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