4ec3c53ce22a123f65ab337cd02b817b7a4560b3
[pcsx_rearmed.git] / 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 VITA
33 #include <psp2/kernel/sysmem.h>
34 static int sceBlock;
35 #endif
36
37 #include "new_dynarec_config.h"
38 #include "../psxhle.h"
39 #include "../psxinterpreter.h"
40 #include "emu_if.h" //emulator interface
41
42 #define noinline __attribute__((noinline,noclone))
43 #ifndef ARRAY_SIZE
44 #define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
45 #endif
46
47 //#define DISASM
48 //#define assem_debug printf
49 //#define inv_debug printf
50 #define assem_debug(...)
51 #define inv_debug(...)
52
53 #ifdef __i386__
54 #include "assem_x86.h"
55 #endif
56 #ifdef __x86_64__
57 #include "assem_x64.h"
58 #endif
59 #ifdef __arm__
60 #include "assem_arm.h"
61 #endif
62 #ifdef __aarch64__
63 #include "assem_arm64.h"
64 #endif
65
66 #define MAXBLOCK 4096
67 #define MAX_OUTPUT_BLOCK_SIZE 262144
68
69 struct ndrc_mem
70 {
71   u_char translation_cache[1 << TARGET_SIZE_2];
72   struct
73   {
74     struct tramp_insns ops[2048 / sizeof(struct tramp_insns)];
75     const void *f[2048 / sizeof(void *)];
76   } tramp;
77 };
78
79 #ifdef BASE_ADDR_DYNAMIC
80 static struct ndrc_mem *ndrc;
81 #else
82 static struct ndrc_mem ndrc_ __attribute__((aligned(4096)));
83 static struct ndrc_mem *ndrc = &ndrc_;
84 #endif
85
86 // stubs
87 enum stub_type {
88   CC_STUB = 1,
89   FP_STUB = 2,
90   LOADB_STUB = 3,
91   LOADH_STUB = 4,
92   LOADW_STUB = 5,
93   LOADD_STUB = 6,
94   LOADBU_STUB = 7,
95   LOADHU_STUB = 8,
96   STOREB_STUB = 9,
97   STOREH_STUB = 10,
98   STOREW_STUB = 11,
99   STORED_STUB = 12,
100   STORELR_STUB = 13,
101   INVCODE_STUB = 14,
102 };
103
104 struct regstat
105 {
106   signed char regmap_entry[HOST_REGS];
107   signed char regmap[HOST_REGS];
108   uint64_t wasdirty;
109   uint64_t dirty;
110   uint64_t u;
111   u_int wasconst;
112   u_int isconst;
113   u_int loadedconst;             // host regs that have constants loaded
114   u_int waswritten;              // MIPS regs that were used as store base before
115 };
116
117 // note: asm depends on this layout
118 struct ll_entry
119 {
120   u_int vaddr;
121   u_int reg_sv_flags;
122   void *addr;
123   struct ll_entry *next;
124 };
125
126 struct ht_entry
127 {
128   u_int vaddr[2];
129   void *tcaddr[2];
130 };
131
132 struct code_stub
133 {
134   enum stub_type type;
135   void *addr;
136   void *retaddr;
137   u_int a;
138   uintptr_t b;
139   uintptr_t c;
140   u_int d;
141   u_int e;
142 };
143
144 struct link_entry
145 {
146   void *addr;
147   u_int target;
148   u_int ext;
149 };
150
151   // used by asm:
152   u_char *out;
153   struct ht_entry hash_table[65536]  __attribute__((aligned(16)));
154   struct ll_entry *jump_in[4096] __attribute__((aligned(16)));
155   struct ll_entry *jump_dirty[4096];
156
157   static struct ll_entry *jump_out[4096];
158   static u_int start;
159   static u_int *source;
160   static char insn[MAXBLOCK][10];
161   static u_char itype[MAXBLOCK];
162   static u_char opcode[MAXBLOCK];
163   static u_char opcode2[MAXBLOCK];
164   static u_char bt[MAXBLOCK];
165   static u_char rs1[MAXBLOCK];
166   static u_char rs2[MAXBLOCK];
167   static u_char rt1[MAXBLOCK];
168   static u_char rt2[MAXBLOCK];
169   static u_char dep1[MAXBLOCK];
170   static u_char dep2[MAXBLOCK];
171   static u_char lt1[MAXBLOCK];
172   static uint64_t gte_rs[MAXBLOCK]; // gte: 32 data and 32 ctl regs
173   static uint64_t gte_rt[MAXBLOCK];
174   static uint64_t gte_unneeded[MAXBLOCK];
175   static u_int smrv[32]; // speculated MIPS register values
176   static u_int smrv_strong; // mask or regs that are likely to have correct values
177   static u_int smrv_weak; // same, but somewhat less likely
178   static u_int smrv_strong_next; // same, but after current insn executes
179   static u_int smrv_weak_next;
180   static int imm[MAXBLOCK];
181   static u_int ba[MAXBLOCK];
182   static char likely[MAXBLOCK];
183   static char is_ds[MAXBLOCK];
184   static char ooo[MAXBLOCK];
185   static uint64_t unneeded_reg[MAXBLOCK];
186   static uint64_t branch_unneeded_reg[MAXBLOCK];
187   static signed char regmap_pre[MAXBLOCK][HOST_REGS]; // pre-instruction i?
188   // contains 'real' consts at [i] insn, but may differ from what's actually
189   // loaded in host reg as 'final' value is always loaded, see get_final_value()
190   static uint32_t current_constmap[HOST_REGS];
191   static uint32_t constmap[MAXBLOCK][HOST_REGS];
192   static struct regstat regs[MAXBLOCK];
193   static struct regstat branch_regs[MAXBLOCK];
194   static signed char minimum_free_regs[MAXBLOCK];
195   static u_int needed_reg[MAXBLOCK];
196   static u_int wont_dirty[MAXBLOCK];
197   static u_int will_dirty[MAXBLOCK];
198   static int ccadj[MAXBLOCK];
199   static int slen;
200   static void *instr_addr[MAXBLOCK];
201   static struct link_entry link_addr[MAXBLOCK];
202   static int linkcount;
203   static struct code_stub stubs[MAXBLOCK*3];
204   static int stubcount;
205   static u_int literals[1024][2];
206   static int literalcount;
207   static int is_delayslot;
208   static char shadow[1048576]  __attribute__((aligned(16)));
209   static void *copy;
210   static int expirep;
211   static u_int stop_after_jal;
212 #ifndef RAM_FIXED
213   static uintptr_t ram_offset;
214 #else
215   static const uintptr_t ram_offset=0;
216 #endif
217
218   int new_dynarec_hacks;
219   int new_dynarec_did_compile;
220
221   extern int cycle_count; // ... until end of the timeslice, counts -N -> 0
222   extern int last_count;  // last absolute target, often = next_interupt
223   extern int pcaddr;
224   extern int pending_exception;
225   extern int branch_target;
226   extern uintptr_t mini_ht[32][2];
227   extern u_char restore_candidate[512];
228
229   /* registers that may be allocated */
230   /* 1-31 gpr */
231 #define LOREG 32 // lo
232 #define HIREG 33 // hi
233 //#define FSREG 34 // FPU status (FCSR)
234 #define CSREG 35 // Coprocessor status
235 #define CCREG 36 // Cycle count
236 #define INVCP 37 // Pointer to invalid_code
237 //#define MMREG 38 // Pointer to memory_map
238 //#define ROREG 39 // ram offset (if rdram!=0x80000000)
239 #define TEMPREG 40
240 #define FTEMP 40 // FPU temporary register
241 #define PTEMP 41 // Prefetch temporary register
242 //#define TLREG 42 // TLB mapping offset
243 #define RHASH 43 // Return address hash
244 #define RHTBL 44 // Return address hash table address
245 #define RTEMP 45 // JR/JALR address register
246 #define MAXREG 45
247 #define AGEN1 46 // Address generation temporary register
248 //#define AGEN2 47 // Address generation temporary register
249 //#define MGEN1 48 // Maptable address generation temporary register
250 //#define MGEN2 49 // Maptable address generation temporary register
251 #define BTREG 50 // Branch target temporary register
252
253   /* instruction types */
254 #define NOP 0     // No operation
255 #define LOAD 1    // Load
256 #define STORE 2   // Store
257 #define LOADLR 3  // Unaligned load
258 #define STORELR 4 // Unaligned store
259 #define MOV 5     // Move
260 #define ALU 6     // Arithmetic/logic
261 #define MULTDIV 7 // Multiply/divide
262 #define SHIFT 8   // Shift by register
263 #define SHIFTIMM 9// Shift by immediate
264 #define IMM16 10  // 16-bit immediate
265 #define RJUMP 11  // Unconditional jump to register
266 #define UJUMP 12  // Unconditional jump
267 #define CJUMP 13  // Conditional branch (BEQ/BNE/BGTZ/BLEZ)
268 #define SJUMP 14  // Conditional branch (regimm format)
269 #define COP0 15   // Coprocessor 0
270 #define COP1 16   // Coprocessor 1
271 #define C1LS 17   // Coprocessor 1 load/store
272 //#define FJUMP 18  // Conditional branch (floating point)
273 //#define FLOAT 19  // Floating point unit
274 //#define FCONV 20  // Convert integer to float
275 //#define FCOMP 21  // Floating point compare (sets FSREG)
276 #define SYSCALL 22// SYSCALL
277 #define OTHER 23  // Other
278 #define SPAN 24   // Branch/delay slot spans 2 pages
279 #define NI 25     // Not implemented
280 #define HLECALL 26// PCSX fake opcodes for HLE
281 #define COP2 27   // Coprocessor 2 move
282 #define C2LS 28   // Coprocessor 2 load/store
283 #define C2OP 29   // Coprocessor 2 operation
284 #define INTCALL 30// Call interpreter to handle rare corner cases
285
286   /* branch codes */
287 #define TAKEN 1
288 #define NOTTAKEN 2
289 #define NULLDS 3
290
291 #define DJT_1 (void *)1l // no function, just a label in assem_debug log
292 #define DJT_2 (void *)2l
293
294 // asm linkage
295 int new_recompile_block(u_int addr);
296 void *get_addr_ht(u_int vaddr);
297 void invalidate_block(u_int block);
298 void invalidate_addr(u_int addr);
299 void remove_hash(int vaddr);
300 void dyna_linker();
301 void dyna_linker_ds();
302 void verify_code();
303 void verify_code_ds();
304 void cc_interrupt();
305 void fp_exception();
306 void fp_exception_ds();
307 void jump_to_new_pc();
308 void new_dyna_leave();
309
310 // Needed by assembler
311 static void wb_register(signed char r,signed char regmap[],uint64_t dirty);
312 static void wb_dirtys(signed char i_regmap[],uint64_t i_dirty);
313 static void wb_needed_dirtys(signed char i_regmap[],uint64_t i_dirty,int addr);
314 static void load_all_regs(signed char i_regmap[]);
315 static void load_needed_regs(signed char i_regmap[],signed char next_regmap[]);
316 static void load_regs_entry(int t);
317 static void load_all_consts(signed char regmap[],u_int dirty,int i);
318
319 static int verify_dirty(const u_int *ptr);
320 static int get_final_value(int hr, int i, int *value);
321 static void add_stub(enum stub_type type, void *addr, void *retaddr,
322   u_int a, uintptr_t b, uintptr_t c, u_int d, u_int e);
323 static void add_stub_r(enum stub_type type, void *addr, void *retaddr,
324   int i, int addr_reg, struct regstat *i_regs, int ccadj, u_int reglist);
325 static void add_to_linker(void *addr, u_int target, int ext);
326 static void *emit_fastpath_cmp_jump(int i,int addr,int *addr_reg_override);
327 static void *get_direct_memhandler(void *table, u_int addr,
328   enum stub_type type, uintptr_t *addr_host);
329 static void pass_args(int a0, int a1);
330 static void emit_far_jump(const void *f);
331 static void emit_far_call(const void *f);
332
333 static void mprotect_w_x(void *start, void *end, int is_x)
334 {
335 #ifdef NO_WRITE_EXEC
336   #if defined(VITA)
337   // *Open* enables write on all memory that was
338   // allocated by sceKernelAllocMemBlockForVM()?
339   if (is_x)
340     sceKernelCloseVMDomain();
341   else
342     sceKernelOpenVMDomain();
343   #else
344   u_long mstart = (u_long)start & ~4095ul;
345   u_long mend = (u_long)end;
346   if (mprotect((void *)mstart, mend - mstart,
347                PROT_READ | (is_x ? PROT_EXEC : PROT_WRITE)) != 0)
348     SysPrintf("mprotect(%c) failed: %s\n", is_x ? 'x' : 'w', strerror(errno));
349   #endif
350 #endif
351 }
352
353 static void start_tcache_write(void *start, void *end)
354 {
355   mprotect_w_x(start, end, 0);
356 }
357
358 static void end_tcache_write(void *start, void *end)
359 {
360 #if defined(__arm__) || defined(__aarch64__)
361   size_t len = (char *)end - (char *)start;
362   #if   defined(__BLACKBERRY_QNX__)
363   msync(start, len, MS_SYNC | MS_CACHE_ONLY | MS_INVALIDATE_ICACHE);
364   #elif defined(__MACH__)
365   sys_cache_control(kCacheFunctionPrepareForExecution, start, len);
366   #elif defined(VITA)
367   sceKernelSyncVMDomain(sceBlock, start, len);
368   #elif defined(_3DS)
369   ctr_flush_invalidate_cache();
370   #elif defined(__aarch64__)
371   // as of 2021, __clear_cache() is still broken on arm64
372   // so here is a custom one :(
373   clear_cache_arm64(start, end);
374   #else
375   __clear_cache(start, end);
376   #endif
377   (void)len;
378 #endif
379
380   mprotect_w_x(start, end, 1);
381 }
382
383 static void *start_block(void)
384 {
385   u_char *end = out + MAX_OUTPUT_BLOCK_SIZE;
386   if (end > ndrc->translation_cache + sizeof(ndrc->translation_cache))
387     end = ndrc->translation_cache + sizeof(ndrc->translation_cache);
388   start_tcache_write(out, end);
389   return out;
390 }
391
392 static void end_block(void *start)
393 {
394   end_tcache_write(start, out);
395 }
396
397 // also takes care of w^x mappings when patching code
398 static u_int needs_clear_cache[1<<(TARGET_SIZE_2-17)];
399
400 static void mark_clear_cache(void *target)
401 {
402   uintptr_t offset = (u_char *)target - ndrc->translation_cache;
403   u_int mask = 1u << ((offset >> 12) & 31);
404   if (!(needs_clear_cache[offset >> 17] & mask)) {
405     char *start = (char *)((uintptr_t)target & ~4095l);
406     start_tcache_write(start, start + 4095);
407     needs_clear_cache[offset >> 17] |= mask;
408   }
409 }
410
411 // Clearing the cache is rather slow on ARM Linux, so mark the areas
412 // that need to be cleared, and then only clear these areas once.
413 static void do_clear_cache(void)
414 {
415   int i, j;
416   for (i = 0; i < (1<<(TARGET_SIZE_2-17)); i++)
417   {
418     u_int bitmap = needs_clear_cache[i];
419     if (!bitmap)
420       continue;
421     for (j = 0; j < 32; j++)
422     {
423       u_char *start, *end;
424       if (!(bitmap & (1<<j)))
425         continue;
426
427       start = ndrc->translation_cache + i*131072 + j*4096;
428       end = start + 4095;
429       for (j++; j < 32; j++) {
430         if (!(bitmap & (1<<j)))
431           break;
432         end += 4096;
433       }
434       end_tcache_write(start, end);
435     }
436     needs_clear_cache[i] = 0;
437   }
438 }
439
440 //#define DEBUG_CYCLE_COUNT 1
441
442 #define NO_CYCLE_PENALTY_THR 12
443
444 int cycle_multiplier; // 100 for 1.0
445
446 static int CLOCK_ADJUST(int x)
447 {
448   int s=(x>>31)|1;
449   return (x * cycle_multiplier + s * 50) / 100;
450 }
451
452 static u_int get_page(u_int vaddr)
453 {
454   u_int page=vaddr&~0xe0000000;
455   if (page < 0x1000000)
456     page &= ~0x0e00000; // RAM mirrors
457   page>>=12;
458   if(page>2048) page=2048+(page&2047);
459   return page;
460 }
461
462 // no virtual mem in PCSX
463 static u_int get_vpage(u_int vaddr)
464 {
465   return get_page(vaddr);
466 }
467
468 static struct ht_entry *hash_table_get(u_int vaddr)
469 {
470   return &hash_table[((vaddr>>16)^vaddr)&0xFFFF];
471 }
472
473 static void hash_table_add(struct ht_entry *ht_bin, u_int vaddr, void *tcaddr)
474 {
475   ht_bin->vaddr[1] = ht_bin->vaddr[0];
476   ht_bin->tcaddr[1] = ht_bin->tcaddr[0];
477   ht_bin->vaddr[0] = vaddr;
478   ht_bin->tcaddr[0] = tcaddr;
479 }
480
481 // some messy ari64's code, seems to rely on unsigned 32bit overflow
482 static int doesnt_expire_soon(void *tcaddr)
483 {
484   u_int diff = (u_int)((u_char *)tcaddr - out) << (32-TARGET_SIZE_2);
485   return diff > (u_int)(0x60000000 + (MAX_OUTPUT_BLOCK_SIZE << (32-TARGET_SIZE_2)));
486 }
487
488 // Get address from virtual address
489 // This is called from the recompiled JR/JALR instructions
490 void noinline *get_addr(u_int vaddr)
491 {
492   u_int page=get_page(vaddr);
493   u_int vpage=get_vpage(vaddr);
494   struct ll_entry *head;
495   //printf("TRACE: count=%d next=%d (get_addr %x,page %d)\n",Count,next_interupt,vaddr,page);
496   head=jump_in[page];
497   while(head!=NULL) {
498     if(head->vaddr==vaddr) {
499   //printf("TRACE: count=%d next=%d (get_addr match %x: %p)\n",Count,next_interupt,vaddr,head->addr);
500       hash_table_add(hash_table_get(vaddr), vaddr, head->addr);
501       return head->addr;
502     }
503     head=head->next;
504   }
505   head=jump_dirty[vpage];
506   while(head!=NULL) {
507     if(head->vaddr==vaddr) {
508       //printf("TRACE: count=%d next=%d (get_addr match dirty %x: %p)\n",Count,next_interupt,vaddr,head->addr);
509       // Don't restore blocks which are about to expire from the cache
510       if (doesnt_expire_soon(head->addr))
511       if (verify_dirty(head->addr)) {
512         //printf("restore candidate: %x (%d) d=%d\n",vaddr,page,invalid_code[vaddr>>12]);
513         invalid_code[vaddr>>12]=0;
514         inv_code_start=inv_code_end=~0;
515         if(vpage<2048) {
516           restore_candidate[vpage>>3]|=1<<(vpage&7);
517         }
518         else restore_candidate[page>>3]|=1<<(page&7);
519         struct ht_entry *ht_bin = hash_table_get(vaddr);
520         if (ht_bin->vaddr[0] == vaddr)
521           ht_bin->tcaddr[0] = head->addr; // Replace existing entry
522         else
523           hash_table_add(ht_bin, vaddr, head->addr);
524
525         return head->addr;
526       }
527     }
528     head=head->next;
529   }
530   //printf("TRACE: count=%d next=%d (get_addr no-match %x)\n",Count,next_interupt,vaddr);
531   int r=new_recompile_block(vaddr);
532   if(r==0) return get_addr(vaddr);
533   // Execute in unmapped page, generate pagefault execption
534   Status|=2;
535   Cause=(vaddr<<31)|0x8;
536   EPC=(vaddr&1)?vaddr-5:vaddr;
537   BadVAddr=(vaddr&~1);
538   Context=(Context&0xFF80000F)|((BadVAddr>>9)&0x007FFFF0);
539   EntryHi=BadVAddr&0xFFFFE000;
540   return get_addr_ht(0x80000000);
541 }
542 // Look up address in hash table first
543 void *get_addr_ht(u_int vaddr)
544 {
545   //printf("TRACE: count=%d next=%d (get_addr_ht %x)\n",Count,next_interupt,vaddr);
546   const struct ht_entry *ht_bin = hash_table_get(vaddr);
547   if (ht_bin->vaddr[0] == vaddr) return ht_bin->tcaddr[0];
548   if (ht_bin->vaddr[1] == vaddr) return ht_bin->tcaddr[1];
549   return get_addr(vaddr);
550 }
551
552 void clear_all_regs(signed char regmap[])
553 {
554   int hr;
555   for (hr=0;hr<HOST_REGS;hr++) regmap[hr]=-1;
556 }
557
558 static signed char get_reg(const signed char regmap[],int r)
559 {
560   int hr;
561   for (hr=0;hr<HOST_REGS;hr++) if(hr!=EXCLUDE_REG&&regmap[hr]==r) return hr;
562   return -1;
563 }
564
565 // Find a register that is available for two consecutive cycles
566 static signed char get_reg2(signed char regmap1[], const signed char regmap2[], int r)
567 {
568   int hr;
569   for (hr=0;hr<HOST_REGS;hr++) if(hr!=EXCLUDE_REG&&regmap1[hr]==r&&regmap2[hr]==r) return hr;
570   return -1;
571 }
572
573 int count_free_regs(signed char regmap[])
574 {
575   int count=0;
576   int hr;
577   for(hr=0;hr<HOST_REGS;hr++)
578   {
579     if(hr!=EXCLUDE_REG) {
580       if(regmap[hr]<0) count++;
581     }
582   }
583   return count;
584 }
585
586 void dirty_reg(struct regstat *cur,signed char reg)
587 {
588   int hr;
589   if(!reg) return;
590   for (hr=0;hr<HOST_REGS;hr++) {
591     if((cur->regmap[hr]&63)==reg) {
592       cur->dirty|=1<<hr;
593     }
594   }
595 }
596
597 static void set_const(struct regstat *cur, signed char reg, uint32_t value)
598 {
599   int hr;
600   if(!reg) return;
601   for (hr=0;hr<HOST_REGS;hr++) {
602     if(cur->regmap[hr]==reg) {
603       cur->isconst|=1<<hr;
604       current_constmap[hr]=value;
605     }
606   }
607 }
608
609 static void clear_const(struct regstat *cur, signed char reg)
610 {
611   int hr;
612   if(!reg) return;
613   for (hr=0;hr<HOST_REGS;hr++) {
614     if((cur->regmap[hr]&63)==reg) {
615       cur->isconst&=~(1<<hr);
616     }
617   }
618 }
619
620 static int is_const(struct regstat *cur, signed char reg)
621 {
622   int hr;
623   if(reg<0) return 0;
624   if(!reg) return 1;
625   for (hr=0;hr<HOST_REGS;hr++) {
626     if((cur->regmap[hr]&63)==reg) {
627       return (cur->isconst>>hr)&1;
628     }
629   }
630   return 0;
631 }
632
633 static uint32_t get_const(struct regstat *cur, signed char reg)
634 {
635   int hr;
636   if(!reg) return 0;
637   for (hr=0;hr<HOST_REGS;hr++) {
638     if(cur->regmap[hr]==reg) {
639       return current_constmap[hr];
640     }
641   }
642   SysPrintf("Unknown constant in r%d\n",reg);
643   abort();
644 }
645
646 // Least soon needed registers
647 // Look at the next ten instructions and see which registers
648 // will be used.  Try not to reallocate these.
649 void lsn(u_char hsn[], int i, int *preferred_reg)
650 {
651   int j;
652   int b=-1;
653   for(j=0;j<9;j++)
654   {
655     if(i+j>=slen) {
656       j=slen-i-1;
657       break;
658     }
659     if(itype[i+j]==UJUMP||itype[i+j]==RJUMP||(source[i+j]>>16)==0x1000)
660     {
661       // Don't go past an unconditonal jump
662       j++;
663       break;
664     }
665   }
666   for(;j>=0;j--)
667   {
668     if(rs1[i+j]) hsn[rs1[i+j]]=j;
669     if(rs2[i+j]) hsn[rs2[i+j]]=j;
670     if(rt1[i+j]) hsn[rt1[i+j]]=j;
671     if(rt2[i+j]) hsn[rt2[i+j]]=j;
672     if(itype[i+j]==STORE || itype[i+j]==STORELR) {
673       // Stores can allocate zero
674       hsn[rs1[i+j]]=j;
675       hsn[rs2[i+j]]=j;
676     }
677     // On some architectures stores need invc_ptr
678     #if defined(HOST_IMM8)
679     if(itype[i+j]==STORE || itype[i+j]==STORELR || (opcode[i+j]&0x3b)==0x39 || (opcode[i+j]&0x3b)==0x3a) {
680       hsn[INVCP]=j;
681     }
682     #endif
683     if(i+j>=0&&(itype[i+j]==UJUMP||itype[i+j]==CJUMP||itype[i+j]==SJUMP))
684     {
685       hsn[CCREG]=j;
686       b=j;
687     }
688   }
689   if(b>=0)
690   {
691     if(ba[i+b]>=start && ba[i+b]<(start+slen*4))
692     {
693       // Follow first branch
694       int t=(ba[i+b]-start)>>2;
695       j=7-b;if(t+j>=slen) j=slen-t-1;
696       for(;j>=0;j--)
697       {
698         if(rs1[t+j]) if(hsn[rs1[t+j]]>j+b+2) hsn[rs1[t+j]]=j+b+2;
699         if(rs2[t+j]) if(hsn[rs2[t+j]]>j+b+2) hsn[rs2[t+j]]=j+b+2;
700         //if(rt1[t+j]) if(hsn[rt1[t+j]]>j+b+2) hsn[rt1[t+j]]=j+b+2;
701         //if(rt2[t+j]) if(hsn[rt2[t+j]]>j+b+2) hsn[rt2[t+j]]=j+b+2;
702       }
703     }
704     // TODO: preferred register based on backward branch
705   }
706   // Delay slot should preferably not overwrite branch conditions or cycle count
707   if(i>0&&(itype[i-1]==RJUMP||itype[i-1]==UJUMP||itype[i-1]==CJUMP||itype[i-1]==SJUMP)) {
708     if(rs1[i-1]) if(hsn[rs1[i-1]]>1) hsn[rs1[i-1]]=1;
709     if(rs2[i-1]) if(hsn[rs2[i-1]]>1) hsn[rs2[i-1]]=1;
710     hsn[CCREG]=1;
711     // ...or hash tables
712     hsn[RHASH]=1;
713     hsn[RHTBL]=1;
714   }
715   // Coprocessor load/store needs FTEMP, even if not declared
716   if(itype[i]==C1LS||itype[i]==C2LS) {
717     hsn[FTEMP]=0;
718   }
719   // Load L/R also uses FTEMP as a temporary register
720   if(itype[i]==LOADLR) {
721     hsn[FTEMP]=0;
722   }
723   // Also SWL/SWR/SDL/SDR
724   if(opcode[i]==0x2a||opcode[i]==0x2e||opcode[i]==0x2c||opcode[i]==0x2d) {
725     hsn[FTEMP]=0;
726   }
727   // Don't remove the miniht registers
728   if(itype[i]==UJUMP||itype[i]==RJUMP)
729   {
730     hsn[RHASH]=0;
731     hsn[RHTBL]=0;
732   }
733 }
734
735 // We only want to allocate registers if we're going to use them again soon
736 int needed_again(int r, int i)
737 {
738   int j;
739   int b=-1;
740   int rn=10;
741
742   if(i>0&&(itype[i-1]==UJUMP||itype[i-1]==RJUMP||(source[i-1]>>16)==0x1000))
743   {
744     if(ba[i-1]<start || ba[i-1]>start+slen*4-4)
745       return 0; // Don't need any registers if exiting the block
746   }
747   for(j=0;j<9;j++)
748   {
749     if(i+j>=slen) {
750       j=slen-i-1;
751       break;
752     }
753     if(itype[i+j]==UJUMP||itype[i+j]==RJUMP||(source[i+j]>>16)==0x1000)
754     {
755       // Don't go past an unconditonal jump
756       j++;
757       break;
758     }
759     if(itype[i+j]==SYSCALL||itype[i+j]==HLECALL||itype[i+j]==INTCALL||((source[i+j]&0xfc00003f)==0x0d))
760     {
761       break;
762     }
763   }
764   for(;j>=1;j--)
765   {
766     if(rs1[i+j]==r) rn=j;
767     if(rs2[i+j]==r) rn=j;
768     if((unneeded_reg[i+j]>>r)&1) rn=10;
769     if(i+j>=0&&(itype[i+j]==UJUMP||itype[i+j]==CJUMP||itype[i+j]==SJUMP))
770     {
771       b=j;
772     }
773   }
774   /*
775   if(b>=0)
776   {
777     if(ba[i+b]>=start && ba[i+b]<(start+slen*4))
778     {
779       // Follow first branch
780       int o=rn;
781       int t=(ba[i+b]-start)>>2;
782       j=7-b;if(t+j>=slen) j=slen-t-1;
783       for(;j>=0;j--)
784       {
785         if(!((unneeded_reg[t+j]>>r)&1)) {
786           if(rs1[t+j]==r) if(rn>j+b+2) rn=j+b+2;
787           if(rs2[t+j]==r) if(rn>j+b+2) rn=j+b+2;
788         }
789         else rn=o;
790       }
791     }
792   }*/
793   if(rn<10) return 1;
794   (void)b;
795   return 0;
796 }
797
798 // Try to match register allocations at the end of a loop with those
799 // at the beginning
800 int loop_reg(int i, int r, int hr)
801 {
802   int j,k;
803   for(j=0;j<9;j++)
804   {
805     if(i+j>=slen) {
806       j=slen-i-1;
807       break;
808     }
809     if(itype[i+j]==UJUMP||itype[i+j]==RJUMP||(source[i+j]>>16)==0x1000)
810     {
811       // Don't go past an unconditonal jump
812       j++;
813       break;
814     }
815   }
816   k=0;
817   if(i>0){
818     if(itype[i-1]==UJUMP||itype[i-1]==CJUMP||itype[i-1]==SJUMP)
819       k--;
820   }
821   for(;k<j;k++)
822   {
823     assert(r < 64);
824     if((unneeded_reg[i+k]>>r)&1) return hr;
825     if(i+k>=0&&(itype[i+k]==UJUMP||itype[i+k]==CJUMP||itype[i+k]==SJUMP))
826     {
827       if(ba[i+k]>=start && ba[i+k]<(start+i*4))
828       {
829         int t=(ba[i+k]-start)>>2;
830         int reg=get_reg(regs[t].regmap_entry,r);
831         if(reg>=0) return reg;
832         //reg=get_reg(regs[t+1].regmap_entry,r);
833         //if(reg>=0) return reg;
834       }
835     }
836   }
837   return hr;
838 }
839
840
841 // Allocate every register, preserving source/target regs
842 void alloc_all(struct regstat *cur,int i)
843 {
844   int hr;
845
846   for(hr=0;hr<HOST_REGS;hr++) {
847     if(hr!=EXCLUDE_REG) {
848       if(((cur->regmap[hr]&63)!=rs1[i])&&((cur->regmap[hr]&63)!=rs2[i])&&
849          ((cur->regmap[hr]&63)!=rt1[i])&&((cur->regmap[hr]&63)!=rt2[i]))
850       {
851         cur->regmap[hr]=-1;
852         cur->dirty&=~(1<<hr);
853       }
854       // Don't need zeros
855       if((cur->regmap[hr]&63)==0)
856       {
857         cur->regmap[hr]=-1;
858         cur->dirty&=~(1<<hr);
859       }
860     }
861   }
862 }
863
864 #ifndef NDEBUG
865 static int host_tempreg_in_use;
866
867 static void host_tempreg_acquire(void)
868 {
869   assert(!host_tempreg_in_use);
870   host_tempreg_in_use = 1;
871 }
872
873 static void host_tempreg_release(void)
874 {
875   host_tempreg_in_use = 0;
876 }
877 #else
878 static void host_tempreg_acquire(void) {}
879 static void host_tempreg_release(void) {}
880 #endif
881
882 #ifdef DRC_DBG
883 extern void gen_interupt();
884 extern void do_insn_cmp();
885 #define FUNCNAME(f) { f, " " #f }
886 static const struct {
887   void *addr;
888   const char *name;
889 } function_names[] = {
890   FUNCNAME(cc_interrupt),
891   FUNCNAME(gen_interupt),
892   FUNCNAME(get_addr_ht),
893   FUNCNAME(get_addr),
894   FUNCNAME(jump_handler_read8),
895   FUNCNAME(jump_handler_read16),
896   FUNCNAME(jump_handler_read32),
897   FUNCNAME(jump_handler_write8),
898   FUNCNAME(jump_handler_write16),
899   FUNCNAME(jump_handler_write32),
900   FUNCNAME(invalidate_addr),
901   FUNCNAME(jump_to_new_pc),
902   FUNCNAME(new_dyna_leave),
903   FUNCNAME(pcsx_mtc0),
904   FUNCNAME(pcsx_mtc0_ds),
905   FUNCNAME(do_insn_cmp),
906 #ifdef __arm__
907   FUNCNAME(verify_code),
908 #endif
909 };
910
911 static const char *func_name(const void *a)
912 {
913   int i;
914   for (i = 0; i < sizeof(function_names)/sizeof(function_names[0]); i++)
915     if (function_names[i].addr == a)
916       return function_names[i].name;
917   return "";
918 }
919 #else
920 #define func_name(x) ""
921 #endif
922
923 #ifdef __i386__
924 #include "assem_x86.c"
925 #endif
926 #ifdef __x86_64__
927 #include "assem_x64.c"
928 #endif
929 #ifdef __arm__
930 #include "assem_arm.c"
931 #endif
932 #ifdef __aarch64__
933 #include "assem_arm64.c"
934 #endif
935
936 static void *get_trampoline(const void *f)
937 {
938   size_t i;
939
940   for (i = 0; i < ARRAY_SIZE(ndrc->tramp.f); i++) {
941     if (ndrc->tramp.f[i] == f || ndrc->tramp.f[i] == NULL)
942       break;
943   }
944   if (i == ARRAY_SIZE(ndrc->tramp.f)) {
945     SysPrintf("trampoline table is full, last func %p\n", f);
946     abort();
947   }
948   if (ndrc->tramp.f[i] == NULL) {
949     start_tcache_write(&ndrc->tramp.f[i], &ndrc->tramp.f[i + 1]);
950     ndrc->tramp.f[i] = f;
951     end_tcache_write(&ndrc->tramp.f[i], &ndrc->tramp.f[i + 1]);
952   }
953   return &ndrc->tramp.ops[i];
954 }
955
956 static void emit_far_jump(const void *f)
957 {
958   if (can_jump_or_call(f)) {
959     emit_jmp(f);
960     return;
961   }
962
963   f = get_trampoline(f);
964   emit_jmp(f);
965 }
966
967 static void emit_far_call(const void *f)
968 {
969   if (can_jump_or_call(f)) {
970     emit_call(f);
971     return;
972   }
973
974   f = get_trampoline(f);
975   emit_call(f);
976 }
977
978 // Add virtual address mapping to linked list
979 void ll_add(struct ll_entry **head,int vaddr,void *addr)
980 {
981   struct ll_entry *new_entry;
982   new_entry=malloc(sizeof(struct ll_entry));
983   assert(new_entry!=NULL);
984   new_entry->vaddr=vaddr;
985   new_entry->reg_sv_flags=0;
986   new_entry->addr=addr;
987   new_entry->next=*head;
988   *head=new_entry;
989 }
990
991 void ll_add_flags(struct ll_entry **head,int vaddr,u_int reg_sv_flags,void *addr)
992 {
993   ll_add(head,vaddr,addr);
994   (*head)->reg_sv_flags=reg_sv_flags;
995 }
996
997 // Check if an address is already compiled
998 // but don't return addresses which are about to expire from the cache
999 void *check_addr(u_int vaddr)
1000 {
1001   struct ht_entry *ht_bin = hash_table_get(vaddr);
1002   size_t i;
1003   for (i = 0; i < ARRAY_SIZE(ht_bin->vaddr); i++) {
1004     if (ht_bin->vaddr[i] == vaddr)
1005       if (doesnt_expire_soon((u_char *)ht_bin->tcaddr[i] - MAX_OUTPUT_BLOCK_SIZE))
1006         if (isclean(ht_bin->tcaddr[i]))
1007           return ht_bin->tcaddr[i];
1008   }
1009   u_int page=get_page(vaddr);
1010   struct ll_entry *head;
1011   head=jump_in[page];
1012   while (head != NULL) {
1013     if (head->vaddr == vaddr) {
1014       if (doesnt_expire_soon(head->addr)) {
1015         // Update existing entry with current address
1016         if (ht_bin->vaddr[0] == vaddr) {
1017           ht_bin->tcaddr[0] = head->addr;
1018           return head->addr;
1019         }
1020         if (ht_bin->vaddr[1] == vaddr) {
1021           ht_bin->tcaddr[1] = head->addr;
1022           return head->addr;
1023         }
1024         // Insert into hash table with low priority.
1025         // Don't evict existing entries, as they are probably
1026         // addresses that are being accessed frequently.
1027         if (ht_bin->vaddr[0] == -1) {
1028           ht_bin->vaddr[0] = vaddr;
1029           ht_bin->tcaddr[0] = head->addr;
1030         }
1031         else if (ht_bin->vaddr[1] == -1) {
1032           ht_bin->vaddr[1] = vaddr;
1033           ht_bin->tcaddr[1] = head->addr;
1034         }
1035         return head->addr;
1036       }
1037     }
1038     head=head->next;
1039   }
1040   return 0;
1041 }
1042
1043 void remove_hash(int vaddr)
1044 {
1045   //printf("remove hash: %x\n",vaddr);
1046   struct ht_entry *ht_bin = hash_table_get(vaddr);
1047   if (ht_bin->vaddr[1] == vaddr) {
1048     ht_bin->vaddr[1] = -1;
1049     ht_bin->tcaddr[1] = NULL;
1050   }
1051   if (ht_bin->vaddr[0] == vaddr) {
1052     ht_bin->vaddr[0] = ht_bin->vaddr[1];
1053     ht_bin->tcaddr[0] = ht_bin->tcaddr[1];
1054     ht_bin->vaddr[1] = -1;
1055     ht_bin->tcaddr[1] = NULL;
1056   }
1057 }
1058
1059 void ll_remove_matching_addrs(struct ll_entry **head,uintptr_t addr,int shift)
1060 {
1061   struct ll_entry *next;
1062   while(*head) {
1063     if(((uintptr_t)((*head)->addr)>>shift)==(addr>>shift) ||
1064        ((uintptr_t)((*head)->addr-MAX_OUTPUT_BLOCK_SIZE)>>shift)==(addr>>shift))
1065     {
1066       inv_debug("EXP: Remove pointer to %p (%x)\n",(*head)->addr,(*head)->vaddr);
1067       remove_hash((*head)->vaddr);
1068       next=(*head)->next;
1069       free(*head);
1070       *head=next;
1071     }
1072     else
1073     {
1074       head=&((*head)->next);
1075     }
1076   }
1077 }
1078
1079 // Remove all entries from linked list
1080 void ll_clear(struct ll_entry **head)
1081 {
1082   struct ll_entry *cur;
1083   struct ll_entry *next;
1084   if((cur=*head)) {
1085     *head=0;
1086     while(cur) {
1087       next=cur->next;
1088       free(cur);
1089       cur=next;
1090     }
1091   }
1092 }
1093
1094 // Dereference the pointers and remove if it matches
1095 static void ll_kill_pointers(struct ll_entry *head,uintptr_t addr,int shift)
1096 {
1097   while(head) {
1098     uintptr_t ptr = (uintptr_t)get_pointer(head->addr);
1099     inv_debug("EXP: Lookup pointer to %lx at %p (%x)\n",(long)ptr,head->addr,head->vaddr);
1100     if(((ptr>>shift)==(addr>>shift)) ||
1101        (((ptr-MAX_OUTPUT_BLOCK_SIZE)>>shift)==(addr>>shift)))
1102     {
1103       inv_debug("EXP: Kill pointer at %p (%x)\n",head->addr,head->vaddr);
1104       void *host_addr=find_extjump_insn(head->addr);
1105       mark_clear_cache(host_addr);
1106       set_jump_target(host_addr, head->addr);
1107     }
1108     head=head->next;
1109   }
1110 }
1111
1112 // This is called when we write to a compiled block (see do_invstub)
1113 static void invalidate_page(u_int page)
1114 {
1115   struct ll_entry *head;
1116   struct ll_entry *next;
1117   head=jump_in[page];
1118   jump_in[page]=0;
1119   while(head!=NULL) {
1120     inv_debug("INVALIDATE: %x\n",head->vaddr);
1121     remove_hash(head->vaddr);
1122     next=head->next;
1123     free(head);
1124     head=next;
1125   }
1126   head=jump_out[page];
1127   jump_out[page]=0;
1128   while(head!=NULL) {
1129     inv_debug("INVALIDATE: kill pointer to %x (%p)\n",head->vaddr,head->addr);
1130     void *host_addr=find_extjump_insn(head->addr);
1131     mark_clear_cache(host_addr);
1132     set_jump_target(host_addr, head->addr);
1133     next=head->next;
1134     free(head);
1135     head=next;
1136   }
1137 }
1138
1139 static void invalidate_block_range(u_int block, u_int first, u_int last)
1140 {
1141   u_int page=get_page(block<<12);
1142   //printf("first=%d last=%d\n",first,last);
1143   invalidate_page(page);
1144   assert(first+5>page); // NB: this assumes MAXBLOCK<=4096 (4 pages)
1145   assert(last<page+5);
1146   // Invalidate the adjacent pages if a block crosses a 4K boundary
1147   while(first<page) {
1148     invalidate_page(first);
1149     first++;
1150   }
1151   for(first=page+1;first<last;first++) {
1152     invalidate_page(first);
1153   }
1154   do_clear_cache();
1155
1156   // Don't trap writes
1157   invalid_code[block]=1;
1158
1159   #ifdef USE_MINI_HT
1160   memset(mini_ht,-1,sizeof(mini_ht));
1161   #endif
1162 }
1163
1164 void invalidate_block(u_int block)
1165 {
1166   u_int page=get_page(block<<12);
1167   u_int vpage=get_vpage(block<<12);
1168   inv_debug("INVALIDATE: %x (%d)\n",block<<12,page);
1169   //inv_debug("invalid_code[block]=%d\n",invalid_code[block]);
1170   u_int first,last;
1171   first=last=page;
1172   struct ll_entry *head;
1173   head=jump_dirty[vpage];
1174   //printf("page=%d vpage=%d\n",page,vpage);
1175   while(head!=NULL) {
1176     if(vpage>2047||(head->vaddr>>12)==block) { // Ignore vaddr hash collision
1177       u_char *start, *end;
1178       get_bounds(head->addr, &start, &end);
1179       //printf("start: %p end: %p\n", start, end);
1180       if (page < 2048 && start >= rdram && end < rdram+RAM_SIZE) {
1181         if (((start-rdram)>>12) <= page && ((end-1-rdram)>>12) >= page) {
1182           if ((((start-rdram)>>12)&2047) < first) first = ((start-rdram)>>12)&2047;
1183           if ((((end-1-rdram)>>12)&2047) > last)  last = ((end-1-rdram)>>12)&2047;
1184         }
1185       }
1186     }
1187     head=head->next;
1188   }
1189   invalidate_block_range(block,first,last);
1190 }
1191
1192 void invalidate_addr(u_int addr)
1193 {
1194   //static int rhits;
1195   // this check is done by the caller
1196   //if (inv_code_start<=addr&&addr<=inv_code_end) { rhits++; return; }
1197   u_int page=get_vpage(addr);
1198   if(page<2048) { // RAM
1199     struct ll_entry *head;
1200     u_int addr_min=~0, addr_max=0;
1201     u_int mask=RAM_SIZE-1;
1202     u_int addr_main=0x80000000|(addr&mask);
1203     int pg1;
1204     inv_code_start=addr_main&~0xfff;
1205     inv_code_end=addr_main|0xfff;
1206     pg1=page;
1207     if (pg1>0) {
1208       // must check previous page too because of spans..
1209       pg1--;
1210       inv_code_start-=0x1000;
1211     }
1212     for(;pg1<=page;pg1++) {
1213       for(head=jump_dirty[pg1];head!=NULL;head=head->next) {
1214         u_char *start_h, *end_h;
1215         u_int start, end;
1216         get_bounds(head->addr, &start_h, &end_h);
1217         start = (uintptr_t)start_h - ram_offset;
1218         end = (uintptr_t)end_h - ram_offset;
1219         if(start<=addr_main&&addr_main<end) {
1220           if(start<addr_min) addr_min=start;
1221           if(end>addr_max) addr_max=end;
1222         }
1223         else if(addr_main<start) {
1224           if(start<inv_code_end)
1225             inv_code_end=start-1;
1226         }
1227         else {
1228           if(end>inv_code_start)
1229             inv_code_start=end;
1230         }
1231       }
1232     }
1233     if (addr_min!=~0) {
1234       inv_debug("INV ADDR: %08x hit %08x-%08x\n", addr, addr_min, addr_max);
1235       inv_code_start=inv_code_end=~0;
1236       invalidate_block_range(addr>>12,(addr_min&mask)>>12,(addr_max&mask)>>12);
1237       return;
1238     }
1239     else {
1240       inv_code_start=(addr&~mask)|(inv_code_start&mask);
1241       inv_code_end=(addr&~mask)|(inv_code_end&mask);
1242       inv_debug("INV ADDR: %08x miss, inv %08x-%08x, sk %d\n", addr, inv_code_start, inv_code_end, 0);
1243       return;
1244     }
1245   }
1246   invalidate_block(addr>>12);
1247 }
1248
1249 // This is called when loading a save state.
1250 // Anything could have changed, so invalidate everything.
1251 void invalidate_all_pages(void)
1252 {
1253   u_int page;
1254   for(page=0;page<4096;page++)
1255     invalidate_page(page);
1256   for(page=0;page<1048576;page++)
1257     if(!invalid_code[page]) {
1258       restore_candidate[(page&2047)>>3]|=1<<(page&7);
1259       restore_candidate[((page&2047)>>3)+256]|=1<<(page&7);
1260     }
1261   #ifdef USE_MINI_HT
1262   memset(mini_ht,-1,sizeof(mini_ht));
1263   #endif
1264   do_clear_cache();
1265 }
1266
1267 static void do_invstub(int n)
1268 {
1269   literal_pool(20);
1270   u_int reglist=stubs[n].a;
1271   set_jump_target(stubs[n].addr, out);
1272   save_regs(reglist);
1273   if(stubs[n].b!=0) emit_mov(stubs[n].b,0);
1274   emit_far_call(invalidate_addr);
1275   restore_regs(reglist);
1276   emit_jmp(stubs[n].retaddr); // return address
1277 }
1278
1279 // Add an entry to jump_out after making a link
1280 // src should point to code by emit_extjump2()
1281 void add_link(u_int vaddr,void *src)
1282 {
1283   u_int page=get_page(vaddr);
1284   inv_debug("add_link: %p -> %x (%d)\n",src,vaddr,page);
1285   check_extjump2(src);
1286   ll_add(jump_out+page,vaddr,src);
1287   //void *ptr=get_pointer(src);
1288   //inv_debug("add_link: Pointer is to %p\n",ptr);
1289 }
1290
1291 // If a code block was found to be unmodified (bit was set in
1292 // restore_candidate) and it remains unmodified (bit is clear
1293 // in invalid_code) then move the entries for that 4K page from
1294 // the dirty list to the clean list.
1295 void clean_blocks(u_int page)
1296 {
1297   struct ll_entry *head;
1298   inv_debug("INV: clean_blocks page=%d\n",page);
1299   head=jump_dirty[page];
1300   while(head!=NULL) {
1301     if(!invalid_code[head->vaddr>>12]) {
1302       // Don't restore blocks which are about to expire from the cache
1303       if (doesnt_expire_soon(head->addr)) {
1304         if(verify_dirty(head->addr)) {
1305           u_char *start, *end;
1306           //printf("Possibly Restore %x (%p)\n",head->vaddr, head->addr);
1307           u_int i;
1308           u_int inv=0;
1309           get_bounds(head->addr, &start, &end);
1310           if (start - rdram < RAM_SIZE) {
1311             for (i = (start-rdram+0x80000000)>>12; i <= (end-1-rdram+0x80000000)>>12; i++) {
1312               inv|=invalid_code[i];
1313             }
1314           }
1315           else if((signed int)head->vaddr>=(signed int)0x80000000+RAM_SIZE) {
1316             inv=1;
1317           }
1318           if(!inv) {
1319             void *clean_addr = get_clean_addr(head->addr);
1320             if (doesnt_expire_soon(clean_addr)) {
1321               u_int ppage=page;
1322               inv_debug("INV: Restored %x (%p/%p)\n",head->vaddr, head->addr, clean_addr);
1323               //printf("page=%x, addr=%x\n",page,head->vaddr);
1324               //assert(head->vaddr>>12==(page|0x80000));
1325               ll_add_flags(jump_in+ppage,head->vaddr,head->reg_sv_flags,clean_addr);
1326               struct ht_entry *ht_bin = hash_table_get(head->vaddr);
1327               if (ht_bin->vaddr[0] == head->vaddr)
1328                 ht_bin->tcaddr[0] = clean_addr; // Replace existing entry
1329               if (ht_bin->vaddr[1] == head->vaddr)
1330                 ht_bin->tcaddr[1] = clean_addr; // Replace existing entry
1331             }
1332           }
1333         }
1334       }
1335     }
1336     head=head->next;
1337   }
1338 }
1339
1340 /* Register allocation */
1341
1342 // Note: registers are allocated clean (unmodified state)
1343 // if you intend to modify the register, you must call dirty_reg().
1344 static void alloc_reg(struct regstat *cur,int i,signed char reg)
1345 {
1346   int r,hr;
1347   int preferred_reg = (reg&7);
1348   if(reg==CCREG) preferred_reg=HOST_CCREG;
1349   if(reg==PTEMP||reg==FTEMP) preferred_reg=12;
1350
1351   // Don't allocate unused registers
1352   if((cur->u>>reg)&1) return;
1353
1354   // see if it's already allocated
1355   for(hr=0;hr<HOST_REGS;hr++)
1356   {
1357     if(cur->regmap[hr]==reg) return;
1358   }
1359
1360   // Keep the same mapping if the register was already allocated in a loop
1361   preferred_reg = loop_reg(i,reg,preferred_reg);
1362
1363   // Try to allocate the preferred register
1364   if(cur->regmap[preferred_reg]==-1) {
1365     cur->regmap[preferred_reg]=reg;
1366     cur->dirty&=~(1<<preferred_reg);
1367     cur->isconst&=~(1<<preferred_reg);
1368     return;
1369   }
1370   r=cur->regmap[preferred_reg];
1371   assert(r < 64);
1372   if((cur->u>>r)&1) {
1373     cur->regmap[preferred_reg]=reg;
1374     cur->dirty&=~(1<<preferred_reg);
1375     cur->isconst&=~(1<<preferred_reg);
1376     return;
1377   }
1378
1379   // Clear any unneeded registers
1380   // We try to keep the mapping consistent, if possible, because it
1381   // makes branches easier (especially loops).  So we try to allocate
1382   // first (see above) before removing old mappings.  If this is not
1383   // possible then go ahead and clear out the registers that are no
1384   // longer needed.
1385   for(hr=0;hr<HOST_REGS;hr++)
1386   {
1387     r=cur->regmap[hr];
1388     if(r>=0) {
1389       assert(r < 64);
1390       if((cur->u>>r)&1) {cur->regmap[hr]=-1;break;}
1391     }
1392   }
1393   // Try to allocate any available register, but prefer
1394   // registers that have not been used recently.
1395   if(i>0) {
1396     for(hr=0;hr<HOST_REGS;hr++) {
1397       if(hr!=EXCLUDE_REG&&cur->regmap[hr]==-1) {
1398         if(regs[i-1].regmap[hr]!=rs1[i-1]&&regs[i-1].regmap[hr]!=rs2[i-1]&&regs[i-1].regmap[hr]!=rt1[i-1]&&regs[i-1].regmap[hr]!=rt2[i-1]) {
1399           cur->regmap[hr]=reg;
1400           cur->dirty&=~(1<<hr);
1401           cur->isconst&=~(1<<hr);
1402           return;
1403         }
1404       }
1405     }
1406   }
1407   // Try to allocate any available register
1408   for(hr=0;hr<HOST_REGS;hr++) {
1409     if(hr!=EXCLUDE_REG&&cur->regmap[hr]==-1) {
1410       cur->regmap[hr]=reg;
1411       cur->dirty&=~(1<<hr);
1412       cur->isconst&=~(1<<hr);
1413       return;
1414     }
1415   }
1416
1417   // Ok, now we have to evict someone
1418   // Pick a register we hopefully won't need soon
1419   u_char hsn[MAXREG+1];
1420   memset(hsn,10,sizeof(hsn));
1421   int j;
1422   lsn(hsn,i,&preferred_reg);
1423   //printf("eax=%d ecx=%d edx=%d ebx=%d ebp=%d esi=%d edi=%d\n",cur->regmap[0],cur->regmap[1],cur->regmap[2],cur->regmap[3],cur->regmap[5],cur->regmap[6],cur->regmap[7]);
1424   //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]);
1425   if(i>0) {
1426     // Don't evict the cycle count at entry points, otherwise the entry
1427     // stub will have to write it.
1428     if(bt[i]&&hsn[CCREG]>2) hsn[CCREG]=2;
1429     if(i>1&&hsn[CCREG]>2&&(itype[i-2]==RJUMP||itype[i-2]==UJUMP||itype[i-2]==CJUMP||itype[i-2]==SJUMP)) hsn[CCREG]=2;
1430     for(j=10;j>=3;j--)
1431     {
1432       // Alloc preferred register if available
1433       if(hsn[r=cur->regmap[preferred_reg]&63]==j) {
1434         for(hr=0;hr<HOST_REGS;hr++) {
1435           // Evict both parts of a 64-bit register
1436           if((cur->regmap[hr]&63)==r) {
1437             cur->regmap[hr]=-1;
1438             cur->dirty&=~(1<<hr);
1439             cur->isconst&=~(1<<hr);
1440           }
1441         }
1442         cur->regmap[preferred_reg]=reg;
1443         return;
1444       }
1445       for(r=1;r<=MAXREG;r++)
1446       {
1447         if(hsn[r]==j&&r!=rs1[i-1]&&r!=rs2[i-1]&&r!=rt1[i-1]&&r!=rt2[i-1]) {
1448           for(hr=0;hr<HOST_REGS;hr++) {
1449             if(hr!=HOST_CCREG||j<hsn[CCREG]) {
1450               if(cur->regmap[hr]==r) {
1451                 cur->regmap[hr]=reg;
1452                 cur->dirty&=~(1<<hr);
1453                 cur->isconst&=~(1<<hr);
1454                 return;
1455               }
1456             }
1457           }
1458         }
1459       }
1460     }
1461   }
1462   for(j=10;j>=0;j--)
1463   {
1464     for(r=1;r<=MAXREG;r++)
1465     {
1466       if(hsn[r]==j) {
1467         for(hr=0;hr<HOST_REGS;hr++) {
1468           if(cur->regmap[hr]==r) {
1469             cur->regmap[hr]=reg;
1470             cur->dirty&=~(1<<hr);
1471             cur->isconst&=~(1<<hr);
1472             return;
1473           }
1474         }
1475       }
1476     }
1477   }
1478   SysPrintf("This shouldn't happen (alloc_reg)");abort();
1479 }
1480
1481 // Allocate a temporary register.  This is done without regard to
1482 // dirty status or whether the register we request is on the unneeded list
1483 // Note: This will only allocate one register, even if called multiple times
1484 static void alloc_reg_temp(struct regstat *cur,int i,signed char reg)
1485 {
1486   int r,hr;
1487   int preferred_reg = -1;
1488
1489   // see if it's already allocated
1490   for(hr=0;hr<HOST_REGS;hr++)
1491   {
1492     if(hr!=EXCLUDE_REG&&cur->regmap[hr]==reg) return;
1493   }
1494
1495   // Try to allocate any available register
1496   for(hr=HOST_REGS-1;hr>=0;hr--) {
1497     if(hr!=EXCLUDE_REG&&cur->regmap[hr]==-1) {
1498       cur->regmap[hr]=reg;
1499       cur->dirty&=~(1<<hr);
1500       cur->isconst&=~(1<<hr);
1501       return;
1502     }
1503   }
1504
1505   // Find an unneeded register
1506   for(hr=HOST_REGS-1;hr>=0;hr--)
1507   {
1508     r=cur->regmap[hr];
1509     if(r>=0) {
1510       assert(r < 64);
1511       if((cur->u>>r)&1) {
1512         if(i==0||((unneeded_reg[i-1]>>r)&1)) {
1513           cur->regmap[hr]=reg;
1514           cur->dirty&=~(1<<hr);
1515           cur->isconst&=~(1<<hr);
1516           return;
1517         }
1518       }
1519     }
1520   }
1521
1522   // Ok, now we have to evict someone
1523   // Pick a register we hopefully won't need soon
1524   // TODO: we might want to follow unconditional jumps here
1525   // TODO: get rid of dupe code and make this into a function
1526   u_char hsn[MAXREG+1];
1527   memset(hsn,10,sizeof(hsn));
1528   int j;
1529   lsn(hsn,i,&preferred_reg);
1530   //printf("hsn: %d %d %d %d %d %d %d\n",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]);
1531   if(i>0) {
1532     // Don't evict the cycle count at entry points, otherwise the entry
1533     // stub will have to write it.
1534     if(bt[i]&&hsn[CCREG]>2) hsn[CCREG]=2;
1535     if(i>1&&hsn[CCREG]>2&&(itype[i-2]==RJUMP||itype[i-2]==UJUMP||itype[i-2]==CJUMP||itype[i-2]==SJUMP)) hsn[CCREG]=2;
1536     for(j=10;j>=3;j--)
1537     {
1538       for(r=1;r<=MAXREG;r++)
1539       {
1540         if(hsn[r]==j&&r!=rs1[i-1]&&r!=rs2[i-1]&&r!=rt1[i-1]&&r!=rt2[i-1]) {
1541           for(hr=0;hr<HOST_REGS;hr++) {
1542             if(hr!=HOST_CCREG||hsn[CCREG]>2) {
1543               if(cur->regmap[hr]==r) {
1544                 cur->regmap[hr]=reg;
1545                 cur->dirty&=~(1<<hr);
1546                 cur->isconst&=~(1<<hr);
1547                 return;
1548               }
1549             }
1550           }
1551         }
1552       }
1553     }
1554   }
1555   for(j=10;j>=0;j--)
1556   {
1557     for(r=1;r<=MAXREG;r++)
1558     {
1559       if(hsn[r]==j) {
1560         for(hr=0;hr<HOST_REGS;hr++) {
1561           if(cur->regmap[hr]==r) {
1562             cur->regmap[hr]=reg;
1563             cur->dirty&=~(1<<hr);
1564             cur->isconst&=~(1<<hr);
1565             return;
1566           }
1567         }
1568       }
1569     }
1570   }
1571   SysPrintf("This shouldn't happen");abort();
1572 }
1573
1574 static void mov_alloc(struct regstat *current,int i)
1575 {
1576   // Note: Don't need to actually alloc the source registers
1577   //alloc_reg(current,i,rs1[i]);
1578   alloc_reg(current,i,rt1[i]);
1579
1580   clear_const(current,rs1[i]);
1581   clear_const(current,rt1[i]);
1582   dirty_reg(current,rt1[i]);
1583 }
1584
1585 static void shiftimm_alloc(struct regstat *current,int i)
1586 {
1587   if(opcode2[i]<=0x3) // SLL/SRL/SRA
1588   {
1589     if(rt1[i]) {
1590       if(rs1[i]&&needed_again(rs1[i],i)) alloc_reg(current,i,rs1[i]);
1591       else lt1[i]=rs1[i];
1592       alloc_reg(current,i,rt1[i]);
1593       dirty_reg(current,rt1[i]);
1594       if(is_const(current,rs1[i])) {
1595         int v=get_const(current,rs1[i]);
1596         if(opcode2[i]==0x00) set_const(current,rt1[i],v<<imm[i]);
1597         if(opcode2[i]==0x02) set_const(current,rt1[i],(u_int)v>>imm[i]);
1598         if(opcode2[i]==0x03) set_const(current,rt1[i],v>>imm[i]);
1599       }
1600       else clear_const(current,rt1[i]);
1601     }
1602   }
1603   else
1604   {
1605     clear_const(current,rs1[i]);
1606     clear_const(current,rt1[i]);
1607   }
1608
1609   if(opcode2[i]>=0x38&&opcode2[i]<=0x3b) // DSLL/DSRL/DSRA
1610   {
1611     assert(0);
1612   }
1613   if(opcode2[i]==0x3c) // DSLL32
1614   {
1615     assert(0);
1616   }
1617   if(opcode2[i]==0x3e) // DSRL32
1618   {
1619     assert(0);
1620   }
1621   if(opcode2[i]==0x3f) // DSRA32
1622   {
1623     assert(0);
1624   }
1625 }
1626
1627 static void shift_alloc(struct regstat *current,int i)
1628 {
1629   if(rt1[i]) {
1630     if(opcode2[i]<=0x07) // SLLV/SRLV/SRAV
1631     {
1632       if(rs1[i]) alloc_reg(current,i,rs1[i]);
1633       if(rs2[i]) alloc_reg(current,i,rs2[i]);
1634       alloc_reg(current,i,rt1[i]);
1635       if(rt1[i]==rs2[i]) {
1636         alloc_reg_temp(current,i,-1);
1637         minimum_free_regs[i]=1;
1638       }
1639     } else { // DSLLV/DSRLV/DSRAV
1640       assert(0);
1641     }
1642     clear_const(current,rs1[i]);
1643     clear_const(current,rs2[i]);
1644     clear_const(current,rt1[i]);
1645     dirty_reg(current,rt1[i]);
1646   }
1647 }
1648
1649 static void alu_alloc(struct regstat *current,int i)
1650 {
1651   if(opcode2[i]>=0x20&&opcode2[i]<=0x23) { // ADD/ADDU/SUB/SUBU
1652     if(rt1[i]) {
1653       if(rs1[i]&&rs2[i]) {
1654         alloc_reg(current,i,rs1[i]);
1655         alloc_reg(current,i,rs2[i]);
1656       }
1657       else {
1658         if(rs1[i]&&needed_again(rs1[i],i)) alloc_reg(current,i,rs1[i]);
1659         if(rs2[i]&&needed_again(rs2[i],i)) alloc_reg(current,i,rs2[i]);
1660       }
1661       alloc_reg(current,i,rt1[i]);
1662     }
1663   }
1664   if(opcode2[i]==0x2a||opcode2[i]==0x2b) { // SLT/SLTU
1665     if(rt1[i]) {
1666       alloc_reg(current,i,rs1[i]);
1667       alloc_reg(current,i,rs2[i]);
1668       alloc_reg(current,i,rt1[i]);
1669     }
1670   }
1671   if(opcode2[i]>=0x24&&opcode2[i]<=0x27) { // AND/OR/XOR/NOR
1672     if(rt1[i]) {
1673       if(rs1[i]&&rs2[i]) {
1674         alloc_reg(current,i,rs1[i]);
1675         alloc_reg(current,i,rs2[i]);
1676       }
1677       else
1678       {
1679         if(rs1[i]&&needed_again(rs1[i],i)) alloc_reg(current,i,rs1[i]);
1680         if(rs2[i]&&needed_again(rs2[i],i)) alloc_reg(current,i,rs2[i]);
1681       }
1682       alloc_reg(current,i,rt1[i]);
1683     }
1684   }
1685   if(opcode2[i]>=0x2c&&opcode2[i]<=0x2f) { // DADD/DADDU/DSUB/DSUBU
1686     assert(0);
1687   }
1688   clear_const(current,rs1[i]);
1689   clear_const(current,rs2[i]);
1690   clear_const(current,rt1[i]);
1691   dirty_reg(current,rt1[i]);
1692 }
1693
1694 static void imm16_alloc(struct regstat *current,int i)
1695 {
1696   if(rs1[i]&&needed_again(rs1[i],i)) alloc_reg(current,i,rs1[i]);
1697   else lt1[i]=rs1[i];
1698   if(rt1[i]) alloc_reg(current,i,rt1[i]);
1699   if(opcode[i]==0x18||opcode[i]==0x19) { // DADDI/DADDIU
1700     assert(0);
1701   }
1702   else if(opcode[i]==0x0a||opcode[i]==0x0b) { // SLTI/SLTIU
1703     clear_const(current,rs1[i]);
1704     clear_const(current,rt1[i]);
1705   }
1706   else if(opcode[i]>=0x0c&&opcode[i]<=0x0e) { // ANDI/ORI/XORI
1707     if(is_const(current,rs1[i])) {
1708       int v=get_const(current,rs1[i]);
1709       if(opcode[i]==0x0c) set_const(current,rt1[i],v&imm[i]);
1710       if(opcode[i]==0x0d) set_const(current,rt1[i],v|imm[i]);
1711       if(opcode[i]==0x0e) set_const(current,rt1[i],v^imm[i]);
1712     }
1713     else clear_const(current,rt1[i]);
1714   }
1715   else if(opcode[i]==0x08||opcode[i]==0x09) { // ADDI/ADDIU
1716     if(is_const(current,rs1[i])) {
1717       int v=get_const(current,rs1[i]);
1718       set_const(current,rt1[i],v+imm[i]);
1719     }
1720     else clear_const(current,rt1[i]);
1721   }
1722   else {
1723     set_const(current,rt1[i],imm[i]<<16); // LUI
1724   }
1725   dirty_reg(current,rt1[i]);
1726 }
1727
1728 static void load_alloc(struct regstat *current,int i)
1729 {
1730   clear_const(current,rt1[i]);
1731   //if(rs1[i]!=rt1[i]&&needed_again(rs1[i],i)) clear_const(current,rs1[i]); // Does this help or hurt?
1732   if(!rs1[i]) current->u&=~1LL; // Allow allocating r0 if it's the source register
1733   if(needed_again(rs1[i],i)) alloc_reg(current,i,rs1[i]);
1734   if(rt1[i]&&!((current->u>>rt1[i])&1)) {
1735     alloc_reg(current,i,rt1[i]);
1736     assert(get_reg(current->regmap,rt1[i])>=0);
1737     if(opcode[i]==0x27||opcode[i]==0x37) // LWU/LD
1738     {
1739       assert(0);
1740     }
1741     else if(opcode[i]==0x1A||opcode[i]==0x1B) // LDL/LDR
1742     {
1743       assert(0);
1744     }
1745     dirty_reg(current,rt1[i]);
1746     // LWL/LWR need a temporary register for the old value
1747     if(opcode[i]==0x22||opcode[i]==0x26)
1748     {
1749       alloc_reg(current,i,FTEMP);
1750       alloc_reg_temp(current,i,-1);
1751       minimum_free_regs[i]=1;
1752     }
1753   }
1754   else
1755   {
1756     // Load to r0 or unneeded register (dummy load)
1757     // but we still need a register to calculate the address
1758     if(opcode[i]==0x22||opcode[i]==0x26)
1759     {
1760       alloc_reg(current,i,FTEMP); // LWL/LWR need another temporary
1761     }
1762     alloc_reg_temp(current,i,-1);
1763     minimum_free_regs[i]=1;
1764     if(opcode[i]==0x1A||opcode[i]==0x1B) // LDL/LDR
1765     {
1766       assert(0);
1767     }
1768   }
1769 }
1770
1771 void store_alloc(struct regstat *current,int i)
1772 {
1773   clear_const(current,rs2[i]);
1774   if(!(rs2[i])) current->u&=~1LL; // Allow allocating r0 if necessary
1775   if(needed_again(rs1[i],i)) alloc_reg(current,i,rs1[i]);
1776   alloc_reg(current,i,rs2[i]);
1777   if(opcode[i]==0x2c||opcode[i]==0x2d||opcode[i]==0x3f) { // 64-bit SDL/SDR/SD
1778     assert(0);
1779   }
1780   #if defined(HOST_IMM8)
1781   // On CPUs without 32-bit immediates we need a pointer to invalid_code
1782   else alloc_reg(current,i,INVCP);
1783   #endif
1784   if(opcode[i]==0x2a||opcode[i]==0x2e||opcode[i]==0x2c||opcode[i]==0x2d) { // SWL/SWL/SDL/SDR
1785     alloc_reg(current,i,FTEMP);
1786   }
1787   // We need a temporary register for address generation
1788   alloc_reg_temp(current,i,-1);
1789   minimum_free_regs[i]=1;
1790 }
1791
1792 void c1ls_alloc(struct regstat *current,int i)
1793 {
1794   //clear_const(current,rs1[i]); // FIXME
1795   clear_const(current,rt1[i]);
1796   if(needed_again(rs1[i],i)) alloc_reg(current,i,rs1[i]);
1797   alloc_reg(current,i,CSREG); // Status
1798   alloc_reg(current,i,FTEMP);
1799   if(opcode[i]==0x35||opcode[i]==0x3d) { // 64-bit LDC1/SDC1
1800     assert(0);
1801   }
1802   #if defined(HOST_IMM8)
1803   // On CPUs without 32-bit immediates we need a pointer to invalid_code
1804   else if((opcode[i]&0x3b)==0x39) // SWC1/SDC1
1805     alloc_reg(current,i,INVCP);
1806   #endif
1807   // We need a temporary register for address generation
1808   alloc_reg_temp(current,i,-1);
1809 }
1810
1811 void c2ls_alloc(struct regstat *current,int i)
1812 {
1813   clear_const(current,rt1[i]);
1814   if(needed_again(rs1[i],i)) alloc_reg(current,i,rs1[i]);
1815   alloc_reg(current,i,FTEMP);
1816   #if defined(HOST_IMM8)
1817   // On CPUs without 32-bit immediates we need a pointer to invalid_code
1818   if((opcode[i]&0x3b)==0x3a) // SWC2/SDC2
1819     alloc_reg(current,i,INVCP);
1820   #endif
1821   // We need a temporary register for address generation
1822   alloc_reg_temp(current,i,-1);
1823   minimum_free_regs[i]=1;
1824 }
1825
1826 #ifndef multdiv_alloc
1827 void multdiv_alloc(struct regstat *current,int i)
1828 {
1829   //  case 0x18: MULT
1830   //  case 0x19: MULTU
1831   //  case 0x1A: DIV
1832   //  case 0x1B: DIVU
1833   //  case 0x1C: DMULT
1834   //  case 0x1D: DMULTU
1835   //  case 0x1E: DDIV
1836   //  case 0x1F: DDIVU
1837   clear_const(current,rs1[i]);
1838   clear_const(current,rs2[i]);
1839   if(rs1[i]&&rs2[i])
1840   {
1841     if((opcode2[i]&4)==0) // 32-bit
1842     {
1843       current->u&=~(1LL<<HIREG);
1844       current->u&=~(1LL<<LOREG);
1845       alloc_reg(current,i,HIREG);
1846       alloc_reg(current,i,LOREG);
1847       alloc_reg(current,i,rs1[i]);
1848       alloc_reg(current,i,rs2[i]);
1849       dirty_reg(current,HIREG);
1850       dirty_reg(current,LOREG);
1851     }
1852     else // 64-bit
1853     {
1854       assert(0);
1855     }
1856   }
1857   else
1858   {
1859     // Multiply by zero is zero.
1860     // MIPS does not have a divide by zero exception.
1861     // The result is undefined, we return zero.
1862     alloc_reg(current,i,HIREG);
1863     alloc_reg(current,i,LOREG);
1864     dirty_reg(current,HIREG);
1865     dirty_reg(current,LOREG);
1866   }
1867 }
1868 #endif
1869
1870 void cop0_alloc(struct regstat *current,int i)
1871 {
1872   if(opcode2[i]==0) // MFC0
1873   {
1874     if(rt1[i]) {
1875       clear_const(current,rt1[i]);
1876       alloc_all(current,i);
1877       alloc_reg(current,i,rt1[i]);
1878       dirty_reg(current,rt1[i]);
1879     }
1880   }
1881   else if(opcode2[i]==4) // MTC0
1882   {
1883     if(rs1[i]){
1884       clear_const(current,rs1[i]);
1885       alloc_reg(current,i,rs1[i]);
1886       alloc_all(current,i);
1887     }
1888     else {
1889       alloc_all(current,i); // FIXME: Keep r0
1890       current->u&=~1LL;
1891       alloc_reg(current,i,0);
1892     }
1893   }
1894   else
1895   {
1896     // TLBR/TLBWI/TLBWR/TLBP/ERET
1897     assert(opcode2[i]==0x10);
1898     alloc_all(current,i);
1899   }
1900   minimum_free_regs[i]=HOST_REGS;
1901 }
1902
1903 static void cop12_alloc(struct regstat *current,int i)
1904 {
1905   alloc_reg(current,i,CSREG); // Load status
1906   if(opcode2[i]<3) // MFC1/CFC1
1907   {
1908     if(rt1[i]){
1909       clear_const(current,rt1[i]);
1910       alloc_reg(current,i,rt1[i]);
1911       dirty_reg(current,rt1[i]);
1912     }
1913     alloc_reg_temp(current,i,-1);
1914   }
1915   else if(opcode2[i]>3) // MTC1/CTC1
1916   {
1917     if(rs1[i]){
1918       clear_const(current,rs1[i]);
1919       alloc_reg(current,i,rs1[i]);
1920     }
1921     else {
1922       current->u&=~1LL;
1923       alloc_reg(current,i,0);
1924     }
1925     alloc_reg_temp(current,i,-1);
1926   }
1927   minimum_free_regs[i]=1;
1928 }
1929
1930 void c2op_alloc(struct regstat *current,int i)
1931 {
1932   alloc_reg_temp(current,i,-1);
1933 }
1934
1935 void syscall_alloc(struct regstat *current,int i)
1936 {
1937   alloc_cc(current,i);
1938   dirty_reg(current,CCREG);
1939   alloc_all(current,i);
1940   minimum_free_regs[i]=HOST_REGS;
1941   current->isconst=0;
1942 }
1943
1944 void delayslot_alloc(struct regstat *current,int i)
1945 {
1946   switch(itype[i]) {
1947     case UJUMP:
1948     case CJUMP:
1949     case SJUMP:
1950     case RJUMP:
1951     case SYSCALL:
1952     case HLECALL:
1953     case SPAN:
1954       assem_debug("jump in the delay slot.  this shouldn't happen.\n");//abort();
1955       SysPrintf("Disabled speculative precompilation\n");
1956       stop_after_jal=1;
1957       break;
1958     case IMM16:
1959       imm16_alloc(current,i);
1960       break;
1961     case LOAD:
1962     case LOADLR:
1963       load_alloc(current,i);
1964       break;
1965     case STORE:
1966     case STORELR:
1967       store_alloc(current,i);
1968       break;
1969     case ALU:
1970       alu_alloc(current,i);
1971       break;
1972     case SHIFT:
1973       shift_alloc(current,i);
1974       break;
1975     case MULTDIV:
1976       multdiv_alloc(current,i);
1977       break;
1978     case SHIFTIMM:
1979       shiftimm_alloc(current,i);
1980       break;
1981     case MOV:
1982       mov_alloc(current,i);
1983       break;
1984     case COP0:
1985       cop0_alloc(current,i);
1986       break;
1987     case COP1:
1988     case COP2:
1989       cop12_alloc(current,i);
1990       break;
1991     case C1LS:
1992       c1ls_alloc(current,i);
1993       break;
1994     case C2LS:
1995       c2ls_alloc(current,i);
1996       break;
1997     case C2OP:
1998       c2op_alloc(current,i);
1999       break;
2000   }
2001 }
2002
2003 // Special case where a branch and delay slot span two pages in virtual memory
2004 static void pagespan_alloc(struct regstat *current,int i)
2005 {
2006   current->isconst=0;
2007   current->wasconst=0;
2008   regs[i].wasconst=0;
2009   minimum_free_regs[i]=HOST_REGS;
2010   alloc_all(current,i);
2011   alloc_cc(current,i);
2012   dirty_reg(current,CCREG);
2013   if(opcode[i]==3) // JAL
2014   {
2015     alloc_reg(current,i,31);
2016     dirty_reg(current,31);
2017   }
2018   if(opcode[i]==0&&(opcode2[i]&0x3E)==8) // JR/JALR
2019   {
2020     alloc_reg(current,i,rs1[i]);
2021     if (rt1[i]!=0) {
2022       alloc_reg(current,i,rt1[i]);
2023       dirty_reg(current,rt1[i]);
2024     }
2025   }
2026   if((opcode[i]&0x2E)==4) // BEQ/BNE/BEQL/BNEL
2027   {
2028     if(rs1[i]) alloc_reg(current,i,rs1[i]);
2029     if(rs2[i]) alloc_reg(current,i,rs2[i]);
2030   }
2031   else
2032   if((opcode[i]&0x2E)==6) // BLEZ/BGTZ/BLEZL/BGTZL
2033   {
2034     if(rs1[i]) alloc_reg(current,i,rs1[i]);
2035   }
2036   //else ...
2037 }
2038
2039 static void add_stub(enum stub_type type, void *addr, void *retaddr,
2040   u_int a, uintptr_t b, uintptr_t c, u_int d, u_int e)
2041 {
2042   assert(stubcount < ARRAY_SIZE(stubs));
2043   stubs[stubcount].type = type;
2044   stubs[stubcount].addr = addr;
2045   stubs[stubcount].retaddr = retaddr;
2046   stubs[stubcount].a = a;
2047   stubs[stubcount].b = b;
2048   stubs[stubcount].c = c;
2049   stubs[stubcount].d = d;
2050   stubs[stubcount].e = e;
2051   stubcount++;
2052 }
2053
2054 static void add_stub_r(enum stub_type type, void *addr, void *retaddr,
2055   int i, int addr_reg, struct regstat *i_regs, int ccadj, u_int reglist)
2056 {
2057   add_stub(type, addr, retaddr, i, addr_reg, (uintptr_t)i_regs, ccadj, reglist);
2058 }
2059
2060 // Write out a single register
2061 static void wb_register(signed char r,signed char regmap[],uint64_t dirty)
2062 {
2063   int hr;
2064   for(hr=0;hr<HOST_REGS;hr++) {
2065     if(hr!=EXCLUDE_REG) {
2066       if((regmap[hr]&63)==r) {
2067         if((dirty>>hr)&1) {
2068           assert(regmap[hr]<64);
2069           emit_storereg(r,hr);
2070         }
2071       }
2072     }
2073   }
2074 }
2075
2076 static void wb_valid(signed char pre[],signed char entry[],u_int dirty_pre,u_int dirty,uint64_t u)
2077 {
2078   //if(dirty_pre==dirty) return;
2079   int hr,reg;
2080   for(hr=0;hr<HOST_REGS;hr++) {
2081     if(hr!=EXCLUDE_REG) {
2082       reg=pre[hr];
2083       if(((~u)>>(reg&63))&1) {
2084         if(reg>0) {
2085           if(((dirty_pre&~dirty)>>hr)&1) {
2086             if(reg>0&&reg<34) {
2087               emit_storereg(reg,hr);
2088             }
2089             else if(reg>=64) {
2090               assert(0);
2091             }
2092           }
2093         }
2094       }
2095     }
2096   }
2097 }
2098
2099 // trashes r2
2100 static void pass_args(int a0, int a1)
2101 {
2102   if(a0==1&&a1==0) {
2103     // must swap
2104     emit_mov(a0,2); emit_mov(a1,1); emit_mov(2,0);
2105   }
2106   else if(a0!=0&&a1==0) {
2107     emit_mov(a1,1);
2108     if (a0>=0) emit_mov(a0,0);
2109   }
2110   else {
2111     if(a0>=0&&a0!=0) emit_mov(a0,0);
2112     if(a1>=0&&a1!=1) emit_mov(a1,1);
2113   }
2114 }
2115
2116 static void alu_assemble(int i,struct regstat *i_regs)
2117 {
2118   if(opcode2[i]>=0x20&&opcode2[i]<=0x23) { // ADD/ADDU/SUB/SUBU
2119     if(rt1[i]) {
2120       signed char s1,s2,t;
2121       t=get_reg(i_regs->regmap,rt1[i]);
2122       if(t>=0) {
2123         s1=get_reg(i_regs->regmap,rs1[i]);
2124         s2=get_reg(i_regs->regmap,rs2[i]);
2125         if(rs1[i]&&rs2[i]) {
2126           assert(s1>=0);
2127           assert(s2>=0);
2128           if(opcode2[i]&2) emit_sub(s1,s2,t);
2129           else emit_add(s1,s2,t);
2130         }
2131         else if(rs1[i]) {
2132           if(s1>=0) emit_mov(s1,t);
2133           else emit_loadreg(rs1[i],t);
2134         }
2135         else if(rs2[i]) {
2136           if(s2>=0) {
2137             if(opcode2[i]&2) emit_neg(s2,t);
2138             else emit_mov(s2,t);
2139           }
2140           else {
2141             emit_loadreg(rs2[i],t);
2142             if(opcode2[i]&2) emit_neg(t,t);
2143           }
2144         }
2145         else emit_zeroreg(t);
2146       }
2147     }
2148   }
2149   if(opcode2[i]>=0x2c&&opcode2[i]<=0x2f) { // DADD/DADDU/DSUB/DSUBU
2150     assert(0);
2151   }
2152   if(opcode2[i]==0x2a||opcode2[i]==0x2b) { // SLT/SLTU
2153     if(rt1[i]) {
2154       signed char s1l,s2l,t;
2155       {
2156         t=get_reg(i_regs->regmap,rt1[i]);
2157         //assert(t>=0);
2158         if(t>=0) {
2159           s1l=get_reg(i_regs->regmap,rs1[i]);
2160           s2l=get_reg(i_regs->regmap,rs2[i]);
2161           if(rs2[i]==0) // rx<r0
2162           {
2163             if(opcode2[i]==0x2a&&rs1[i]!=0) { // SLT
2164               assert(s1l>=0);
2165               emit_shrimm(s1l,31,t);
2166             }
2167             else // SLTU (unsigned can not be less than zero, 0<0)
2168               emit_zeroreg(t);
2169           }
2170           else if(rs1[i]==0) // r0<rx
2171           {
2172             assert(s2l>=0);
2173             if(opcode2[i]==0x2a) // SLT
2174               emit_set_gz32(s2l,t);
2175             else // SLTU (set if not zero)
2176               emit_set_nz32(s2l,t);
2177           }
2178           else{
2179             assert(s1l>=0);assert(s2l>=0);
2180             if(opcode2[i]==0x2a) // SLT
2181               emit_set_if_less32(s1l,s2l,t);
2182             else // SLTU
2183               emit_set_if_carry32(s1l,s2l,t);
2184           }
2185         }
2186       }
2187     }
2188   }
2189   if(opcode2[i]>=0x24&&opcode2[i]<=0x27) { // AND/OR/XOR/NOR
2190     if(rt1[i]) {
2191       signed char s1l,s2l,tl;
2192       tl=get_reg(i_regs->regmap,rt1[i]);
2193       {
2194         if(tl>=0) {
2195           s1l=get_reg(i_regs->regmap,rs1[i]);
2196           s2l=get_reg(i_regs->regmap,rs2[i]);
2197           if(rs1[i]&&rs2[i]) {
2198             assert(s1l>=0);
2199             assert(s2l>=0);
2200             if(opcode2[i]==0x24) { // AND
2201               emit_and(s1l,s2l,tl);
2202             } else
2203             if(opcode2[i]==0x25) { // OR
2204               emit_or(s1l,s2l,tl);
2205             } else
2206             if(opcode2[i]==0x26) { // XOR
2207               emit_xor(s1l,s2l,tl);
2208             } else
2209             if(opcode2[i]==0x27) { // NOR
2210               emit_or(s1l,s2l,tl);
2211               emit_not(tl,tl);
2212             }
2213           }
2214           else
2215           {
2216             if(opcode2[i]==0x24) { // AND
2217               emit_zeroreg(tl);
2218             } else
2219             if(opcode2[i]==0x25||opcode2[i]==0x26) { // OR/XOR
2220               if(rs1[i]){
2221                 if(s1l>=0) emit_mov(s1l,tl);
2222                 else emit_loadreg(rs1[i],tl); // CHECK: regmap_entry?
2223               }
2224               else
2225               if(rs2[i]){
2226                 if(s2l>=0) emit_mov(s2l,tl);
2227                 else emit_loadreg(rs2[i],tl); // CHECK: regmap_entry?
2228               }
2229               else emit_zeroreg(tl);
2230             } else
2231             if(opcode2[i]==0x27) { // NOR
2232               if(rs1[i]){
2233                 if(s1l>=0) emit_not(s1l,tl);
2234                 else {
2235                   emit_loadreg(rs1[i],tl);
2236                   emit_not(tl,tl);
2237                 }
2238               }
2239               else
2240               if(rs2[i]){
2241                 if(s2l>=0) emit_not(s2l,tl);
2242                 else {
2243                   emit_loadreg(rs2[i],tl);
2244                   emit_not(tl,tl);
2245                 }
2246               }
2247               else emit_movimm(-1,tl);
2248             }
2249           }
2250         }
2251       }
2252     }
2253   }
2254 }
2255
2256 void imm16_assemble(int i,struct regstat *i_regs)
2257 {
2258   if (opcode[i]==0x0f) { // LUI
2259     if(rt1[i]) {
2260       signed char t;
2261       t=get_reg(i_regs->regmap,rt1[i]);
2262       //assert(t>=0);
2263       if(t>=0) {
2264         if(!((i_regs->isconst>>t)&1))
2265           emit_movimm(imm[i]<<16,t);
2266       }
2267     }
2268   }
2269   if(opcode[i]==0x08||opcode[i]==0x09) { // ADDI/ADDIU
2270     if(rt1[i]) {
2271       signed char s,t;
2272       t=get_reg(i_regs->regmap,rt1[i]);
2273       s=get_reg(i_regs->regmap,rs1[i]);
2274       if(rs1[i]) {
2275         //assert(t>=0);
2276         //assert(s>=0);
2277         if(t>=0) {
2278           if(!((i_regs->isconst>>t)&1)) {
2279             if(s<0) {
2280               if(i_regs->regmap_entry[t]!=rs1[i]) emit_loadreg(rs1[i],t);
2281               emit_addimm(t,imm[i],t);
2282             }else{
2283               if(!((i_regs->wasconst>>s)&1))
2284                 emit_addimm(s,imm[i],t);
2285               else
2286                 emit_movimm(constmap[i][s]+imm[i],t);
2287             }
2288           }
2289         }
2290       } else {
2291         if(t>=0) {
2292           if(!((i_regs->isconst>>t)&1))
2293             emit_movimm(imm[i],t);
2294         }
2295       }
2296     }
2297   }
2298   if(opcode[i]==0x18||opcode[i]==0x19) { // DADDI/DADDIU
2299     if(rt1[i]) {
2300       signed char sl,tl;
2301       tl=get_reg(i_regs->regmap,rt1[i]);
2302       sl=get_reg(i_regs->regmap,rs1[i]);
2303       if(tl>=0) {
2304         if(rs1[i]) {
2305           assert(sl>=0);
2306           emit_addimm(sl,imm[i],tl);
2307         } else {
2308           emit_movimm(imm[i],tl);
2309         }
2310       }
2311     }
2312   }
2313   else if(opcode[i]==0x0a||opcode[i]==0x0b) { // SLTI/SLTIU
2314     if(rt1[i]) {
2315       //assert(rs1[i]!=0); // r0 might be valid, but it's probably a bug
2316       signed char sl,t;
2317       t=get_reg(i_regs->regmap,rt1[i]);
2318       sl=get_reg(i_regs->regmap,rs1[i]);
2319       //assert(t>=0);
2320       if(t>=0) {
2321         if(rs1[i]>0) {
2322             if(opcode[i]==0x0a) { // SLTI
2323               if(sl<0) {
2324                 if(i_regs->regmap_entry[t]!=rs1[i]) emit_loadreg(rs1[i],t);
2325                 emit_slti32(t,imm[i],t);
2326               }else{
2327                 emit_slti32(sl,imm[i],t);
2328               }
2329             }
2330             else { // SLTIU
2331               if(sl<0) {
2332                 if(i_regs->regmap_entry[t]!=rs1[i]) emit_loadreg(rs1[i],t);
2333                 emit_sltiu32(t,imm[i],t);
2334               }else{
2335                 emit_sltiu32(sl,imm[i],t);
2336               }
2337             }
2338         }else{
2339           // SLTI(U) with r0 is just stupid,
2340           // nonetheless examples can be found
2341           if(opcode[i]==0x0a) // SLTI
2342             if(0<imm[i]) emit_movimm(1,t);
2343             else emit_zeroreg(t);
2344           else // SLTIU
2345           {
2346             if(imm[i]) emit_movimm(1,t);
2347             else emit_zeroreg(t);
2348           }
2349         }
2350       }
2351     }
2352   }
2353   else if(opcode[i]>=0x0c&&opcode[i]<=0x0e) { // ANDI/ORI/XORI
2354     if(rt1[i]) {
2355       signed char sl,tl;
2356       tl=get_reg(i_regs->regmap,rt1[i]);
2357       sl=get_reg(i_regs->regmap,rs1[i]);
2358       if(tl>=0 && !((i_regs->isconst>>tl)&1)) {
2359         if(opcode[i]==0x0c) //ANDI
2360         {
2361           if(rs1[i]) {
2362             if(sl<0) {
2363               if(i_regs->regmap_entry[tl]!=rs1[i]) emit_loadreg(rs1[i],tl);
2364               emit_andimm(tl,imm[i],tl);
2365             }else{
2366               if(!((i_regs->wasconst>>sl)&1))
2367                 emit_andimm(sl,imm[i],tl);
2368               else
2369                 emit_movimm(constmap[i][sl]&imm[i],tl);
2370             }
2371           }
2372           else
2373             emit_zeroreg(tl);
2374         }
2375         else
2376         {
2377           if(rs1[i]) {
2378             if(sl<0) {
2379               if(i_regs->regmap_entry[tl]!=rs1[i]) emit_loadreg(rs1[i],tl);
2380             }
2381             if(opcode[i]==0x0d) { // ORI
2382               if(sl<0) {
2383                 emit_orimm(tl,imm[i],tl);
2384               }else{
2385                 if(!((i_regs->wasconst>>sl)&1))
2386                   emit_orimm(sl,imm[i],tl);
2387                 else
2388                   emit_movimm(constmap[i][sl]|imm[i],tl);
2389               }
2390             }
2391             if(opcode[i]==0x0e) { // XORI
2392               if(sl<0) {
2393                 emit_xorimm(tl,imm[i],tl);
2394               }else{
2395                 if(!((i_regs->wasconst>>sl)&1))
2396                   emit_xorimm(sl,imm[i],tl);
2397                 else
2398                   emit_movimm(constmap[i][sl]^imm[i],tl);
2399               }
2400             }
2401           }
2402           else {
2403             emit_movimm(imm[i],tl);
2404           }
2405         }
2406       }
2407     }
2408   }
2409 }
2410
2411 void shiftimm_assemble(int i,struct regstat *i_regs)
2412 {
2413   if(opcode2[i]<=0x3) // SLL/SRL/SRA
2414   {
2415     if(rt1[i]) {
2416       signed char s,t;
2417       t=get_reg(i_regs->regmap,rt1[i]);
2418       s=get_reg(i_regs->regmap,rs1[i]);
2419       //assert(t>=0);
2420       if(t>=0&&!((i_regs->isconst>>t)&1)){
2421         if(rs1[i]==0)
2422         {
2423           emit_zeroreg(t);
2424         }
2425         else
2426         {
2427           if(s<0&&i_regs->regmap_entry[t]!=rs1[i]) emit_loadreg(rs1[i],t);
2428           if(imm[i]) {
2429             if(opcode2[i]==0) // SLL
2430             {
2431               emit_shlimm(s<0?t:s,imm[i],t);
2432             }
2433             if(opcode2[i]==2) // SRL
2434             {
2435               emit_shrimm(s<0?t:s,imm[i],t);
2436             }
2437             if(opcode2[i]==3) // SRA
2438             {
2439               emit_sarimm(s<0?t:s,imm[i],t);
2440             }
2441           }else{
2442             // Shift by zero
2443             if(s>=0 && s!=t) emit_mov(s,t);
2444           }
2445         }
2446       }
2447       //emit_storereg(rt1[i],t); //DEBUG
2448     }
2449   }
2450   if(opcode2[i]>=0x38&&opcode2[i]<=0x3b) // DSLL/DSRL/DSRA
2451   {
2452     assert(0);
2453   }
2454   if(opcode2[i]==0x3c) // DSLL32
2455   {
2456     assert(0);
2457   }
2458   if(opcode2[i]==0x3e) // DSRL32
2459   {
2460     assert(0);
2461   }
2462   if(opcode2[i]==0x3f) // DSRA32
2463   {
2464     assert(0);
2465   }
2466 }
2467
2468 #ifndef shift_assemble
2469 static void shift_assemble(int i,struct regstat *i_regs)
2470 {
2471   signed char s,t,shift;
2472   if (rt1[i] == 0)
2473     return;
2474   assert(opcode2[i]<=0x07); // SLLV/SRLV/SRAV
2475   t = get_reg(i_regs->regmap, rt1[i]);
2476   s = get_reg(i_regs->regmap, rs1[i]);
2477   shift = get_reg(i_regs->regmap, rs2[i]);
2478   if (t < 0)
2479     return;
2480
2481   if(rs1[i]==0)
2482     emit_zeroreg(t);
2483   else if(rs2[i]==0) {
2484     assert(s>=0);
2485     if(s!=t) emit_mov(s,t);
2486   }
2487   else {
2488     host_tempreg_acquire();
2489     emit_andimm(shift,31,HOST_TEMPREG);
2490     switch(opcode2[i]) {
2491     case 4: // SLLV
2492       emit_shl(s,HOST_TEMPREG,t);
2493       break;
2494     case 6: // SRLV
2495       emit_shr(s,HOST_TEMPREG,t);
2496       break;
2497     case 7: // SRAV
2498       emit_sar(s,HOST_TEMPREG,t);
2499       break;
2500     default:
2501       assert(0);
2502     }
2503     host_tempreg_release();
2504   }
2505 }
2506
2507 #endif
2508
2509 enum {
2510   MTYPE_8000 = 0,
2511   MTYPE_8020,
2512   MTYPE_0000,
2513   MTYPE_A000,
2514   MTYPE_1F80,
2515 };
2516
2517 static int get_ptr_mem_type(u_int a)
2518 {
2519   if(a < 0x00200000) {
2520     if(a<0x1000&&((start>>20)==0xbfc||(start>>24)==0xa0))
2521       // return wrong, must use memhandler for BIOS self-test to pass
2522       // 007 does similar stuff from a00 mirror, weird stuff
2523       return MTYPE_8000;
2524     return MTYPE_0000;
2525   }
2526   if(0x1f800000 <= a && a < 0x1f801000)
2527     return MTYPE_1F80;
2528   if(0x80200000 <= a && a < 0x80800000)
2529     return MTYPE_8020;
2530   if(0xa0000000 <= a && a < 0xa0200000)
2531     return MTYPE_A000;
2532   return MTYPE_8000;
2533 }
2534
2535 static void *emit_fastpath_cmp_jump(int i,int addr,int *addr_reg_override)
2536 {
2537   void *jaddr = NULL;
2538   int type=0;
2539   int mr=rs1[i];
2540   if(((smrv_strong|smrv_weak)>>mr)&1) {
2541     type=get_ptr_mem_type(smrv[mr]);
2542     //printf("set %08x @%08x r%d %d\n", smrv[mr], start+i*4, mr, type);
2543   }
2544   else {
2545     // use the mirror we are running on
2546     type=get_ptr_mem_type(start);
2547     //printf("set nospec   @%08x r%d %d\n", start+i*4, mr, type);
2548   }
2549
2550   if(type==MTYPE_8020) { // RAM 80200000+ mirror
2551     host_tempreg_acquire();
2552     emit_andimm(addr,~0x00e00000,HOST_TEMPREG);
2553     addr=*addr_reg_override=HOST_TEMPREG;
2554     type=0;
2555   }
2556   else if(type==MTYPE_0000) { // RAM 0 mirror
2557     host_tempreg_acquire();
2558     emit_orimm(addr,0x80000000,HOST_TEMPREG);
2559     addr=*addr_reg_override=HOST_TEMPREG;
2560     type=0;
2561   }
2562   else if(type==MTYPE_A000) { // RAM A mirror
2563     host_tempreg_acquire();
2564     emit_andimm(addr,~0x20000000,HOST_TEMPREG);
2565     addr=*addr_reg_override=HOST_TEMPREG;
2566     type=0;
2567   }
2568   else if(type==MTYPE_1F80) { // scratchpad
2569     if (psxH == (void *)0x1f800000) {
2570       host_tempreg_acquire();
2571       emit_xorimm(addr,0x1f800000,HOST_TEMPREG);
2572       emit_cmpimm(HOST_TEMPREG,0x1000);
2573       host_tempreg_release();
2574       jaddr=out;
2575       emit_jc(0);
2576     }
2577     else {
2578       // do the usual RAM check, jump will go to the right handler
2579       type=0;
2580     }
2581   }
2582
2583   if(type==0)
2584   {
2585     emit_cmpimm(addr,RAM_SIZE);
2586     jaddr=out;
2587     #ifdef CORTEX_A8_BRANCH_PREDICTION_HACK
2588     // Hint to branch predictor that the branch is unlikely to be taken
2589     if(rs1[i]>=28)
2590       emit_jno_unlikely(0);
2591     else
2592     #endif
2593       emit_jno(0);
2594     if(ram_offset!=0) {
2595       host_tempreg_acquire();
2596       emit_addimm(addr,ram_offset,HOST_TEMPREG);
2597       addr=*addr_reg_override=HOST_TEMPREG;
2598     }
2599   }
2600
2601   return jaddr;
2602 }
2603
2604 // return memhandler, or get directly accessable address and return 0
2605 static void *get_direct_memhandler(void *table, u_int addr,
2606   enum stub_type type, uintptr_t *addr_host)
2607 {
2608   uintptr_t l1, l2 = 0;
2609   l1 = ((uintptr_t *)table)[addr>>12];
2610   if ((l1 & (1ul << (sizeof(l1)*8-1))) == 0) {
2611     uintptr_t v = l1 << 1;
2612     *addr_host = v + addr;
2613     return NULL;
2614   }
2615   else {
2616     l1 <<= 1;
2617     if (type == LOADB_STUB || type == LOADBU_STUB || type == STOREB_STUB)
2618       l2 = ((uintptr_t *)l1)[0x1000/4 + 0x1000/2 + (addr&0xfff)];
2619     else if (type == LOADH_STUB || type == LOADHU_STUB || type == STOREH_STUB)
2620       l2=((uintptr_t *)l1)[0x1000/4 + (addr&0xfff)/2];
2621     else
2622       l2=((uintptr_t *)l1)[(addr&0xfff)/4];
2623     if ((l2 & (1<<31)) == 0) {
2624       uintptr_t v = l2 << 1;
2625       *addr_host = v + (addr&0xfff);
2626       return NULL;
2627     }
2628     return (void *)(l2 << 1);
2629   }
2630 }
2631
2632 static void load_assemble(int i,struct regstat *i_regs)
2633 {
2634   int s,tl,addr;
2635   int offset;
2636   void *jaddr=0;
2637   int memtarget=0,c=0;
2638   int fastio_reg_override=-1;
2639   u_int hr,reglist=0;
2640   tl=get_reg(i_regs->regmap,rt1[i]);
2641   s=get_reg(i_regs->regmap,rs1[i]);
2642   offset=imm[i];
2643   for(hr=0;hr<HOST_REGS;hr++) {
2644     if(i_regs->regmap[hr]>=0) reglist|=1<<hr;
2645   }
2646   if(i_regs->regmap[HOST_CCREG]==CCREG) reglist&=~(1<<HOST_CCREG);
2647   if(s>=0) {
2648     c=(i_regs->wasconst>>s)&1;
2649     if (c) {
2650       memtarget=((signed int)(constmap[i][s]+offset))<(signed int)0x80000000+RAM_SIZE;
2651     }
2652   }
2653   //printf("load_assemble: c=%d\n",c);
2654   //if(c) printf("load_assemble: const=%lx\n",(long)constmap[i][s]+offset);
2655   // FIXME: Even if the load is a NOP, we should check for pagefaults...
2656   if((tl<0&&(!c||(((u_int)constmap[i][s]+offset)>>16)==0x1f80))
2657     ||rt1[i]==0) {
2658       // could be FIFO, must perform the read
2659       // ||dummy read
2660       assem_debug("(forced read)\n");
2661       tl=get_reg(i_regs->regmap,-1);
2662       assert(tl>=0);
2663   }
2664   if(offset||s<0||c) addr=tl;
2665   else addr=s;
2666   //if(tl<0) tl=get_reg(i_regs->regmap,-1);
2667  if(tl>=0) {
2668   //printf("load_assemble: c=%d\n",c);
2669   //if(c) printf("load_assemble: const=%lx\n",(long)constmap[i][s]+offset);
2670   assert(tl>=0); // Even if the load is a NOP, we must check for pagefaults and I/O
2671   reglist&=~(1<<tl);
2672   if(!c) {
2673     #ifdef R29_HACK
2674     // Strmnnrmn's speed hack
2675     if(rs1[i]!=29||start<0x80001000||start>=0x80000000+RAM_SIZE)
2676     #endif
2677     {
2678       jaddr=emit_fastpath_cmp_jump(i,addr,&fastio_reg_override);
2679     }
2680   }
2681   else if(ram_offset&&memtarget) {
2682     host_tempreg_acquire();
2683     emit_addimm(addr,ram_offset,HOST_TEMPREG);
2684     fastio_reg_override=HOST_TEMPREG;
2685   }
2686   int dummy=(rt1[i]==0)||(tl!=get_reg(i_regs->regmap,rt1[i])); // ignore loads to r0 and unneeded reg
2687   if (opcode[i]==0x20) { // LB
2688     if(!c||memtarget) {
2689       if(!dummy) {
2690         {
2691           int x=0,a=tl;
2692           if(!c) a=addr;
2693           if(fastio_reg_override>=0) a=fastio_reg_override;
2694
2695           emit_movsbl_indexed(x,a,tl);
2696         }
2697       }
2698       if(jaddr)
2699         add_stub_r(LOADB_STUB,jaddr,out,i,addr,i_regs,ccadj[i],reglist);
2700     }
2701     else
2702       inline_readstub(LOADB_STUB,i,constmap[i][s]+offset,i_regs->regmap,rt1[i],ccadj[i],reglist);
2703   }
2704   if (opcode[i]==0x21) { // LH
2705     if(!c||memtarget) {
2706       if(!dummy) {
2707         int x=0,a=tl;
2708         if(!c) a=addr;
2709         if(fastio_reg_override>=0) a=fastio_reg_override;
2710         emit_movswl_indexed(x,a,tl);
2711       }
2712       if(jaddr)
2713         add_stub_r(LOADH_STUB,jaddr,out,i,addr,i_regs,ccadj[i],reglist);
2714     }
2715     else
2716       inline_readstub(LOADH_STUB,i,constmap[i][s]+offset,i_regs->regmap,rt1[i],ccadj[i],reglist);
2717   }
2718   if (opcode[i]==0x23) { // LW
2719     if(!c||memtarget) {
2720       if(!dummy) {
2721         int a=addr;
2722         if(fastio_reg_override>=0) a=fastio_reg_override;
2723         emit_readword_indexed(0,a,tl);
2724       }
2725       if(jaddr)
2726         add_stub_r(LOADW_STUB,jaddr,out,i,addr,i_regs,ccadj[i],reglist);
2727     }
2728     else
2729       inline_readstub(LOADW_STUB,i,constmap[i][s]+offset,i_regs->regmap,rt1[i],ccadj[i],reglist);
2730   }
2731   if (opcode[i]==0x24) { // LBU
2732     if(!c||memtarget) {
2733       if(!dummy) {
2734         int x=0,a=tl;
2735         if(!c) a=addr;
2736         if(fastio_reg_override>=0) a=fastio_reg_override;
2737
2738         emit_movzbl_indexed(x,a,tl);
2739       }
2740       if(jaddr)
2741         add_stub_r(LOADBU_STUB,jaddr,out,i,addr,i_regs,ccadj[i],reglist);
2742     }
2743     else
2744       inline_readstub(LOADBU_STUB,i,constmap[i][s]+offset,i_regs->regmap,rt1[i],ccadj[i],reglist);
2745   }
2746   if (opcode[i]==0x25) { // LHU
2747     if(!c||memtarget) {
2748       if(!dummy) {
2749         int x=0,a=tl;
2750         if(!c) a=addr;
2751         if(fastio_reg_override>=0) a=fastio_reg_override;
2752         emit_movzwl_indexed(x,a,tl);
2753       }
2754       if(jaddr)
2755         add_stub_r(LOADHU_STUB,jaddr,out,i,addr,i_regs,ccadj[i],reglist);
2756     }
2757     else
2758       inline_readstub(LOADHU_STUB,i,constmap[i][s]+offset,i_regs->regmap,rt1[i],ccadj[i],reglist);
2759   }
2760   if (opcode[i]==0x27) { // LWU
2761     assert(0);
2762   }
2763   if (opcode[i]==0x37) { // LD
2764     assert(0);
2765   }
2766  }
2767  if (fastio_reg_override == HOST_TEMPREG)
2768    host_tempreg_release();
2769 }
2770
2771 #ifndef loadlr_assemble
2772 static void loadlr_assemble(int i,struct regstat *i_regs)
2773 {
2774   int s,tl,temp,temp2,addr;
2775   int offset;
2776   void *jaddr=0;
2777   int memtarget=0,c=0;
2778   int fastio_reg_override=-1;
2779   u_int hr,reglist=0;
2780   tl=get_reg(i_regs->regmap,rt1[i]);
2781   s=get_reg(i_regs->regmap,rs1[i]);
2782   temp=get_reg(i_regs->regmap,-1);
2783   temp2=get_reg(i_regs->regmap,FTEMP);
2784   addr=get_reg(i_regs->regmap,AGEN1+(i&1));
2785   assert(addr<0);
2786   offset=imm[i];
2787   for(hr=0;hr<HOST_REGS;hr++) {
2788     if(i_regs->regmap[hr]>=0) reglist|=1<<hr;
2789   }
2790   reglist|=1<<temp;
2791   if(offset||s<0||c) addr=temp2;
2792   else addr=s;
2793   if(s>=0) {
2794     c=(i_regs->wasconst>>s)&1;
2795     if(c) {
2796       memtarget=((signed int)(constmap[i][s]+offset))<(signed int)0x80000000+RAM_SIZE;
2797     }
2798   }
2799   if(!c) {
2800     emit_shlimm(addr,3,temp);
2801     if (opcode[i]==0x22||opcode[i]==0x26) {
2802       emit_andimm(addr,0xFFFFFFFC,temp2); // LWL/LWR
2803     }else{
2804       emit_andimm(addr,0xFFFFFFF8,temp2); // LDL/LDR
2805     }
2806     jaddr=emit_fastpath_cmp_jump(i,temp2,&fastio_reg_override);
2807   }
2808   else {
2809     if(ram_offset&&memtarget) {
2810       host_tempreg_acquire();
2811       emit_addimm(temp2,ram_offset,HOST_TEMPREG);
2812       fastio_reg_override=HOST_TEMPREG;
2813     }
2814     if (opcode[i]==0x22||opcode[i]==0x26) {
2815       emit_movimm(((constmap[i][s]+offset)<<3)&24,temp); // LWL/LWR
2816     }else{
2817       emit_movimm(((constmap[i][s]+offset)<<3)&56,temp); // LDL/LDR
2818     }
2819   }
2820   if (opcode[i]==0x22||opcode[i]==0x26) { // LWL/LWR
2821     if(!c||memtarget) {
2822       int a=temp2;
2823       if(fastio_reg_override>=0) a=fastio_reg_override;
2824       emit_readword_indexed(0,a,temp2);
2825       if(fastio_reg_override==HOST_TEMPREG) host_tempreg_release();
2826       if(jaddr) add_stub_r(LOADW_STUB,jaddr,out,i,temp2,i_regs,ccadj[i],reglist);
2827     }
2828     else
2829       inline_readstub(LOADW_STUB,i,(constmap[i][s]+offset)&0xFFFFFFFC,i_regs->regmap,FTEMP,ccadj[i],reglist);
2830     if(rt1[i]) {
2831       assert(tl>=0);
2832       emit_andimm(temp,24,temp);
2833       if (opcode[i]==0x22) // LWL
2834         emit_xorimm(temp,24,temp);
2835       host_tempreg_acquire();
2836       emit_movimm(-1,HOST_TEMPREG);
2837       if (opcode[i]==0x26) {
2838         emit_shr(temp2,temp,temp2);
2839         emit_bic_lsr(tl,HOST_TEMPREG,temp,tl);
2840       }else{
2841         emit_shl(temp2,temp,temp2);
2842         emit_bic_lsl(tl,HOST_TEMPREG,temp,tl);
2843       }
2844       host_tempreg_release();
2845       emit_or(temp2,tl,tl);
2846     }
2847     //emit_storereg(rt1[i],tl); // DEBUG
2848   }
2849   if (opcode[i]==0x1A||opcode[i]==0x1B) { // LDL/LDR
2850     assert(0);
2851   }
2852 }
2853 #endif
2854
2855 void store_assemble(int i,struct regstat *i_regs)
2856 {
2857   int s,tl;
2858   int addr,temp;
2859   int offset;
2860   void *jaddr=0;
2861   enum stub_type type;
2862   int memtarget=0,c=0;
2863   int agr=AGEN1+(i&1);
2864   int fastio_reg_override=-1;
2865   u_int hr,reglist=0;
2866   tl=get_reg(i_regs->regmap,rs2[i]);
2867   s=get_reg(i_regs->regmap,rs1[i]);
2868   temp=get_reg(i_regs->regmap,agr);
2869   if(temp<0) temp=get_reg(i_regs->regmap,-1);
2870   offset=imm[i];
2871   if(s>=0) {
2872     c=(i_regs->wasconst>>s)&1;
2873     if(c) {
2874       memtarget=((signed int)(constmap[i][s]+offset))<(signed int)0x80000000+RAM_SIZE;
2875     }
2876   }
2877   assert(tl>=0);
2878   assert(temp>=0);
2879   for(hr=0;hr<HOST_REGS;hr++) {
2880     if(i_regs->regmap[hr]>=0) reglist|=1<<hr;
2881   }
2882   if(i_regs->regmap[HOST_CCREG]==CCREG) reglist&=~(1<<HOST_CCREG);
2883   if(offset||s<0||c) addr=temp;
2884   else addr=s;
2885   if(!c) {
2886     jaddr=emit_fastpath_cmp_jump(i,addr,&fastio_reg_override);
2887   }
2888   else if(ram_offset&&memtarget) {
2889     host_tempreg_acquire();
2890     emit_addimm(addr,ram_offset,HOST_TEMPREG);
2891     fastio_reg_override=HOST_TEMPREG;
2892   }
2893
2894   if (opcode[i]==0x28) { // SB
2895     if(!c||memtarget) {
2896       int x=0,a=temp;
2897       if(!c) a=addr;
2898       if(fastio_reg_override>=0) a=fastio_reg_override;
2899       emit_writebyte_indexed(tl,x,a);
2900     }
2901     type=STOREB_STUB;
2902   }
2903   if (opcode[i]==0x29) { // SH
2904     if(!c||memtarget) {
2905       int x=0,a=temp;
2906       if(!c) a=addr;
2907       if(fastio_reg_override>=0) a=fastio_reg_override;
2908       emit_writehword_indexed(tl,x,a);
2909     }
2910     type=STOREH_STUB;
2911   }
2912   if (opcode[i]==0x2B) { // SW
2913     if(!c||memtarget) {
2914       int a=addr;
2915       if(fastio_reg_override>=0) a=fastio_reg_override;
2916       emit_writeword_indexed(tl,0,a);
2917     }
2918     type=STOREW_STUB;
2919   }
2920   if (opcode[i]==0x3F) { // SD
2921     assert(0);
2922     type=STORED_STUB;
2923   }
2924   if(fastio_reg_override==HOST_TEMPREG)
2925     host_tempreg_release();
2926   if(jaddr) {
2927     // PCSX store handlers don't check invcode again
2928     reglist|=1<<addr;
2929     add_stub_r(type,jaddr,out,i,addr,i_regs,ccadj[i],reglist);
2930     jaddr=0;
2931   }
2932   if(!(i_regs->waswritten&(1<<rs1[i]))&&!(new_dynarec_hacks&NDHACK_NO_SMC_CHECK)) {
2933     if(!c||memtarget) {
2934       #ifdef DESTRUCTIVE_SHIFT
2935       // The x86 shift operation is 'destructive'; it overwrites the
2936       // source register, so we need to make a copy first and use that.
2937       addr=temp;
2938       #endif
2939       #if defined(HOST_IMM8)
2940       int ir=get_reg(i_regs->regmap,INVCP);
2941       assert(ir>=0);
2942       emit_cmpmem_indexedsr12_reg(ir,addr,1);
2943       #else
2944       emit_cmpmem_indexedsr12_imm(invalid_code,addr,1);
2945       #endif
2946       #if defined(HAVE_CONDITIONAL_CALL) && !defined(DESTRUCTIVE_SHIFT)
2947       emit_callne(invalidate_addr_reg[addr]);
2948       #else
2949       void *jaddr2 = out;
2950       emit_jne(0);
2951       add_stub(INVCODE_STUB,jaddr2,out,reglist|(1<<HOST_CCREG),addr,0,0,0);
2952       #endif
2953     }
2954   }
2955   u_int addr_val=constmap[i][s]+offset;
2956   if(jaddr) {
2957     add_stub_r(type,jaddr,out,i,addr,i_regs,ccadj[i],reglist);
2958   } else if(c&&!memtarget) {
2959     inline_writestub(type,i,addr_val,i_regs->regmap,rs2[i],ccadj[i],reglist);
2960   }
2961   // basic current block modification detection..
2962   // not looking back as that should be in mips cache already
2963   // (see Spyro2 title->attract mode)
2964   if(c&&start+i*4<addr_val&&addr_val<start+slen*4) {
2965     SysPrintf("write to %08x hits block %08x, pc=%08x\n",addr_val,start,start+i*4);
2966     assert(i_regs->regmap==regs[i].regmap); // not delay slot
2967     if(i_regs->regmap==regs[i].regmap) {
2968       load_all_consts(regs[i].regmap_entry,regs[i].wasdirty,i);
2969       wb_dirtys(regs[i].regmap_entry,regs[i].wasdirty);
2970       emit_movimm(start+i*4+4,0);
2971       emit_writeword(0,&pcaddr);
2972       emit_addimm(HOST_CCREG,2,HOST_CCREG);
2973       emit_far_call(get_addr_ht);
2974       emit_jmpreg(0);
2975     }
2976   }
2977 }
2978
2979 static void storelr_assemble(int i,struct regstat *i_regs)
2980 {
2981   int s,tl;
2982   int temp;
2983   int offset;
2984   void *jaddr=0;
2985   void *case1, *case2, *case3;
2986   void *done0, *done1, *done2;
2987   int memtarget=0,c=0;
2988   int agr=AGEN1+(i&1);
2989   u_int hr,reglist=0;
2990   tl=get_reg(i_regs->regmap,rs2[i]);
2991   s=get_reg(i_regs->regmap,rs1[i]);
2992   temp=get_reg(i_regs->regmap,agr);
2993   if(temp<0) temp=get_reg(i_regs->regmap,-1);
2994   offset=imm[i];
2995   if(s>=0) {
2996     c=(i_regs->isconst>>s)&1;
2997     if(c) {
2998       memtarget=((signed int)(constmap[i][s]+offset))<(signed int)0x80000000+RAM_SIZE;
2999     }
3000   }
3001   assert(tl>=0);
3002   for(hr=0;hr<HOST_REGS;hr++) {
3003     if(i_regs->regmap[hr]>=0) reglist|=1<<hr;
3004   }
3005   assert(temp>=0);
3006   if(!c) {
3007     emit_cmpimm(s<0||offset?temp:s,RAM_SIZE);
3008     if(!offset&&s!=temp) emit_mov(s,temp);
3009     jaddr=out;
3010     emit_jno(0);
3011   }
3012   else
3013   {
3014     if(!memtarget||!rs1[i]) {
3015       jaddr=out;
3016       emit_jmp(0);
3017     }
3018   }
3019   if(ram_offset)
3020     emit_addimm_no_flags(ram_offset,temp);
3021
3022   if (opcode[i]==0x2C||opcode[i]==0x2D) { // SDL/SDR
3023     assert(0);
3024   }
3025
3026   emit_xorimm(temp,3,temp);
3027   emit_testimm(temp,2);
3028   case2=out;
3029   emit_jne(0);
3030   emit_testimm(temp,1);
3031   case1=out;
3032   emit_jne(0);
3033   // 0
3034   if (opcode[i]==0x2A) { // SWL
3035     emit_writeword_indexed(tl,0,temp);
3036   }
3037   else if (opcode[i]==0x2E) { // SWR
3038     emit_writebyte_indexed(tl,3,temp);
3039   }
3040   else
3041     assert(0);
3042   done0=out;
3043   emit_jmp(0);
3044   // 1
3045   set_jump_target(case1, out);
3046   if (opcode[i]==0x2A) { // SWL
3047     // Write 3 msb into three least significant bytes
3048     if(rs2[i]) emit_rorimm(tl,8,tl);
3049     emit_writehword_indexed(tl,-1,temp);
3050     if(rs2[i]) emit_rorimm(tl,16,tl);
3051     emit_writebyte_indexed(tl,1,temp);
3052     if(rs2[i]) emit_rorimm(tl,8,tl);
3053   }
3054   else if (opcode[i]==0x2E) { // SWR
3055     // Write two lsb into two most significant bytes
3056     emit_writehword_indexed(tl,1,temp);
3057   }
3058   done1=out;
3059   emit_jmp(0);
3060   // 2
3061   set_jump_target(case2, out);
3062   emit_testimm(temp,1);
3063   case3=out;
3064   emit_jne(0);
3065   if (opcode[i]==0x2A) { // SWL
3066     // Write two msb into two least significant bytes
3067     if(rs2[i]) emit_rorimm(tl,16,tl);
3068     emit_writehword_indexed(tl,-2,temp);
3069     if(rs2[i]) emit_rorimm(tl,16,tl);
3070   }
3071   else if (opcode[i]==0x2E) { // SWR
3072     // Write 3 lsb into three most significant bytes
3073     emit_writebyte_indexed(tl,-1,temp);
3074     if(rs2[i]) emit_rorimm(tl,8,tl);
3075     emit_writehword_indexed(tl,0,temp);
3076     if(rs2[i]) emit_rorimm(tl,24,tl);
3077   }
3078   done2=out;
3079   emit_jmp(0);
3080   // 3
3081   set_jump_target(case3, out);
3082   if (opcode[i]==0x2A) { // SWL
3083     // Write msb into least significant byte
3084     if(rs2[i]) emit_rorimm(tl,24,tl);
3085     emit_writebyte_indexed(tl,-3,temp);
3086     if(rs2[i]) emit_rorimm(tl,8,tl);
3087   }
3088   else if (opcode[i]==0x2E) { // SWR
3089     // Write entire word
3090     emit_writeword_indexed(tl,-3,temp);
3091   }
3092   set_jump_target(done0, out);
3093   set_jump_target(done1, out);
3094   set_jump_target(done2, out);
3095   if(!c||!memtarget)
3096     add_stub_r(STORELR_STUB,jaddr,out,i,temp,i_regs,ccadj[i],reglist);
3097   if(!(i_regs->waswritten&(1<<rs1[i]))&&!(new_dynarec_hacks&NDHACK_NO_SMC_CHECK)) {
3098     emit_addimm_no_flags(-ram_offset,temp);
3099     #if defined(HOST_IMM8)
3100     int ir=get_reg(i_regs->regmap,INVCP);
3101     assert(ir>=0);
3102     emit_cmpmem_indexedsr12_reg(ir,temp,1);
3103     #else
3104     emit_cmpmem_indexedsr12_imm(invalid_code,temp,1);
3105     #endif
3106     #if defined(HAVE_CONDITIONAL_CALL) && !defined(DESTRUCTIVE_SHIFT)
3107     emit_callne(invalidate_addr_reg[temp]);
3108     #else
3109     void *jaddr2 = out;
3110     emit_jne(0);
3111     add_stub(INVCODE_STUB,jaddr2,out,reglist|(1<<HOST_CCREG),temp,0,0,0);
3112     #endif
3113   }
3114 }
3115
3116 static void cop0_assemble(int i,struct regstat *i_regs)
3117 {
3118   if(opcode2[i]==0) // MFC0
3119   {
3120     signed char t=get_reg(i_regs->regmap,rt1[i]);
3121     u_int copr=(source[i]>>11)&0x1f;
3122     //assert(t>=0); // Why does this happen?  OOT is weird
3123     if(t>=0&&rt1[i]!=0) {
3124       emit_readword(&reg_cop0[copr],t);
3125     }
3126   }
3127   else if(opcode2[i]==4) // MTC0
3128   {
3129     signed char s=get_reg(i_regs->regmap,rs1[i]);
3130     char copr=(source[i]>>11)&0x1f;
3131     assert(s>=0);
3132     wb_register(rs1[i],i_regs->regmap,i_regs->dirty);
3133     if(copr==9||copr==11||copr==12||copr==13) {
3134       emit_readword(&last_count,HOST_TEMPREG);
3135       emit_loadreg(CCREG,HOST_CCREG); // TODO: do proper reg alloc
3136       emit_add(HOST_CCREG,HOST_TEMPREG,HOST_CCREG);
3137       emit_addimm(HOST_CCREG,CLOCK_ADJUST(ccadj[i]),HOST_CCREG);
3138       emit_writeword(HOST_CCREG,&Count);
3139     }
3140     // What a mess.  The status register (12) can enable interrupts,
3141     // so needs a special case to handle a pending interrupt.
3142     // The interrupt must be taken immediately, because a subsequent
3143     // instruction might disable interrupts again.
3144     if(copr==12||copr==13) {
3145       if (is_delayslot) {
3146         // burn cycles to cause cc_interrupt, which will
3147         // reschedule next_interupt. Relies on CCREG from above.
3148         assem_debug("MTC0 DS %d\n", copr);
3149         emit_writeword(HOST_CCREG,&last_count);
3150         emit_movimm(0,HOST_CCREG);
3151         emit_storereg(CCREG,HOST_CCREG);
3152         emit_loadreg(rs1[i],1);
3153         emit_movimm(copr,0);
3154         emit_far_call(pcsx_mtc0_ds);
3155         emit_loadreg(rs1[i],s);
3156         return;
3157       }
3158       emit_movimm(start+i*4+4,HOST_TEMPREG);
3159       emit_writeword(HOST_TEMPREG,&pcaddr);
3160       emit_movimm(0,HOST_TEMPREG);
3161       emit_writeword(HOST_TEMPREG,&pending_exception);
3162     }
3163     if(s==HOST_CCREG)
3164       emit_loadreg(rs1[i],1);
3165     else if(s!=1)
3166       emit_mov(s,1);
3167     emit_movimm(copr,0);
3168     emit_far_call(pcsx_mtc0);
3169     if(copr==9||copr==11||copr==12||copr==13) {
3170       emit_readword(&Count,HOST_CCREG);
3171       emit_readword(&next_interupt,HOST_TEMPREG);
3172       emit_addimm(HOST_CCREG,-CLOCK_ADJUST(ccadj[i]),HOST_CCREG);
3173       emit_sub(HOST_CCREG,HOST_TEMPREG,HOST_CCREG);
3174       emit_writeword(HOST_TEMPREG,&last_count);
3175       emit_storereg(CCREG,HOST_CCREG);
3176     }
3177     if(copr==12||copr==13) {
3178       assert(!is_delayslot);
3179       emit_readword(&pending_exception,14);
3180       emit_test(14,14);
3181       void *jaddr = out;
3182       emit_jeq(0);
3183       emit_readword(&pcaddr, 0);
3184       emit_addimm(HOST_CCREG,2,HOST_CCREG);
3185       emit_far_call(get_addr_ht);
3186       emit_jmpreg(0);
3187       set_jump_target(jaddr, out);
3188     }
3189     emit_loadreg(rs1[i],s);
3190   }
3191   else
3192   {
3193     assert(opcode2[i]==0x10);
3194     //if((source[i]&0x3f)==0x10) // RFE
3195     {
3196       emit_readword(&Status,0);
3197       emit_andimm(0,0x3c,1);
3198       emit_andimm(0,~0xf,0);
3199       emit_orrshr_imm(1,2,0);
3200       emit_writeword(0,&Status);
3201     }
3202   }
3203 }
3204
3205 static void cop1_unusable(int i,struct regstat *i_regs)
3206 {
3207   // XXX: should just just do the exception instead
3208   //if(!cop1_usable)
3209   {
3210     void *jaddr=out;
3211     emit_jmp(0);
3212     add_stub_r(FP_STUB,jaddr,out,i,0,i_regs,is_delayslot,0);
3213   }
3214 }
3215
3216 static void cop1_assemble(int i,struct regstat *i_regs)
3217 {
3218   cop1_unusable(i, i_regs);
3219 }
3220
3221 static void c1ls_assemble(int i,struct regstat *i_regs)
3222 {
3223   cop1_unusable(i, i_regs);
3224 }
3225
3226 // FP_STUB
3227 static void do_cop1stub(int n)
3228 {
3229   literal_pool(256);
3230   assem_debug("do_cop1stub %x\n",start+stubs[n].a*4);
3231   set_jump_target(stubs[n].addr, out);
3232   int i=stubs[n].a;
3233 //  int rs=stubs[n].b;
3234   struct regstat *i_regs=(struct regstat *)stubs[n].c;
3235   int ds=stubs[n].d;
3236   if(!ds) {
3237     load_all_consts(regs[i].regmap_entry,regs[i].wasdirty,i);
3238     //if(i_regs!=&regs[i]) printf("oops: regs[i]=%x i_regs=%x",(int)&regs[i],(int)i_regs);
3239   }
3240   //else {printf("fp exception in delay slot\n");}
3241   wb_dirtys(i_regs->regmap_entry,i_regs->wasdirty);
3242   if(regs[i].regmap_entry[HOST_CCREG]!=CCREG) emit_loadreg(CCREG,HOST_CCREG);
3243   emit_movimm(start+(i-ds)*4,EAX); // Get PC
3244   emit_addimm(HOST_CCREG,CLOCK_ADJUST(ccadj[i]),HOST_CCREG); // CHECK: is this right?  There should probably be an extra cycle...
3245   emit_far_jump(ds?fp_exception_ds:fp_exception);
3246 }
3247
3248 static void cop2_get_dreg(u_int copr,signed char tl,signed char temp)
3249 {
3250   switch (copr) {
3251     case 1:
3252     case 3:
3253     case 5:
3254     case 8:
3255     case 9:
3256     case 10:
3257     case 11:
3258       emit_readword(&reg_cop2d[copr],tl);
3259       emit_signextend16(tl,tl);
3260       emit_writeword(tl,&reg_cop2d[copr]); // hmh
3261       break;
3262     case 7:
3263     case 16:
3264     case 17:
3265     case 18:
3266     case 19:
3267       emit_readword(&reg_cop2d[copr],tl);
3268       emit_andimm(tl,0xffff,tl);
3269       emit_writeword(tl,&reg_cop2d[copr]);
3270       break;
3271     case 15:
3272       emit_readword(&reg_cop2d[14],tl); // SXY2
3273       emit_writeword(tl,&reg_cop2d[copr]);
3274       break;
3275     case 28:
3276     case 29:
3277       c2op_mfc2_29_assemble(tl,temp);
3278       break;
3279     default:
3280       emit_readword(&reg_cop2d[copr],tl);
3281       break;
3282   }
3283 }
3284
3285 static void cop2_put_dreg(u_int copr,signed char sl,signed char temp)
3286 {
3287   switch (copr) {
3288     case 15:
3289       emit_readword(&reg_cop2d[13],temp);  // SXY1
3290       emit_writeword(sl,&reg_cop2d[copr]);
3291       emit_writeword(temp,&reg_cop2d[12]); // SXY0
3292       emit_readword(&reg_cop2d[14],temp);  // SXY2
3293       emit_writeword(sl,&reg_cop2d[14]);
3294       emit_writeword(temp,&reg_cop2d[13]); // SXY1
3295       break;
3296     case 28:
3297       emit_andimm(sl,0x001f,temp);
3298       emit_shlimm(temp,7,temp);
3299       emit_writeword(temp,&reg_cop2d[9]);
3300       emit_andimm(sl,0x03e0,temp);
3301       emit_shlimm(temp,2,temp);
3302       emit_writeword(temp,&reg_cop2d[10]);
3303       emit_andimm(sl,0x7c00,temp);
3304       emit_shrimm(temp,3,temp);
3305       emit_writeword(temp,&reg_cop2d[11]);
3306       emit_writeword(sl,&reg_cop2d[28]);
3307       break;
3308     case 30:
3309       emit_xorsar_imm(sl,sl,31,temp);
3310 #if defined(HAVE_ARMV5) || defined(__aarch64__)
3311       emit_clz(temp,temp);
3312 #else
3313       emit_movs(temp,HOST_TEMPREG);
3314       emit_movimm(0,temp);
3315       emit_jeq((int)out+4*4);
3316       emit_addpl_imm(temp,1,temp);
3317       emit_lslpls_imm(HOST_TEMPREG,1,HOST_TEMPREG);
3318       emit_jns((int)out-2*4);
3319 #endif
3320       emit_writeword(sl,&reg_cop2d[30]);
3321       emit_writeword(temp,&reg_cop2d[31]);
3322       break;
3323     case 31:
3324       break;
3325     default:
3326       emit_writeword(sl,&reg_cop2d[copr]);
3327       break;
3328   }
3329 }
3330
3331 static void c2ls_assemble(int i,struct regstat *i_regs)
3332 {
3333   int s,tl;
3334   int ar;
3335   int offset;
3336   int memtarget=0,c=0;
3337   void *jaddr2=NULL;
3338   enum stub_type type;
3339   int agr=AGEN1+(i&1);
3340   int fastio_reg_override=-1;
3341   u_int hr,reglist=0;
3342   u_int copr=(source[i]>>16)&0x1f;
3343   s=get_reg(i_regs->regmap,rs1[i]);
3344   tl=get_reg(i_regs->regmap,FTEMP);
3345   offset=imm[i];
3346   assert(rs1[i]>0);
3347   assert(tl>=0);
3348
3349   for(hr=0;hr<HOST_REGS;hr++) {
3350     if(i_regs->regmap[hr]>=0) reglist|=1<<hr;
3351   }
3352   if(i_regs->regmap[HOST_CCREG]==CCREG)
3353     reglist&=~(1<<HOST_CCREG);
3354
3355   // get the address
3356   if (opcode[i]==0x3a) { // SWC2
3357     ar=get_reg(i_regs->regmap,agr);
3358     if(ar<0) ar=get_reg(i_regs->regmap,-1);
3359     reglist|=1<<ar;
3360   } else { // LWC2
3361     ar=tl;
3362   }
3363   if(s>=0) c=(i_regs->wasconst>>s)&1;
3364   memtarget=c&&(((signed int)(constmap[i][s]+offset))<(signed int)0x80000000+RAM_SIZE);
3365   if (!offset&&!c&&s>=0) ar=s;
3366   assert(ar>=0);
3367
3368   if (opcode[i]==0x3a) { // SWC2
3369     cop2_get_dreg(copr,tl,-1);
3370     type=STOREW_STUB;
3371   }
3372   else
3373     type=LOADW_STUB;
3374
3375   if(c&&!memtarget) {
3376     jaddr2=out;
3377     emit_jmp(0); // inline_readstub/inline_writestub?
3378   }
3379   else {
3380     if(!c) {
3381       jaddr2=emit_fastpath_cmp_jump(i,ar,&fastio_reg_override);
3382     }
3383     else if(ram_offset&&memtarget) {
3384       host_tempreg_acquire();
3385       emit_addimm(ar,ram_offset,HOST_TEMPREG);
3386       fastio_reg_override=HOST_TEMPREG;
3387     }
3388     if (opcode[i]==0x32) { // LWC2
3389       int a=ar;
3390       if(fastio_reg_override>=0) a=fastio_reg_override;
3391       emit_readword_indexed(0,a,tl);
3392     }
3393     if (opcode[i]==0x3a) { // SWC2
3394       #ifdef DESTRUCTIVE_SHIFT
3395       if(!offset&&!c&&s>=0) emit_mov(s,ar);
3396       #endif
3397       int a=ar;
3398       if(fastio_reg_override>=0) a=fastio_reg_override;
3399       emit_writeword_indexed(tl,0,a);
3400     }
3401   }
3402   if(fastio_reg_override==HOST_TEMPREG)
3403     host_tempreg_release();
3404   if(jaddr2)
3405     add_stub_r(type,jaddr2,out,i,ar,i_regs,ccadj[i],reglist);
3406   if(opcode[i]==0x3a) // SWC2
3407   if(!(i_regs->waswritten&(1<<rs1[i]))&&!(new_dynarec_hacks&NDHACK_NO_SMC_CHECK)) {
3408 #if defined(HOST_IMM8)
3409     int ir=get_reg(i_regs->regmap,INVCP);
3410     assert(ir>=0);
3411     emit_cmpmem_indexedsr12_reg(ir,ar,1);
3412 #else
3413     emit_cmpmem_indexedsr12_imm(invalid_code,ar,1);
3414 #endif
3415     #if defined(HAVE_CONDITIONAL_CALL) && !defined(DESTRUCTIVE_SHIFT)
3416     emit_callne(invalidate_addr_reg[ar]);
3417     #else
3418     void *jaddr3 = out;
3419     emit_jne(0);
3420     add_stub(INVCODE_STUB,jaddr3,out,reglist|(1<<HOST_CCREG),ar,0,0,0);
3421     #endif
3422   }
3423   if (opcode[i]==0x32) { // LWC2
3424     host_tempreg_acquire();
3425     cop2_put_dreg(copr,tl,HOST_TEMPREG);
3426     host_tempreg_release();
3427   }
3428 }
3429
3430 static void cop2_assemble(int i,struct regstat *i_regs)
3431 {
3432   u_int copr=(source[i]>>11)&0x1f;
3433   signed char temp=get_reg(i_regs->regmap,-1);
3434   if (opcode2[i]==0) { // MFC2
3435     signed char tl=get_reg(i_regs->regmap,rt1[i]);
3436     if(tl>=0&&rt1[i]!=0)
3437       cop2_get_dreg(copr,tl,temp);
3438   }
3439   else if (opcode2[i]==4) { // MTC2
3440     signed char sl=get_reg(i_regs->regmap,rs1[i]);
3441     cop2_put_dreg(copr,sl,temp);
3442   }
3443   else if (opcode2[i]==2) // CFC2
3444   {
3445     signed char tl=get_reg(i_regs->regmap,rt1[i]);
3446     if(tl>=0&&rt1[i]!=0)
3447       emit_readword(&reg_cop2c[copr],tl);
3448   }
3449   else if (opcode2[i]==6) // CTC2
3450   {
3451     signed char sl=get_reg(i_regs->regmap,rs1[i]);
3452     switch(copr) {
3453       case 4:
3454       case 12:
3455       case 20: