/[gxemul]/trunk/src/cpus/cpu_mips.c
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Diff of /trunk/src/cpus/cpu_mips.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 18 by dpavlin, Mon Oct 8 16:19:11 2007 UTC revision 32 by dpavlin, Mon Oct 8 16:20:58 2007 UTC
# Line 1  Line 1 
1  /*  /*
2   *  Copyright (C) 2003-2005  Anders Gavare.  All rights reserved.   *  Copyright (C) 2003-2006  Anders Gavare.  All rights reserved.
3   *   *
4   *  Redistribution and use in source and binary forms, with or without   *  Redistribution and use in source and binary forms, with or without
5   *  modification, are permitted provided that the following conditions are met:   *  modification, are permitted provided that the following conditions are met:
# Line 25  Line 25 
25   *  SUCH DAMAGE.   *  SUCH DAMAGE.
26   *   *
27   *   *
28   *  $Id: cpu_mips.c,v 1.6 2005/10/26 14:37:02 debug Exp $   *  $Id: cpu_mips.c,v 1.69 2006/10/07 02:05:21 debug Exp $
29   *   *
30   *  MIPS core CPU emulation.   *  MIPS core CPU emulation.
31   */   */
# Line 35  Line 35 
35  #include <string.h>  #include <string.h>
36  #include <sys/types.h>  #include <sys/types.h>
37  #include <ctype.h>  #include <ctype.h>
38    #include <unistd.h>
39    
40  #include "../../config.h"  #include "../../config.h"
41    
   
 #ifndef ENABLE_MIPS  
   
   
 #include "cpu_mips.h"  
   
 /*  
  *  mips_cpu_family_init():  
  *  
  *  Bogus function.  
  */  
 int mips_cpu_family_init(struct cpu_family *fp)  
 {  
         return 0;  
 }  
   
   
 /*  TODO: Maybe it isn't very nice to have these global like this...  */  
 void mips_cpu_exception(struct cpu *cpu, int exccode, int tlb, uint64_t vaddr,  
         int coproc_nr, uint64_t vaddr_vpn2, int vaddr_asid, int x_64)  { }  
   
   
 #else   /*  ENABLE_MIPS  */  
   
   
42  #include "arcbios.h"  #include "arcbios.h"
 #include "bintrans.h"  
43  #include "cop0.h"  #include "cop0.h"
44  #include "cpu.h"  #include "cpu.h"
45  #include "cpu_mips.h"  #include "cpu_mips.h"
# Line 75  void mips_cpu_exception(struct cpu *cpu, Line 50  void mips_cpu_exception(struct cpu *cpu,
50  #include "memory.h"  #include "memory.h"
51  #include "mips_cpu_types.h"  #include "mips_cpu_types.h"
52  #include "opcodes_mips.h"  #include "opcodes_mips.h"
53    #include "settings.h"
54  #include "symbol.h"  #include "symbol.h"
55    
56    
57  extern volatile int single_step;  extern volatile int single_step;
 extern int show_opcode_statistics;  
 extern int old_show_trace_tree;  
 extern int old_instruction_trace;  
 extern int old_quiet_mode;  
 extern int quiet_mode;  
58    
59  static char *exception_names[] = EXCEPTION_NAMES;  static char *exception_names[] = EXCEPTION_NAMES;
60    
61  static char *hi6_names[] = HI6_NAMES;  static char *hi6_names[] = HI6_NAMES;
62  static char *regimm_names[] = REGIMM_NAMES;  static char *regimm_names[] = REGIMM_NAMES;
63  static char *special_names[] = SPECIAL_NAMES;  static char *special_names[] = SPECIAL_NAMES;
64    static char *special_rot_names[] = SPECIAL_ROT_NAMES;
65  static char *special2_names[] = SPECIAL2_NAMES;  static char *special2_names[] = SPECIAL2_NAMES;
66    static char *mmi_names[] = MMI_NAMES;
67    static char *mmi0_names[] = MMI0_NAMES;
68    static char *mmi1_names[] = MMI1_NAMES;
69    static char *mmi2_names[] = MMI2_NAMES;
70    static char *mmi3_names[] = MMI3_NAMES;
71    static char *special3_names[] = SPECIAL3_NAMES;
72    
73  static char *regnames[] = MIPS_REGISTER_NAMES;  static char *regnames[] = MIPS_REGISTER_NAMES;
74  static char *cop0_names[] = COP0_NAMES;  static char *cop0_names[] = COP0_NAMES;
75    
76  #include "cpu_mips16.c"  
77    #define DYNTRANS_DUALMODE_32
78    #define DYNTRANS_DELAYSLOT
79    #include "tmp_mips_head.c"
80    
81    void mips_pc_to_pointers(struct cpu *);
82    void mips32_pc_to_pointers(struct cpu *);
83    
84    
85  /*  /*
# Line 152  int mips_cpu_new(struct cpu *cpu, struct Line 136  int mips_cpu_new(struct cpu *cpu, struct
136          if (found == -1)          if (found == -1)
137                  return 0;                  return 0;
138    
139          cpu->memory_rw          = mips_memory_rw;          cpu->memory_rw                = mips_memory_rw;
140          cpu->cd.mips.cpu_type   = cpu_type_defs[found];          cpu->cd.mips.cpu_type         = cpu_type_defs[found];
141          cpu->name               = cpu->cd.mips.cpu_type.name;          cpu->name                     = cpu->cd.mips.cpu_type.name;
142          cpu->byte_order         = EMUL_LITTLE_ENDIAN;          cpu->byte_order               = EMUL_LITTLE_ENDIAN;
143          cpu->cd.mips.gpr[MIPS_GPR_SP] = INITIAL_STACK_POINTER;          cpu->cd.mips.gpr[MIPS_GPR_SP] = INITIAL_STACK_POINTER;
         cpu->update_translation_table = mips_update_translation_table;  
         cpu->invalidate_translation_caches =  
             mips_invalidate_translation_caches_paddr;  
144    
145          if (cpu->cd.mips.cpu_type.isa_level <= 2 ||          if (cpu->cd.mips.cpu_type.isa_level <= 2 ||
146              cpu->cd.mips.cpu_type.isa_level == 32)              cpu->cd.mips.cpu_type.isa_level == 32)
147                  cpu->is_32bit = 1;                  cpu->is_32bit = 1;
148    
149            if (cpu->is_32bit) {
150                    cpu->run_instr = mips32_run_instr;
151                    cpu->update_translation_table = mips32_update_translation_table;
152                    cpu->invalidate_translation_caches =
153                        mips32_invalidate_translation_caches;
154                    cpu->invalidate_code_translation =
155                        mips32_invalidate_code_translation;
156            } else {
157                    cpu->run_instr = mips_run_instr;
158                    cpu->update_translation_table = mips_update_translation_table;
159                    cpu->invalidate_translation_caches =
160                        mips_invalidate_translation_caches;
161                    cpu->invalidate_code_translation =
162                        mips_invalidate_code_translation;
163            }
164    
165            cpu->instruction_has_delayslot = mips_cpu_instruction_has_delayslot;
166    
167          if (cpu_id == 0)          if (cpu_id == 0)
168                  debug("%s", cpu->cd.mips.cpu_type.name);                  debug("%s", cpu->cd.mips.cpu_type.name);
169    
# Line 309  int mips_cpu_new(struct cpu *cpu, struct Line 308  int mips_cpu_new(struct cpu *cpu, struct
308          cpu->cd.mips.coproc[0] = mips_coproc_new(cpu, 0);          cpu->cd.mips.coproc[0] = mips_coproc_new(cpu, 0);
309          cpu->cd.mips.coproc[1] = mips_coproc_new(cpu, 1);          cpu->cd.mips.coproc[1] = mips_coproc_new(cpu, 1);
310    
         /*  
          *  Initialize the cpu->cd.mips.pc_last_* cache (a 1-entry cache of the  
          *  last program counter value).  For pc_last_virtual_page, any  
          *  "impossible" value will do.  The pc should never ever get this  
          *  value.  (The other pc_last* variables do not need initialization,  
          *  as they are not used before pc_last_virtual_page.)  
          */  
         cpu->cd.mips.pc_last_virtual_page = PC_LAST_PAGE_IMPOSSIBLE_VALUE;  
   
311          switch (cpu->cd.mips.cpu_type.mmu_model) {          switch (cpu->cd.mips.cpu_type.mmu_model) {
312          case MMU3K:          case MMU3K:
313                  cpu->translate_address = translate_address_mmu3k;                  cpu->translate_v2p = translate_v2p_mmu3k;
314                  break;                  break;
315          case MMU8K:          case MMU8K:
316                  cpu->translate_address = translate_address_mmu8k;                  cpu->translate_v2p = translate_v2p_mmu8k;
317                  break;                  break;
318          case MMU10K:          case MMU10K:
319                  cpu->translate_address = translate_address_mmu10k;                  cpu->translate_v2p = translate_v2p_mmu10k;
320                  break;                  break;
321          default:          default:
322                  if (cpu->cd.mips.cpu_type.rev == MIPS_R4100)                  if (cpu->cd.mips.cpu_type.rev == MIPS_R4100)
323                          cpu->translate_address = translate_address_mmu4100;                          cpu->translate_v2p = translate_v2p_mmu4100;
324                  else                  else
325                          cpu->translate_address = translate_address_generic;                          cpu->translate_v2p = translate_v2p_generic;
326          }          }
327    
328  /*  Testing:  */          if (cpu->machine->prom_emulation) {
329          cpu->cd.mips.host_load = zeroed_alloc(1048576 *                  /*
330              sizeof(unsigned char *));                   *  Default behaviour of jumping to 0xbfc00000 should be
331          cpu->cd.mips.host_store = zeroed_alloc(1048576 *                   *  a reboot, unless machine-specific initialization code
332              sizeof(unsigned char *));                   *  overrides this.
333          cpu->cd.mips.host_load_orig = cpu->cd.mips.host_load;                   *
334          cpu->cd.mips.host_store_orig = cpu->cd.mips.host_store;                   *  Note: Specifically big-endian machines should override
335                     *  this, since the default MIPS CPU is little-endian!
336                     */
337                    store_32bit_word(cpu, 0xffffffff9fc00000ULL, 0x00c0de0d);
338            }
339    
340            /*  Add all register names to the settings:  */
341            CPU_SETTINGS_ADD_REGISTER64("pc", cpu->pc);
342            CPU_SETTINGS_ADD_REGISTER64("hi", cpu->cd.mips.hi);
343            CPU_SETTINGS_ADD_REGISTER64("lo", cpu->cd.mips.lo);
344            for (i=0; i<N_MIPS_GPRS; i++)
345                    CPU_SETTINGS_ADD_REGISTER64(regnames[i], cpu->cd.mips.gpr[i]);
346            /*  TODO: Write via special handler function!  */
347            for (i=0; i<N_MIPS_COPROC_REGS; i++)
348                    CPU_SETTINGS_ADD_REGISTER64(cop0_names[i],
349                        cpu->cd.mips.coproc[0]->reg[i]);
350    
351          return 1;          return 1;
352  }  }
353    
354    
355  /*  /*
356   *  mips_cpu_show_full_statistics():   *  mips_cpu_dumpinfo():
357   *   *
358   *  Show detailed statistics on opcode usage on each cpu.   *  Debug dump of MIPS-specific CPU data for specific CPU.
359   */   */
360  void mips_cpu_show_full_statistics(struct machine *m)  void mips_cpu_dumpinfo(struct cpu *cpu)
361  {  {
362          int i, s1, s2, iadd = 4;          int iadd = DEBUG_INDENTATION;
363            struct mips_cpu_type_def *ct = &cpu->cd.mips.cpu_type;
364    
365          if (m->bintrans_enable)          debug_indentation(iadd);
                 fatal("NOTE: Dynamic binary translation is used; this list"  
                     " of opcode usage\n      only includes instructions that"  
                     " were interpreted manually!\n");  
366    
367          for (i=0; i<m->ncpus; i++) {          debug("\n%i-bit %s-endian (MIPS",
368                  fatal("cpu%i opcode statistics:\n", i);              cpu->is_32bit? 32 : 64,
369                  debug_indentation(iadd);              cpu->byte_order == EMUL_BIG_ENDIAN? "Big" : "Little");
370    
371                  for (s1=0; s1<N_HI6; s1++) {          switch (ct->isa_level) {
372                          if (m->cpus[i]->cd.mips.stats_opcode[s1] > 0)          case 1: debug(" ISA I"); break;
373                                  fatal("opcode %02x (%7s): %li\n", s1,          case 2: debug(" ISA II"); break;
374                                      hi6_names[s1],          case 3: debug(" ISA III"); break;
375                                      m->cpus[i]->cd.mips.stats_opcode[s1]);          case 4: debug(" ISA IV"); break;
376            case 5: debug(" ISA V"); break;
377                          debug_indentation(iadd);          case 32:
378                          if (s1 == HI6_SPECIAL)          case 64:debug("%i, revision %i", ct->isa_level, ct->isa_revision);
379                                  for (s2=0; s2<N_SPECIAL; s2++)                  break;
380                                          if (m->cpus[i]->cd.mips.stats__special[          default:debug(" ISA level %i", ct->isa_level);
381                                              s2] > 0)          }
                                                 fatal("special %02x (%7s): "  
                                                     "%li\n", s2, special_names[  
                                                     s2], m->cpus[i]->cd.mips.  
                                                     stats__special[s2]);  
                         if (s1 == HI6_REGIMM)  
                                 for (s2=0; s2<N_REGIMM; s2++)  
                                         if (m->cpus[i]->cd.mips.stats__regimm[  
                                             s2] > 0)  
                                                 fatal("regimm %02x (%7s): "  
                                                     "%li\n", s2, regimm_names[  
                                                     s2], m->cpus[i]->cd.mips.  
                                                     stats__regimm[s2]);  
                         if (s1 == HI6_SPECIAL2)  
                                 for (s2=0; s2<N_SPECIAL; s2++)  
                                         if (m->cpus[i]->cd.mips.stats__special2  
                                             [s2] > 0)  
                                                 fatal("special2 %02x (%7s): "  
                                                     "%li\n", s2,  
                                                     special2_names[s2], m->  
                                                     cpus[i]->cd.mips.  
                                                     stats__special2[s2]);  
                         debug_indentation(-iadd);  
                 }  
382    
383                  debug_indentation(-iadd);          debug("), ");
384            if (ct->nr_of_tlb_entries)
385                    debug("%i TLB entries", ct->nr_of_tlb_entries);
386            else
387                    debug("no TLB");
388            debug("\n");
389    
390            if (ct->picache) {
391                    debug("L1 I-cache: %i KB", (1 << ct->picache) / 1024);
392                    if (ct->pilinesize)
393                            debug(", %i bytes per line", 1 << ct->pilinesize);
394                    if (ct->piways > 1)
395                            debug(", %i-way", ct->piways);
396                    else
397                            debug(", direct-mapped");
398                    debug("\n");
399            }
400    
401            if (ct->pdcache) {
402                    debug("L1 D-cache: %i KB", (1 << ct->pdcache) / 1024);
403                    if (ct->pdlinesize)
404                            debug(", %i bytes per line", 1 << ct->pdlinesize);
405                    if (ct->pdways > 1)
406                            debug(", %i-way", ct->pdways);
407                    else
408                            debug(", direct-mapped");
409                    debug("\n");
410            }
411    
412            if (ct->scache) {
413                    int kb = (1 << ct->scache) / 1024;
414                    debug("L2 cache: %i %s",
415                        kb >= 1024? kb / 1024 : kb, kb >= 1024? "MB":"KB");
416                    if (ct->slinesize)
417                            debug(", %i bytes per line", 1 << ct->slinesize);
418                    if (ct->sways > 1)
419                            debug(", %i-way", ct->sways);
420                    else
421                            debug(", direct-mapped");
422                    debug("\n");
423            }
424    
425            debug_indentation(-iadd);
426    }
427    
428    
429    /*
430     *  mips_cpu_list_available_types():
431     *
432     *  Print a list of available MIPS CPU types.
433     */
434    void mips_cpu_list_available_types(void)
435    {
436            int i, j;
437            struct mips_cpu_type_def cpu_type_defs[] = MIPS_CPU_TYPE_DEFS;
438    
439            i = 0;
440            while (cpu_type_defs[i].name != NULL) {
441                    debug("%s", cpu_type_defs[i].name);
442                    for (j=10 - strlen(cpu_type_defs[i].name); j>0; j--)
443                            debug(" ");
444                    i++;
445                    if ((i % 6) == 0 || cpu_type_defs[i].name == NULL)
446                            debug("\n");
447          }          }
448  }  }
449    
450    
451  /*  /*
452     *  mips_cpu_instruction_has_delayslot():
453     *
454     *  Return 1 if an opcode is a branch, 0 otherwise.
455     */
456    int mips_cpu_instruction_has_delayslot(struct cpu *cpu, unsigned char *ib)
457    {
458            uint32_t iword = *((uint32_t *)&ib[0]);
459    
460            if (cpu->byte_order == EMUL_LITTLE_ENDIAN)
461                    iword = LE32_TO_HOST(iword);
462            else
463                    iword = BE32_TO_HOST(iword);
464    
465            switch (iword >> 26) {
466            case HI6_SPECIAL:
467                    switch (iword & 0x3f) {
468                    case SPECIAL_JR:
469                    case SPECIAL_JALR:
470                            return 1;
471                    }
472                    break;
473            case HI6_REGIMM:
474                    switch ((iword >> 16) & 0x1f) {
475                    case REGIMM_BLTZ:
476                    case REGIMM_BGEZ:
477                    case REGIMM_BLTZL:
478                    case REGIMM_BGEZL:
479                    case REGIMM_BLTZAL:
480                    case REGIMM_BLTZALL:
481                    case REGIMM_BGEZAL:
482                    case REGIMM_BGEZALL:
483                            return 1;
484                    }
485                    break;
486            case HI6_BEQ:
487            case HI6_BEQL:
488            case HI6_BNE:
489            case HI6_BNEL:
490            case HI6_BGTZ:
491            case HI6_BGTZL:
492            case HI6_BLEZ:
493            case HI6_BLEZL:
494            case HI6_J:
495            case HI6_JAL:
496                    return 1;
497            }
498    
499            return 0;
500    }
501    
502    
503    /*
504   *  mips_cpu_tlbdump():   *  mips_cpu_tlbdump():
505   *   *
506   *  Called from the debugger to dump the TLB in a readable format.   *  Called from the debugger to dump the TLB in a readable format.
# Line 418  void mips_cpu_tlbdump(struct machine *m, Line 513  void mips_cpu_tlbdump(struct machine *m,
513  {  {
514          int i, j;          int i, j;
515    
516          /*  Nicely formatted output:  */          /*  Raw output:  */
517          if (!rawflag) {          if (rawflag) {
518                  for (i=0; i<m->ncpus; i++) {                  for (i=0; i<m->ncpus; i++) {
                         int pageshift = 12;  
   
519                          if (x >= 0 && i != x)                          if (x >= 0 && i != x)
520                                  continue;                                  continue;
521    
                         if (m->cpus[i]->cd.mips.cpu_type.rev == MIPS_R4100)  
                                 pageshift = 10;  
   
522                          /*  Print index, random, and wired:  */                          /*  Print index, random, and wired:  */
523                          printf("cpu%i: (", i);                          printf("cpu%i: (", i);
524                          switch (m->cpus[i]->cd.mips.cpu_type.isa_level) {  
525                          case 1:                          if (m->cpus[i]->is_32bit)
526                          case 2:                                  printf("index=0x%08x random=0x%08x", (int)m->
527                                  printf("index=0x%x random=0x%x",                                      cpus[i]->cd.mips.coproc[0]->reg[COP0_INDEX],
528                                      (int) ((m->cpus[i]->cd.mips.coproc[0]->                                      (int)m->cpus[i]->cd.mips.coproc[0]->reg
529                                      reg[COP0_INDEX] & R2K3K_INDEX_MASK)                                      [COP0_RANDOM]);
530                                      >> R2K3K_INDEX_SHIFT),                          else
531                                      (int) ((m->cpus[i]->cd.mips.coproc[0]->                                  printf("index=0x%016"PRIx64
532                                      reg[COP0_RANDOM] & R2K3K_RANDOM_MASK)                                      " random=0x%016"PRIx64,
533                                      >> R2K3K_RANDOM_SHIFT));                                      (uint64_t)m->cpus[i]->cd.mips.coproc[0]->
534                                  break;                                      reg[COP0_INDEX], (uint64_t)m->cpus[i]->
535                          default:                                      cd.mips.coproc[0]->reg[COP0_RANDOM]);
536                                  printf("index=0x%x random=0x%x",  
537                                      (int) (m->cpus[i]->cd.mips.coproc[0]->                          if (m->cpus[i]->cd.mips.cpu_type.isa_level >= 3)
538                                      reg[COP0_INDEX] & INDEX_MASK),                                  printf(" wired=0x%"PRIx64, (uint64_t) m->cpus
539                                      (int) (m->cpus[i]->cd.mips.coproc[0]->                                      [i]->cd.mips.coproc[0]->reg[COP0_WIRED]);
                                     reg[COP0_RANDOM] & RANDOM_MASK));  
                                 printf(" wired=0x%llx", (long long)  
                                     m->cpus[i]->cd.mips.coproc[0]->  
                                     reg[COP0_WIRED]);  
                         }  
540    
541                          printf(")\n");                          printf(")\n");
542    
543                          for (j=0; j<m->cpus[i]->cd.mips.cpu_type.                          for (j=0; j<m->cpus[i]->cd.mips.cpu_type.
544                              nr_of_tlb_entries; j++) {                              nr_of_tlb_entries; j++) {
545                                  uint64_t hi,lo0,lo1,mask;                                  if (m->cpus[i]->cd.mips.cpu_type.mmu_model ==
546                                  hi = m->cpus[i]->cd.mips.coproc[0]->tlbs[j].hi;                                      MMU3K)
547                                  lo0 = m->cpus[i]->cd.mips.coproc[0]->tlbs[j].lo0;                                          printf("%3i: hi=0x%08x lo=0x%08x\n", j,
548                                  lo1 = m->cpus[i]->cd.mips.coproc[0]->tlbs[j].lo1;                                              (int)m->cpus[i]->cd.mips.coproc[0]->tlbs[j].hi,
549                                  mask = m->cpus[i]->cd.mips.coproc[0]->tlbs[j].mask;                                              (int)m->cpus[i]->cd.mips.coproc[0]->tlbs[j].lo0);
550                                    else if (m->cpus[i]->is_32bit)
551                                  printf("%3i: ", j);                                          printf("%3i: hi=0x%08x mask=0x%08x "
552                                  switch (m->cpus[i]->cd.mips.cpu_type.mmu_model) {                                              "lo0=0x%08x lo1=0x%08x\n", j,
553                                  case MMU3K:                                              (int)m->cpus[i]->cd.mips.coproc[0]->tlbs[j].hi,
554                                          if (!(lo0 & R2K3K_ENTRYLO_V)) {                                              (int)m->cpus[i]->cd.mips.coproc[0]->tlbs[j].mask,
555                                                  printf("(invalid)\n");                                              (int)m->cpus[i]->cd.mips.coproc[0]->tlbs[j].lo0,
556                                                  continue;                                              (int)m->cpus[i]->cd.mips.coproc[0]->tlbs[j].lo1);
557                                          }                                  else
558                                          printf("vaddr=0x%08x ",                                          printf("%3i: hi=0x%016"PRIx64" mask=0x%016"PRIx64" "
559                                              (int) (hi&R2K3K_ENTRYHI_VPN_MASK));                                              "lo0=0x%016"PRIx64" lo1=0x%016"PRIx64"\n", j,
560                                          if (lo0 & R2K3K_ENTRYLO_G)                                              (uint64_t)m->cpus[i]->cd.mips.coproc[0]->tlbs[j].hi,
561                                                  printf("(global), ");                                              (uint64_t)m->cpus[i]->cd.mips.coproc[0]->tlbs[j].mask,
562                                          else                                              (uint64_t)m->cpus[i]->cd.mips.coproc[0]->tlbs[j].lo0,
563                                                  printf("(asid %02x),",                                              (uint64_t)m->cpus[i]->cd.mips.coproc[0]->tlbs[j].lo1);
                                                     (int) ((hi & R2K3K_ENTRYHI_ASID_MASK)  
                                                     >> R2K3K_ENTRYHI_ASID_SHIFT));  
                                         printf(" paddr=0x%08x ",  
                                             (int) (lo0&R2K3K_ENTRYLO_PFN_MASK));  
                                         if (lo0 & R2K3K_ENTRYLO_N)  
                                                 printf("N");  
                                         if (lo0 & R2K3K_ENTRYLO_D)  
                                                 printf("D");  
                                         printf("\n");  
                                         break;  
                                 default:  
                                         switch (m->cpus[i]->cd.mips.cpu_type.mmu_model) {  
                                         case MMU10K:  
                                                 printf("vaddr=0x%1x..%011llx ",  
                                                     (int) (hi >> 60),  
                                                     (long long) (hi&ENTRYHI_VPN2_MASK_R10K));  
                                                 break;  
                                         case MMU32:  
                                                 printf("vaddr=0x%08x ", (int)(hi&ENTRYHI_VPN2_MASK));  
                                                 break;  
                                         default:/*  R4000 etc.  */  
                                                 printf("vaddr=0x%1x..%010llx ",  
                                                     (int) (hi >> 60),  
                                                     (long long) (hi&ENTRYHI_VPN2_MASK));  
                                         }  
                                         if (hi & TLB_G)  
                                                 printf("(global): ");  
                                         else  
                                                 printf("(asid %02x):",  
                                                     (int) (hi & ENTRYHI_ASID));  
   
                                         /*  TODO: Coherency bits  */  
   
                                         if (!(lo0 & ENTRYLO_V))  
                                                 printf(" p0=(invalid)   ");  
                                         else  
                                                 printf(" p0=0x%09llx ", (long long)  
                                                     (((lo0&ENTRYLO_PFN_MASK) >> ENTRYLO_PFN_SHIFT) << pageshift));  
                                         printf(lo0 & ENTRYLO_D? "D" : " ");  
   
                                         if (!(lo1 & ENTRYLO_V))  
                                                 printf(" p1=(invalid)   ");  
                                         else  
                                                 printf(" p1=0x%09llx ", (long long)  
                                                     (((lo1&ENTRYLO_PFN_MASK) >> ENTRYLO_PFN_SHIFT) << pageshift));  
                                         printf(lo1 & ENTRYLO_D? "D" : " ");  
                                         mask |= (1 << (pageshift+1)) - 1;  
                                         switch (mask) {  
                                         case 0x7ff:     printf(" (1KB)"); break;  
                                         case 0x1fff:    printf(" (4KB)"); break;  
                                         case 0x7fff:    printf(" (16KB)"); break;  
                                         case 0x1ffff:   printf(" (64KB)"); break;  
                                         case 0x7ffff:   printf(" (256KB)"); break;  
                                         case 0x1fffff:  printf(" (1MB)"); break;  
                                         case 0x7fffff:  printf(" (4MB)"); break;  
                                         case 0x1ffffff: printf(" (16MB)"); break;  
                                         case 0x7ffffff: printf(" (64MB)"); break;  
                                         default:  
                                                 printf(" (mask=%08x?)", (int)mask);  
                                         }  
                                         printf("\n");  
                                 }  
564                          }                          }
565                  }                  }
   
566                  return;                  return;
567          }          }
568    
569          /*  Raw output:  */          /*  Nicely formatted output:  */
570          for (i=0; i<m->ncpus; i++) {          for (i=0; i<m->ncpus; i++) {
571                    int pageshift = 12;
572    
573                  if (x >= 0 && i != x)                  if (x >= 0 && i != x)
574                          continue;                          continue;
575    
576                    if (m->cpus[i]->cd.mips.cpu_type.rev == MIPS_R4100)
577                            pageshift = 10;
578    
579                  /*  Print index, random, and wired:  */                  /*  Print index, random, and wired:  */
580                  printf("cpu%i: (", i);                  printf("cpu%i: (", i);
581                    switch (m->cpus[i]->cd.mips.cpu_type.isa_level) {
582                  if (m->cpus[i]->is_32bit)                  case 1:
583                          printf("index=0x%08x random=0x%08x",                  case 2: printf("index=0x%x random=0x%x",
584                              (int)m->cpus[i]->cd.mips.coproc[0]->reg[COP0_INDEX],                              (int) ((m->cpus[i]->cd.mips.coproc[0]->
585                              (int)m->cpus[i]->cd.mips.coproc[0]->reg[COP0_RANDOM]);                              reg[COP0_INDEX] & R2K3K_INDEX_MASK)
586                  else                              >> R2K3K_INDEX_SHIFT),
587                          printf("index=0x%016llx random=0x%016llx", (long long)                              (int) ((m->cpus[i]->cd.mips.coproc[0]->
588                              m->cpus[i]->cd.mips.coproc[0]->reg[COP0_INDEX],                              reg[COP0_RANDOM] & R2K3K_RANDOM_MASK)
589                              (long long)m->cpus[i]->cd.mips.coproc[0]->reg                              >> R2K3K_RANDOM_SHIFT));
590                              [COP0_RANDOM]);                          break;
591                    default:printf("index=0x%x random=0x%x",
592                  if (m->cpus[i]->cd.mips.cpu_type.isa_level >= 3)                              (int) (m->cpus[i]->cd.mips.coproc[0]->
593                          printf(" wired=0x%llx", (long long)                              reg[COP0_INDEX] & INDEX_MASK),
594                                (int) (m->cpus[i]->cd.mips.coproc[0]->
595                                reg[COP0_RANDOM] & RANDOM_MASK));
596                            printf(" wired=0x%"PRIx64, (uint64_t)
597                              m->cpus[i]->cd.mips.coproc[0]->reg[COP0_WIRED]);                              m->cpus[i]->cd.mips.coproc[0]->reg[COP0_WIRED]);
   
                 printf(")\n");  
   
                 for (j=0; j<m->cpus[i]->cd.mips.cpu_type.nr_of_tlb_entries; j++) {  
                         if (m->cpus[i]->cd.mips.cpu_type.mmu_model == MMU3K)  
                                 printf("%3i: hi=0x%08x lo=0x%08x\n",  
                                     j,  
                                     (int)m->cpus[i]->cd.mips.coproc[0]->tlbs[j].hi,  
                                     (int)m->cpus[i]->cd.mips.coproc[0]->tlbs[j].lo0);  
                         else if (m->cpus[i]->is_32bit)  
                                 printf("%3i: hi=0x%08x mask=0x%08x "  
                                     "lo0=0x%08x lo1=0x%08x\n", j,  
                                     (int)m->cpus[i]->cd.mips.coproc[0]->tlbs[j].hi,  
                                     (int)m->cpus[i]->cd.mips.coproc[0]->tlbs[j].mask,  
                                     (int)m->cpus[i]->cd.mips.coproc[0]->tlbs[j].lo0,  
                                     (int)m->cpus[i]->cd.mips.coproc[0]->tlbs[j].lo1);  
                         else  
                                 printf("%3i: hi=0x%016llx mask=0x%016llx "  
                                     "lo0=0x%016llx lo1=0x%016llx\n", j,  
                                     (long long)m->cpus[i]->cd.mips.coproc[0]->tlbs[j].hi,  
                                     (long long)m->cpus[i]->cd.mips.coproc[0]->tlbs[j].mask,  
                                     (long long)m->cpus[i]->cd.mips.coproc[0]->tlbs[j].lo0,  
                                     (long long)m->cpus[i]->cd.mips.coproc[0]->tlbs[j].lo1);  
598                  }                  }
         }  
 }  
   
599    
600  /*                  printf(")\n");
  *  mips_cpu_register_match():  
  */  
 void mips_cpu_register_match(struct machine *m, char *name,  
         int writeflag, uint64_t *valuep, int *match_register)  
 {  
         int cpunr = 0;  
601    
602          /*  CPU number:  */                  for (j=0; j<m->cpus[i]->cd.mips.cpu_type.
603                        nr_of_tlb_entries; j++) {
604                            uint64_t hi,lo0,lo1,mask;
605                            hi = m->cpus[i]->cd.mips.coproc[0]->tlbs[j].hi;
606                            lo0 = m->cpus[i]->cd.mips.coproc[0]->tlbs[j].lo0;
607                            lo1 = m->cpus[i]->cd.mips.coproc[0]->tlbs[j].lo1;
608                            mask = m->cpus[i]->cd.mips.coproc[0]->tlbs[j].mask;
609    
610                            printf("%3i: ", j);
611                            switch (m->cpus[i]->cd.mips.cpu_type.mmu_model) {
612                            case MMU3K:
613                                    if (!(lo0 & R2K3K_ENTRYLO_V)) {
614                                            printf("(invalid)\n");
615                                            continue;
616                                    }
617                                    printf("vaddr=0x%08x ",
618                                        (int) (hi&R2K3K_ENTRYHI_VPN_MASK));
619                                    if (lo0 & R2K3K_ENTRYLO_G)
620                                            printf("(global), ");
621                                    else
622                                            printf("(asid %02x),", (int) ((hi &
623                                                R2K3K_ENTRYHI_ASID_MASK)
624                                                >> R2K3K_ENTRYHI_ASID_SHIFT));
625                                    printf(" paddr=0x%08x ",
626                                        (int) (lo0&R2K3K_ENTRYLO_PFN_MASK));
627                                    if (lo0 & R2K3K_ENTRYLO_N)
628                                            printf("N");
629                                    if (lo0 & R2K3K_ENTRYLO_D)
630                                            printf("D");
631                                    printf("\n");
632                                    break;
633                            default:switch (m->cpus[i]->cd.mips.cpu_type.mmu_model){
634                                    case MMU32:
635                                            printf("vaddr=0x%08"PRIx32" ",
636                                                (uint32_t) hi);
637                                            break;
638                                    case MMU10K:
639                                    default:/*  R4000 etc.  */
640                                            printf("vaddr=%016"PRIx64" ",
641                                                (uint64_t) hi);
642                                    }
643                                    if (hi & TLB_G)
644                                            printf("(global): ");
645                                    else
646                                            printf("(asid %02x):",
647                                                (int) (hi & ENTRYHI_ASID));
648    
649          /*  TODO  */                                  /*  TODO: Coherency bits  */
650    
651          /*  Register name:  */                                  if (!(lo0 & ENTRYLO_V))
652          if (strcasecmp(name, "pc") == 0) {                                          printf(" p0=(invalid)   ");
                 if (writeflag) {  
                         m->cpus[cpunr]->pc = *valuep;  
                         if (m->cpus[cpunr]->cd.mips.delay_slot) {  
                                 printf("NOTE: Clearing the delay slot"  
                                     " flag! (It was set before.)\n");  
                                 m->cpus[cpunr]->cd.mips.delay_slot = 0;  
                         }  
                         if (m->cpus[cpunr]->cd.mips.nullify_next) {  
                                 printf("NOTE: Clearing the nullify-ne"  
                                     "xt flag! (It was set before.)\n");  
                                 m->cpus[cpunr]->cd.mips.nullify_next = 0;  
                         }  
                 } else  
                         *valuep = m->cpus[cpunr]->pc;  
                 *match_register = 1;  
         } else if (strcasecmp(name, "hi") == 0) {  
                 if (writeflag)  
                         m->cpus[cpunr]->cd.mips.hi = *valuep;  
                 else  
                         *valuep = m->cpus[cpunr]->cd.mips.hi;  
                 *match_register = 1;  
         } else if (strcasecmp(name, "lo") == 0) {  
                 if (writeflag)  
                         m->cpus[cpunr]->cd.mips.lo = *valuep;  
                 else  
                         *valuep = m->cpus[cpunr]->cd.mips.lo;  
                 *match_register = 1;  
         } else if (name[0] == 'r' && isdigit((int)name[1])) {  
                 int nr = atoi(name + 1);  
                 if (nr >= 0 && nr < N_MIPS_GPRS) {  
                         if (writeflag) {  
                                 if (nr != 0)  
                                         m->cpus[cpunr]->cd.mips.gpr[nr] = *valuep;  
653                                  else                                  else
654                                          printf("WARNING: Attempt to modify r0.\n");                                          printf(" p0=0x%09"PRIx64" ", (uint64_t)
655                          } else                                              (((lo0&ENTRYLO_PFN_MASK) >>
656                                  *valuep = m->cpus[cpunr]->cd.mips.gpr[nr];                                              ENTRYLO_PFN_SHIFT) << pageshift));
657                          *match_register = 1;                                  printf(lo0 & ENTRYLO_D? "D" : " ");
                 }  
         } else {  
                 /*  Check for a symbolic name such as "t6" or "at":  */  
                 int nr;  
                 for (nr=0; nr<N_MIPS_GPRS; nr++)  
                         if (strcmp(name, regnames[nr]) == 0) {  
                                 if (writeflag) {  
                                         if (nr != 0)  
                                                 m->cpus[cpunr]->cd.mips.gpr[nr] = *valuep;  
                                         else  
                                                 printf("WARNING: Attempt to modify r0.\n");  
                                 } else  
                                         *valuep = m->cpus[cpunr]->cd.mips.gpr[nr];  
                                 *match_register = 1;  
                         }  
         }  
658    
659          if (!(*match_register)) {                                  if (!(lo1 & ENTRYLO_V))
660                  /*  Check for a symbolic coproc0 name:  */                                          printf(" p1=(invalid)   ");
661                  int nr;                                  else
662                  for (nr=0; nr<32; nr++)                                          printf(" p1=0x%09"PRIx64" ", (uint64_t)
663                          if (strcmp(name, cop0_names[nr]) == 0) {                                              (((lo1&ENTRYLO_PFN_MASK) >>
664                                  if (writeflag) {                                              ENTRYLO_PFN_SHIFT) << pageshift));
665                                          coproc_register_write(m->cpus[cpunr],                                  printf(lo1 & ENTRYLO_D? "D" : " ");
666                                              m->cpus[cpunr]->cd.mips.coproc[0], nr,                                  mask |= (1 << (pageshift+1)) - 1;
667                                              valuep, 1, 0);                                  switch (mask) {
668                                  } else {                                  case 0x7ff:     printf(" (1KB)"); break;
669                                          /*  TODO: Use coproc_register_read instead?  */                                  case 0x1fff:    printf(" (4KB)"); break;
670                                          *valuep = m->cpus[cpunr]->cd.mips.coproc[0]->reg[nr];                                  case 0x7fff:    printf(" (16KB)"); break;
671                                    case 0x1ffff:   printf(" (64KB)"); break;
672                                    case 0x7ffff:   printf(" (256KB)"); break;
673                                    case 0x1fffff:  printf(" (1MB)"); break;
674                                    case 0x7fffff:  printf(" (4MB)"); break;
675                                    case 0x1ffffff: printf(" (16MB)"); break;
676                                    case 0x7ffffff: printf(" (64MB)"); break;
677                                    default:printf(" (mask=%08x?)", (int)mask);
678                                  }                                  }
679                                  *match_register = 1;                                  printf("\n");
680                          }                          }
681          }                  }
   
         /*  TODO: Coprocessor 1,2,3 registers.  */  
 }  
   
   
 /*  
  *  cpu_flags():  
  *  
  *  Returns a pointer to a string containing "(d)" "(j)" "(dj)" or "",  
  *  depending on the cpu's current delay_slot and last_was_jumptoself  
  *  flags.  
  */  
 static const char *cpu_flags(struct cpu *cpu)  
 {  
         if (cpu->cd.mips.delay_slot) {  
                 if (cpu->cd.mips.last_was_jumptoself)  
                         return " (dj)";  
                 else  
                         return " (d)";  
         } else {  
                 if (cpu->cd.mips.last_was_jumptoself)  
                         return " (j)";  
                 else  
                         return "";  
682          }          }
683  }  }
684    
# Line 721  static const char *cpu_flags(struct cpu Line 698  static const char *cpu_flags(struct cpu
698   *  NOTE 2:  coprocessor instructions are not decoded nicely yet  (TODO)   *  NOTE 2:  coprocessor instructions are not decoded nicely yet  (TODO)
699   */   */
700  int mips_cpu_disassemble_instr(struct cpu *cpu, unsigned char *originstr,  int mips_cpu_disassemble_instr(struct cpu *cpu, unsigned char *originstr,
701          int running, uint64_t dumpaddr, int bintrans)          int running, uint64_t dumpaddr)
702  {  {
703          int hi6, special6, regimm5;          int hi6, special6, regimm5, sub;
704          int rt, rd, rs, sa, imm, copz, cache_op, which_cache, showtag;          int rt, rd, rs, sa, imm, copz, cache_op, which_cache, showtag;
705          uint64_t addr, offset;          uint64_t addr, offset;
706          uint32_t instrword;          uint32_t instrword;
# Line 745  int mips_cpu_disassemble_instr(struct cp Line 722  int mips_cpu_disassemble_instr(struct cp
722                  debug("cpu%i: ", cpu->cpu_id);                  debug("cpu%i: ", cpu->cpu_id);
723    
724          if (cpu->is_32bit)          if (cpu->is_32bit)
725                  debug("%08x", (int)dumpaddr);                  debug("%08"PRIx32, (uint32_t)dumpaddr);
726          else          else
727                  debug("%016llx", (long long)dumpaddr);                  debug("%016"PRIx64, (uint64_t)dumpaddr);
728    
729          *((uint32_t *)&instr[0]) = *((uint32_t *)&originstr[0]);          *((uint32_t *)&instr[0]) = *((uint32_t *)&originstr[0]);
730    
# Line 765  int mips_cpu_disassemble_instr(struct cp Line 742  int mips_cpu_disassemble_instr(struct cp
742          debug(": %02x%02x%02x%02x",          debug(": %02x%02x%02x%02x",
743              instr[3], instr[2], instr[1], instr[0]);              instr[3], instr[2], instr[1], instr[0]);
744    
745          if (running)          if (running && cpu->delay_slot)
746                  debug("%s", cpu_flags(cpu));                  debug(" (d)");
747    
748          debug("\t");          debug("\t");
749    
         if (bintrans && running) {  
                 debug("(bintrans)");  
                 goto disasm_ret;  
         }  
   
750          /*          /*
751           *  Decode the instruction:           *  Decode the instruction:
752           */           */
753    
         if (cpu->cd.mips.nullify_next && running) {  
                 debug("(nullified)");  
                 goto disasm_ret;  
         }  
   
754          hi6 = (instr[3] >> 2) & 0x3f;          hi6 = (instr[3] >> 2) & 0x3f;
755    
756          switch (hi6) {          switch (hi6) {
# Line 799  int mips_cpu_disassemble_instr(struct cp Line 766  int mips_cpu_disassemble_instr(struct cp
766                  case SPECIAL_DSLL32:                  case SPECIAL_DSLL32:
767                  case SPECIAL_DSRL32:                  case SPECIAL_DSRL32:
768                  case SPECIAL_DSRA32:                  case SPECIAL_DSRA32:
769                            sub = ((instr[3] & 3) << 3) + ((instr[2] >> 5) & 7);
770                          rt = instr[2] & 31;                          rt = instr[2] & 31;
771                          rd = (instr[1] >> 3) & 31;                          rd = (instr[1] >> 3) & 31;
772                          sa = ((instr[1] & 7) << 2) + ((instr[0] >> 6) & 3);                          sa = ((instr[1] & 7) << 2) + ((instr[0] >> 6) & 3);
# Line 808  int mips_cpu_disassemble_instr(struct cp Line 776  int mips_cpu_disassemble_instr(struct cp
776                                          debug("nop");                                          debug("nop");
777                                  else if (sa == 1)                                  else if (sa == 1)
778                                          debug("ssnop");                                          debug("ssnop");
779                                    else if (sa == 3)
780                                            debug("ehb");
781                                  else                                  else
782                                          debug("nop (weird, sa=%i)", sa);                                          debug("nop (weird, sa=%i)", sa);
783                                  goto disasm_ret;                                  break;
784                          } else                          }
785    
786                            switch (sub) {
787                            case 0x00:
788                                  debug("%s\t%s,",                                  debug("%s\t%s,",
789                                      special_names[special6],                                      special_names[special6],
790                                      regname(cpu->machine, rd));                                      regname(cpu->machine, rd));
791                                  debug("%s,%i", regname(cpu->machine, rt), sa);                                  debug("%s,%i", regname(cpu->machine, rt), sa);
792                                    break;
793                            case 0x01:
794                                    debug("%s\t%s,",
795                                        special_rot_names[special6],
796                                        regname(cpu->machine, rd));
797                                    debug("%s,%i", regname(cpu->machine, rt), sa);
798                                    break;
799                            default:debug("UNIMPLEMENTED special, sub=0x%02x\n",
800                                        sub);
801                            }
802                          break;                          break;
803                  case SPECIAL_DSRLV:                  case SPECIAL_DSRLV:
804                  case SPECIAL_DSRAV:                  case SPECIAL_DSRAV:
# Line 826  int mips_cpu_disassemble_instr(struct cp Line 809  int mips_cpu_disassemble_instr(struct cp
809                          rs = ((instr[3] & 3) << 3) + ((instr[2] >> 5) & 7);                          rs = ((instr[3] & 3) << 3) + ((instr[2] >> 5) & 7);
810                          rt = instr[2] & 31;                          rt = instr[2] & 31;
811                          rd = (instr[1] >> 3) & 31;                          rd = (instr[1] >> 3) & 31;
812                          debug("%s\t%s",                          sub = ((instr[1] & 7) << 2) + ((instr[0] >> 6) & 3);
813                              special_names[special6], regname(cpu->machine, rd));  
814                          debug(",%s", regname(cpu->machine, rt));                          switch (sub) {
815                          debug(",%s", regname(cpu->machine, rs));                          case 0x00:
816                                    debug("%s\t%s", special_names[special6],
817                                        regname(cpu->machine, rd));
818                                    debug(",%s", regname(cpu->machine, rt));
819                                    debug(",%s", regname(cpu->machine, rs));
820                                    break;
821                            case 0x01:
822                                    debug("%s\t%s", special_rot_names[special6],
823                                        regname(cpu->machine, rd));
824                                    debug(",%s", regname(cpu->machine, rt));
825                                    debug(",%s", regname(cpu->machine, rs));
826                                    break;
827                            default:debug("UNIMPLEMENTED special, sub=0x%02x\n",
828                                        sub);
829                            }
830                          break;                          break;
831                  case SPECIAL_JR:                  case SPECIAL_JR:
832                          rs = ((instr[3] & 3) << 3) + ((instr[2] >> 5) & 7);                          rs = ((instr[3] & 3) << 3) + ((instr[2] >> 5) & 7);
833                          symbol = get_symbol_name(&cpu->machine->symbol_context,                          symbol = get_symbol_name(&cpu->machine->symbol_context,
834                              cpu->cd.mips.gpr[rs], &offset);                              cpu->cd.mips.gpr[rs], &offset);
835                          debug("jr\t%s", regname(cpu->machine, rs));                          /*  .hb = hazard barrier hint on MIPS32/64 rev 2  */
836                            debug("jr%s\t%s",
837                                (instr[1] & 0x04) ? ".hb" : "",
838                                regname(cpu->machine, rs));
839                          if (running && symbol != NULL)                          if (running && symbol != NULL)
840                                  debug("\t<%s>", symbol);                                  debug("\t<%s>", symbol);
841                          break;                          break;
# Line 844  int mips_cpu_disassemble_instr(struct cp Line 844  int mips_cpu_disassemble_instr(struct cp
844                          rd = (instr[1] >> 3) & 31;                          rd = (instr[1] >> 3) & 31;
845                          symbol = get_symbol_name(&cpu->machine->symbol_context,                          symbol = get_symbol_name(&cpu->machine->symbol_context,
846                              cpu->cd.mips.gpr[rs], &offset);                              cpu->cd.mips.gpr[rs], &offset);
847                          debug("jalr\t%s", regname(cpu->machine, rd));                          /*  .hb = hazard barrier hint on MIPS32/64 rev 2  */
848                            debug("jalr%s\t%s",
849                                (instr[1] & 0x04) ? ".hb" : "",
850                                regname(cpu->machine, rd));
851                          debug(",%s", regname(cpu->machine, rs));                          debug(",%s", regname(cpu->machine, rs));
852                          if (running && symbol != NULL)                          if (running && symbol != NULL)
853                                  debug("\t<%s>", symbol);                                  debug("\t<%s>", symbol);
# Line 880  int mips_cpu_disassemble_instr(struct cp Line 883  int mips_cpu_disassemble_instr(struct cp
883                          rs = ((instr[3] & 3) << 3) + ((instr[2] >> 5) & 7);                          rs = ((instr[3] & 3) << 3) + ((instr[2] >> 5) & 7);
884                          rt = instr[2] & 31;                          rt = instr[2] & 31;
885                          rd = (instr[1] >> 3) & 31;                          rd = (instr[1] >> 3) & 31;
886                          if ((special6 == SPECIAL_ADDU ||                          if (cpu->is_32bit && (special6 == SPECIAL_ADDU ||
887                              special6 == SPECIAL_DADDU ||                              special6 == SPECIAL_SUBU) && rt == 0) {
888                              special6 == SPECIAL_SUBU ||                                  /*  Special case 1: addu/subu with
                             special6 == SPECIAL_DSUBU) && rt == 0) {  
                                 /*  Special case 1: addu/daddu/subu/dsubu with  
889                                      rt = the zero register ==> move  */                                      rt = the zero register ==> move  */
890                                  debug("move\t%s", regname(cpu->machine, rd));                                  debug("move\t%s", regname(cpu->machine, rd));
891                                  debug(",%s", regname(cpu->machine, rs));                                  debug(",%s", regname(cpu->machine, rs));
892                          } else if ((special6 == SPECIAL_ADDU ||                          } else if (special6 == SPECIAL_ADDU && cpu->is_32bit
893                              special6 == SPECIAL_DADDU) && rs == 0) {                              && rs == 0) {
894                                  /*  Special case 2: addu/daddu with                                  /*  Special case 2: addu with
895                                      rs = the zero register ==> move  */                                      rs = the zero register ==> move  */
896                                  debug("move\t%s", regname(cpu->machine, rd));                                  debug("move\t%s", regname(cpu->machine, rd));
897                                  debug(",%s", regname(cpu->machine, rt));                                  debug(",%s", regname(cpu->machine, rt));
# Line 918  int mips_cpu_disassemble_instr(struct cp Line 919  int mips_cpu_disassemble_instr(struct cp
919                          rs = ((instr[3] & 3) << 3) + ((instr[2] >> 5) & 7);                          rs = ((instr[3] & 3) << 3) + ((instr[2] >> 5) & 7);
920                          rt = instr[2] & 31;                          rt = instr[2] & 31;
921                          rd = (instr[1] >> 3) & 31;                          rd = (instr[1] >> 3) & 31;
922                          if (special6 == SPECIAL_MULT) {                          debug("%s\t", special_names[special6]);
923                                  if (rd != 0) {                          if (rd != 0) {
924                                          debug("mult_xx\t%s",                                  if (cpu->cd.mips.cpu_type.rev == MIPS_R5900) {
925                                              regname(cpu->machine, rd));                                          if (special6 == SPECIAL_MULT ||
926                                          debug(",%s", regname(cpu->machine, rs));                                              special6 == SPECIAL_MULTU)
927                                          debug(",%s", regname(cpu->machine, rt));                                                  debug("%s,",
928                                          goto disasm_ret;                                                      regname(cpu->machine, rd));
929                                            else
930                                                    debug("WEIRD_R5900_RD,");
931                                    } else {
932                                            debug("WEIRD_RD_NONZERO,");
933                                  }                                  }
934                          }                          }
935                          debug("%s\t%s", special_names[special6],                          debug("%s", regname(cpu->machine, rs));
                             regname(cpu->machine, rs));  
936                          debug(",%s", regname(cpu->machine, rt));                          debug(",%s", regname(cpu->machine, rt));
937                          break;                          break;
938                  case SPECIAL_SYNC:                  case SPECIAL_SYNC:
# Line 952  int mips_cpu_disassemble_instr(struct cp Line 956  int mips_cpu_disassemble_instr(struct cp
956                                  debug("break");                                  debug("break");
957                          break;                          break;
958                  case SPECIAL_MFSA:                  case SPECIAL_MFSA:
959                          rd = (instr[1] >> 3) & 31;                          if (cpu->cd.mips.cpu_type.rev == MIPS_R5900) {
960                          debug("mfsa\t%s", regname(cpu->machine, rd));                                  rd = (instr[1] >> 3) & 31;
961                                    debug("mfsa\t%s", regname(cpu->machine, rd));
962                            } else {
963                                    debug("unimplemented special 0x28");
964                            }
965                          break;                          break;
966                  case SPECIAL_MTSA:                  case SPECIAL_MTSA:
967                          rs = ((instr[3] & 3) << 3) + ((instr[2] >> 5) & 7);                          if (cpu->cd.mips.cpu_type.rev == MIPS_R5900) {
968                          debug("mtsa\t%s", regname(cpu->machine, rs));                                  rs = ((instr[3] & 3) << 3) +
969                                        ((instr[2] >> 5) & 7);
970                                    debug("mtsa\t%s", regname(cpu->machine, rs));
971                            } else {
972                                    debug("unimplemented special 0x29");
973                            }
974                          break;                          break;
975                  default:                  default:
976                          debug("unimplemented special6 = 0x%02x", special6);                          debug("%s\t= UNIMPLEMENTED", special_names[special6]);
977                  }                  }
978                  break;                  break;
979          case HI6_BEQ:          case HI6_BEQ:
# Line 977  int mips_cpu_disassemble_instr(struct cp Line 990  int mips_cpu_disassemble_instr(struct cp
990                  if (imm >= 32768)                  if (imm >= 32768)
991                          imm -= 65536;                          imm -= 65536;
992                  addr = (dumpaddr + 4) + (imm << 2);                  addr = (dumpaddr + 4) + (imm << 2);
                 debug("%s\t", hi6_names[hi6]);  
993    
994                  switch (hi6) {                  if (hi6 == HI6_BEQ && rt == MIPS_GPR_ZERO &&
995                  case HI6_BEQ:                      rs == MIPS_GPR_ZERO)
996                  case HI6_BEQL:                          debug("b\t");
997                  case HI6_BNE:                  else {
998                  case HI6_BNEL:                          debug("%s\t", hi6_names[hi6]);
999                          debug("%s,", regname(cpu->machine, rt));                          switch (hi6) {
1000                            case HI6_BEQ:
1001                            case HI6_BEQL:
1002                            case HI6_BNE:
1003                            case HI6_BNEL:
1004                                    debug("%s,", regname(cpu->machine, rt));
1005                            }
1006                            debug("%s,", regname(cpu->machine, rs));
1007                  }                  }
1008    
                 debug("%s,", regname(cpu->machine, rs));  
   
1009                  if (cpu->is_32bit)                  if (cpu->is_32bit)
1010                          debug("0x%08x", (int)addr);                          debug("0x%08"PRIx32, (uint32_t)addr);
1011                  else                  else
1012                          debug("0x%016llx", (long long)addr);                          debug("0x%016"PRIx64, (uint64_t)addr);
1013    
1014                  symbol = get_symbol_name(&cpu->machine->symbol_context,                  symbol = get_symbol_name(&cpu->machine->symbol_context,
1015                      addr, &offset);                      addr, &offset);
# Line 1044  int mips_cpu_disassemble_instr(struct cp Line 1061  int mips_cpu_disassemble_instr(struct cp
1061          case HI6_SH:          case HI6_SH:
1062          case HI6_SW:          case HI6_SW:
1063          case HI6_SD:          case HI6_SD:
1064          case HI6_SQ:          case HI6_SQ_SPECIAL3:
1065          case HI6_SC:          case HI6_SC:
1066          case HI6_SCD:          case HI6_SCD:
1067          case HI6_SWC1:          case HI6_SWC1:
# Line 1060  int mips_cpu_disassemble_instr(struct cp Line 1077  int mips_cpu_disassemble_instr(struct cp
1077          case HI6_SWR:          case HI6_SWR:
1078          case HI6_SDL:          case HI6_SDL:
1079          case HI6_SDR:          case HI6_SDR:
1080                    if (hi6 == HI6_LQ_MDMX &&
1081                        cpu->cd.mips.cpu_type.rev != MIPS_R5900) {
1082                            debug("mdmx\t(UNIMPLEMENTED)");
1083                            break;
1084                    }
1085                    if (hi6 == HI6_SQ_SPECIAL3 &&
1086                        cpu->cd.mips.cpu_type.rev != MIPS_R5900) {
1087                            int msbd, lsb, sub10;
1088                            special6 = instr[0] & 0x3f;
1089                            rs = ((instr[3] & 3) << 3) + ((instr[2] >> 5) & 7);
1090                            rt = instr[2] & 31;
1091                            rd = msbd = (instr[1] >> 3) & 31;
1092                            lsb = ((instr[1] & 7) << 2) | (instr[0] >> 6);
1093                            sub10 = (rs << 5) | lsb;
1094    
1095                            switch (special6) {
1096    
1097                            case SPECIAL3_EXT:
1098                            case SPECIAL3_DEXT:
1099                            case SPECIAL3_DEXTM:
1100                            case SPECIAL3_DEXTU:
1101                                    debug("%s", special3_names[special6]);
1102                                    if (special6 == SPECIAL3_DEXTM)
1103                                            msbd += 32;
1104                                    if (special6 == SPECIAL3_DEXTU)
1105                                            lsb += 32;
1106                                    debug("\t%s", regname(cpu->machine, rt));
1107                                    debug(",%s", regname(cpu->machine, rs));
1108                                    debug(",%i,%i", lsb, msbd + 1);
1109                                    break;
1110    
1111                            case SPECIAL3_INS:
1112                            case SPECIAL3_DINS:
1113                            case SPECIAL3_DINSM:
1114                            case SPECIAL3_DINSU:
1115                                    debug("%s", special3_names[special6]);
1116                                    if (special6 == SPECIAL3_DINSM)
1117                                            msbd += 32;
1118                                    if (special6 == SPECIAL3_DINSU) {
1119                                            lsb += 32;
1120                                            msbd += 32;
1121                                    }
1122                                    msbd -= lsb;
1123                                    debug("\t%s", regname(cpu->machine, rt));
1124                                    debug(",%s", regname(cpu->machine, rs));
1125                                    debug(",%i,%i", lsb, msbd + 1);
1126                                    break;
1127    
1128                            case SPECIAL3_BSHFL:
1129                                    switch (sub10) {
1130                                    case BSHFL_WSBH:
1131                                    case BSHFL_SEB:
1132                                    case BSHFL_SEH:
1133                                            switch (sub10) {
1134                                            case BSHFL_WSBH: debug("wsbh"); break;
1135                                            case BSHFL_SEB:  debug("seb"); break;
1136                                            case BSHFL_SEH:  debug("seh"); break;
1137                                            }
1138                                            debug("\t%s", regname(cpu->machine,rd));
1139                                            debug(",%s", regname(cpu->machine,rt));
1140                                            break;
1141                                    default:debug("%s", special3_names[special6]);
1142                                            debug("\t(UNIMPLEMENTED)");
1143                                    }
1144                                    break;
1145    
1146                            case SPECIAL3_DBSHFL:
1147                                    switch (sub10) {
1148                                    case BSHFL_DSBH:
1149                                    case BSHFL_DSHD:
1150                                            switch (sub10) {
1151                                            case BSHFL_DSBH: debug("dsbh"); break;
1152                                            case BSHFL_DSHD: debug("dshd"); break;
1153                                            }
1154                                            debug("\t%s", regname(cpu->machine,rd));
1155                                            debug(",%s", regname(cpu->machine,rt));
1156                                            break;
1157                                    default:debug("%s", special3_names[special6]);
1158                                            debug("\t(UNIMPLEMENTED)");
1159                                    }
1160                                    break;
1161    
1162                            case SPECIAL3_RDHWR:
1163                                    debug("%s", special3_names[special6]);
1164                                    debug("\t%s", regname(cpu->machine, rt));
1165                                    debug(",hwr%i", rd);
1166                                    break;
1167    
1168                            default:debug("%s", special3_names[special6]);
1169                                    debug("\t(UNIMPLEMENTED)");
1170                            }
1171                            break;
1172                    }
1173    
1174                  rs = ((instr[3] & 3) << 3) + ((instr[2] >> 5) & 7);                  rs = ((instr[3] & 3) << 3) + ((instr[2] >> 5) & 7);
1175                  rt = instr[2] & 31;                  rt = instr[2] & 31;
1176                  imm = (instr[1] << 8) + instr[0];                  imm = (instr[1] << 8) + instr[0];
# Line 1075  int mips_cpu_disassemble_instr(struct cp Line 1186  int mips_cpu_disassemble_instr(struct cp
1186                              rt, imm, regname(cpu->machine, rs));                              rt, imm, regname(cpu->machine, rs));
1187    
1188                          if (running) {                          if (running) {
1189                                  debug("\t[0x%016llx = %s]",                                  debug("\t[0x%016"PRIx64" = %s]",
1190                                      (long long)(cpu->cd.mips.gpr[rs] + imm));                                      (uint64_t)(cpu->cd.mips.gpr[rs] + imm));
1191                                  if (symbol != NULL)                                  if (symbol != NULL)
1192                                          debug(" = %s", symbol);                                          debug(" = %s", symbol);
1193                                  debug("]");                                  debug("]");
# Line 1100  int mips_cpu_disassemble_instr(struct cp Line 1211  int mips_cpu_disassemble_instr(struct cp
1211                          debug("\t[");                          debug("\t[");
1212    
1213                          if (cpu->is_32bit)                          if (cpu->is_32bit)
1214                                  debug("0x%08x", (int)(cpu->cd.mips.gpr[rs] + imm));                                  debug("0x%08"PRIx32,
1215                                        (uint32_t) (cpu->cd.mips.gpr[rs] + imm));
1216                          else                          else
1217                                  debug("0x%016llx",                                  debug("0x%016"PRIx64,
1218                                      (long long)(cpu->cd.mips.gpr[rs] + imm));                                      (uint64_t) (cpu->cd.mips.gpr[rs] + imm));
1219    
1220                          if (symbol != NULL)                          if (symbol != NULL)
1221                                  debug(" = %s", symbol);                                  debug(" = %s", symbol);
1222    
1223                          debug(", data=");                          /*  TODO: In some cases, it is possible to peek into
1224                  } else                              memory, and display that data here, like for the
1225                          break;                              other emulation modes.  */
1226                  /*  NOTE: No break here (if we are running) as it is up  
1227                      to the caller to print 'data'.  */                          debug("]");
1228                  return sizeof(instrword);                  }
1229                    break;
1230    
1231          case HI6_J:          case HI6_J:
1232          case HI6_JAL:          case HI6_JAL:
1233                  imm = (((instr[3] & 3) << 24) + (instr[2] << 16) +                  imm = (((instr[3] & 3) << 24) + (instr[2] << 16) +
# Line 1124  int mips_cpu_disassemble_instr(struct cp Line 1238  int mips_cpu_disassemble_instr(struct cp
1238                      addr, &offset);                      addr, &offset);
1239                  debug("%s\t0x", hi6_names[hi6]);                  debug("%s\t0x", hi6_names[hi6]);
1240                  if (cpu->is_32bit)                  if (cpu->is_32bit)
1241                          debug("%08x", (int)addr);                          debug("%08"PRIx32, (uint32_t) addr);
1242                  else                  else
1243                          debug("%016llx", (long long)addr);                          debug("%016"PRIx64, (uint64_t) addr);
1244                  if (symbol != NULL)                  if (symbol != NULL)
1245                          debug("\t<%s>", symbol);                          debug("\t<%s>", symbol);
1246                  break;                  break;
1247    
1248          case HI6_COP0:          case HI6_COP0:
1249          case HI6_COP1:          case HI6_COP1:
1250          case HI6_COP2:          case HI6_COP2:
# Line 1142  int mips_cpu_disassemble_instr(struct cp Line 1257  int mips_cpu_disassemble_instr(struct cp
1257                  coproc_function(cpu, cpu->cd.mips.coproc[hi6 - HI6_COP0],                  coproc_function(cpu, cpu->cd.mips.coproc[hi6 - HI6_COP0],
1258                      hi6 - HI6_COP0, imm, 1, running);                      hi6 - HI6_COP0, imm, 1, running);
1259                  return sizeof(instrword);                  return sizeof(instrword);
1260    
1261          case HI6_CACHE:          case HI6_CACHE:
1262                  rt   = ((instr[3] & 3) << 3) + (instr[2] >> 5); /*  base  */                  rt   = ((instr[3] & 3) << 3) + (instr[2] >> 5); /*  base  */
1263                  copz = instr[2] & 31;                  copz = instr[2] & 31;
# Line 1165  int mips_cpu_disassemble_instr(struct cp Line 1281  int mips_cpu_disassemble_instr(struct cp
1281                  if (cache_op==6)        debug("hit writeback");                  if (cache_op==6)        debug("hit writeback");
1282                  if (cache_op==7)        debug("hit set virtual");                  if (cache_op==7)        debug("hit set virtual");
1283                  if (running)                  if (running)
1284                          debug(", addr 0x%016llx",                          debug(", addr 0x%016"PRIx64,
1285                              (long long)(cpu->cd.mips.gpr[rt] + imm));                              (uint64_t)(cpu->cd.mips.gpr[rt] + imm));
1286                  if (showtag)                  if (showtag)
1287                  debug(", taghi=%08lx lo=%08lx",                  debug(", taghi=%08lx lo=%08lx",
1288                      (long)cpu->cd.mips.coproc[0]->reg[COP0_TAGDATA_HI],                      (long)cpu->cd.mips.coproc[0]->reg[COP0_TAGDATA_HI],
1289                      (long)cpu->cd.mips.coproc[0]->reg[COP0_TAGDATA_LO]);                      (long)cpu->cd.mips.coproc[0]->reg[COP0_TAGDATA_LO]);
1290                  debug(" ]");                  debug(" ]");
1291                  break;                  break;
1292    
1293          case HI6_SPECIAL2:          case HI6_SPECIAL2:
1294                  special6 = instr[0] & 0x3f;                  special6 = instr[0] & 0x3f;
1295                  instrword = (instr[3] << 24) + (instr[2] << 16) +                  instrword = (instr[3] << 24) + (instr[2] << 16) +
# Line 1180  int mips_cpu_disassemble_instr(struct cp Line 1297  int mips_cpu_disassemble_instr(struct cp
1297                  rs = ((instr[3] & 3) << 3) + ((instr[2] >> 5) & 7);                  rs = ((instr[3] & 3) << 3) + ((instr[2] >> 5) & 7);
1298                  rt = instr[2] & 31;                  rt = instr[2] & 31;
1299                  rd = (instr[1] >> 3) & 31;                  rd = (instr[1] >> 3) & 31;
1300                  if ((instrword & 0xfc0007ffULL) == 0x70000000) {  
1301                          debug("madd\t%s", regname(cpu->machine, rd));                  if (cpu->cd.mips.cpu_type.rev == MIPS_R5900) {
1302                          debug(",%s", regname(cpu->machine, rs));                          int c790mmifunc = (instrword >> 6) & 0x1f;
1303                          debug(",%s", regname(cpu->machine, rt));                          if (special6 != MMI_MMI0 && special6 != MMI_MMI1 &&
1304                  } else if (special6 == SPECIAL2_MUL) {                              special6 != MMI_MMI2 && special6 != MMI_MMI3)
1305                          /*  TODO: this is just a guess, I don't have the                                  debug("%s\t", mmi_names[special6]);
1306                                  docs in front of me  */  
1307                          debug("mul\t%s", regname(cpu->machine, rd));                          switch (special6) {
1308                          debug(",%s", regname(cpu->machine, rs));  
1309                          debug(",%s", regname(cpu->machine, rt));                          case MMI_MADD:
1310                  } else if (special6 == SPECIAL2_CLZ) {                          case MMI_MADDU:
1311                          debug("clz\t%s", regname(cpu->machine, rd));                                  if (rd != MIPS_GPR_ZERO) {
1312                          debug(",%s", regname(cpu->machine, rs));                                          debug("%s,", regname(cpu->machine, rd));
1313                  } else if (special6 == SPECIAL2_CLO) {                                  }
1314                          debug("clo\t%s", regname(cpu->machine, rd));                                  debug("%s", regname(cpu->machine, rs));
1315                          debug(",%s", regname(cpu->machine, rs));                                  debug(",%s", regname(cpu->machine, rt));
1316                  } else if (special6 == SPECIAL2_DCLZ) {                                  break;
1317                          debug("dclz\t%s", regname(cpu->machine, rd));  
1318                          debug(",%s", regname(cpu->machine, rs));                          case MMI_MMI0:
1319                  } else if (special6 == SPECIAL2_DCLO) {                                  debug("%s\t", mmi0_names[c790mmifunc]);
1320                          debug("dclo\t%s", regname(cpu->machine, rd));                                  switch (c790mmifunc) {
1321                          debug(",%s", regname(cpu->machine, rs));  
1322                  } else if ((instrword & 0xffff07ffULL) == 0x70000209                                  case MMI0_PEXTLB:
1323                      || (instrword & 0xffff07ffULL) == 0x70000249) {                                  case MMI0_PEXTLH:
1324                          if (instr[0] == 0x49) {                                  case MMI0_PEXTLW:
1325                                  debug("pmflo\t%s", regname(cpu->machine, rd));                                  case MMI0_PMAXH:
1326                                  debug("  (rs=%s)", regname(cpu->machine, rs));                                  case MMI0_PMAXW:
1327                          } else {                                  case MMI0_PPACB:
1328                                  debug("pmfhi\t%s", regname(cpu->machine, rd));                                  case MMI0_PPACH:
1329                                  debug("  (rs=%s)", regname(cpu->machine, rs));                                  case MMI0_PPACW:
1330                                            debug("%s", regname(cpu->machine, rd));
1331                                            debug(",%s", regname(cpu->machine, rs));
1332                                            debug(",%s", regname(cpu->machine, rt));
1333                                            break;
1334    
1335                                    default:debug("(UNIMPLEMENTED)");
1336                                    }
1337                                    break;
1338    
1339                            case MMI_MMI1:
1340                                    debug("%s\t", mmi1_names[c790mmifunc]);
1341                                    switch (c790mmifunc) {
1342    
1343                                    case MMI1_PEXTUB:
1344                                    case MMI1_PEXTUH:
1345                                    case MMI1_PEXTUW:
1346                                    case MMI1_PMINH:
1347                                    case MMI1_PMINW:
1348                                            debug("%s", regname(cpu->machine, rd));
1349                                            debug(",%s", regname(cpu->machine, rs));
1350                                            debug(",%s", regname(cpu->machine, rt));
1351                                            break;
1352    
1353                                    default:debug("(UNIMPLEMENTED)");
1354                                    }
1355                                    break;
1356    
1357                            case MMI_MMI2:
1358                                    debug("%s\t", mmi2_names[c790mmifunc]);
1359                                    switch (c790mmifunc) {
1360    
1361                                    case MMI2_PMFHI:
1362                                    case MMI2_PMFLO:
1363                                            debug("%s", regname(cpu->machine, rd));
1364                                            break;
1365    
1366                                    case MMI2_PHMADH:
1367                                    case MMI2_PHMSBH:
1368                                    case MMI2_PINTH:
1369                                    case MMI2_PMADDH:
1370                                    case MMI2_PMADDW:
1371                                    case MMI2_PMSUBH:
1372                                    case MMI2_PMSUBW:
1373                                    case MMI2_PMULTH:
1374                                    case MMI2_PMULTW:
1375                                    case MMI2_PSLLVW:
1376                                            debug("%s", regname(cpu->machine, rd));
1377                                            debug(",%s", regname(cpu->machine, rs));
1378                                            debug(",%s", regname(cpu->machine, rt));
1379                                            break;
1380    
1381                                    default:debug("(UNIMPLEMENTED)");
1382                                    }
1383                                    break;
1384    
1385                            case MMI_MMI3:
1386                                    debug("%s\t", mmi3_names[c790mmifunc]);
1387                                    switch (c790mmifunc) {
1388    
1389                                    case MMI3_PMTHI:
1390                                    case MMI3_PMTLO:
1391                                            debug("%s", regname(cpu->machine, rs));
1392                                            break;
1393    
1394                                    case MMI3_PINTEH:
1395                                    case MMI3_PMADDUW:
1396                                    case MMI3_PMULTUW:
1397                                    case MMI3_PNOR:
1398                                    case MMI3_POR:
1399                                    case MMI3_PSRAVW:
1400                                            debug("%s", regname(cpu->machine, rd));
1401                                            debug(",%s", regname(cpu->machine, rs));
1402                                            debug(",%s", regname(cpu->machine, rt));
1403                                            break;
1404    
1405                                    default:debug("(UNIMPLEMENTED)");
1406                                    }
1407                                    break;
1408    
1409                            default:debug("(UNIMPLEMENTED)");
1410                          }                          }
1411                  } else if ((instrword & 0xfc1fffff) == 0x70000269                          break;
1412                      || (instrword & 0xfc1fffff) == 0x70000229) {                  }
1413                          if (instr[0] == 0x69) {  
1414                                  debug("pmtlo\t%s", regname(cpu->machine, rs));                  /*  SPECIAL2:  */
1415                          } else {                  debug("%s\t", special2_names[special6]);
1416                                  debug("pmthi\t%s", regname(cpu->machine, rs));  
1417                          }                  switch (special6) {
1418                  } else if ((instrword & 0xfc0007ff) == 0x700004a9) {  
1419                          debug("por\t%s", regname(cpu->machine, rd));                  case SPECIAL2_MADD:
1420                          debug(",%s", regname(cpu->machine, rs));                  case SPECIAL2_MADDU:
1421                    case SPECIAL2_MSUB:
1422                    case SPECIAL2_MSUBU:
1423                            if (rd != MIPS_GPR_ZERO) {
1424                                    debug("WEIRD_NONZERO_RD(%s),",
1425                                        regname(cpu->machine, rd));
1426                            }
1427                            debug("%s", regname(cpu->machine, rs));
1428                          debug(",%s", regname(cpu->machine, rt));                          debug(",%s", regname(cpu->machine, rt));
1429                  } else if ((instrword & 0xfc0007ff) == 0x70000488) {                          break;
1430                          debug("pextlw\t%s", regname(cpu->machine, rd));  
1431                    case SPECIAL2_MUL:
1432                            /*  Apparently used both on R5900 and MIPS32:  */
1433                            debug("%s", regname(cpu->machine, rd));
1434                          debug(",%s", regname(cpu->machine, rs));                          debug(",%s", regname(cpu->machine, rs));
1435                          debug(",%s", regname(cpu->machine, rt));                          debug(",%s", regname(cpu->machine, rt));
1436                  } else {                          break;
1437                          debug("unimplemented special2 = 0x%02x", special6);  
1438                    case SPECIAL2_CLZ:
1439                    case SPECIAL2_CLO:
1440                    case SPECIAL2_DCLZ:
1441                    case SPECIAL2_DCLO:
1442                            debug("%s", regname(cpu->machine, rd));
1443                            debug(",%s", regname(cpu->machine, rs));
1444                            break;
1445    
1446                    default:
1447                            debug("(UNIMPLEMENTED)");
1448                  }                  }
1449                  break;                  break;
1450    
1451          case HI6_REGIMM:          case HI6_REGIMM:
1452                  regimm5 = instr[2] & 0x1f;                  regimm5 = instr[2] & 0x1f;
1453                    rs = ((instr[3] & 3) << 3) + ((instr[2] >> 5) & 7);
1454                    imm = (instr[1] << 8) + instr[0];
1455                    if (imm >= 32768)              
1456                            imm -= 65536;
1457    
1458                  switch (regimm5) {                  switch (regimm5) {
1459    
1460                  case REGIMM_BLTZ:                  case REGIMM_BLTZ:
1461                  case REGIMM_BGEZ:                  case REGIMM_BGEZ:
1462                  case REGIMM_BLTZL:                  case REGIMM_BLTZL:
# Line 1241  int mips_cpu_disassemble_instr(struct cp Line 1465  int mips_cpu_disassemble_instr(struct cp
1465                  case REGIMM_BLTZALL:                  case REGIMM_BLTZALL:
1466                  case REGIMM_BGEZAL:                  case REGIMM_BGEZAL:
1467                  case REGIMM_BGEZALL:                  case REGIMM_BGEZALL:
                         rs = ((instr[3] & 3) << 3) + ((instr[2] >> 5) & 7);  
                         imm = (instr[1] << 8) + instr[0];  
                         if (imm >= 32768)                
                                 imm -= 65536;  
   
1468                          debug("%s\t%s,", regimm_names[regimm5],                          debug("%s\t%s,", regimm_names[regimm5],
1469                              regname(cpu->machine, rs));                              regname(cpu->machine, rs));
1470    
1471                          addr = (dumpaddr + 4) + (imm << 2);                          addr = (dumpaddr + 4) + (imm << 2);
1472    
1473                          if (cpu->is_32bit)                          if (cpu->is_32bit)
1474                                  debug("0x%08x", (int)addr);                                  debug("0x%08"PRIx32, (uint32_t) addr);
1475                          else                          else
1476                                  debug("0x%016llx", (long long)addr);                                  debug("0x%016"PRIx64, (uint64_t) addr);
1477                            break;
1478    
1479                    case REGIMM_SYNCI:
1480                            debug("%s\t%i(%s)", regimm_names[regimm5],
1481                                imm, regname(cpu->machine, rs));
1482                          break;                          break;
1483    
1484                  default:                  default:
1485                          debug("unimplemented regimm5 = 0x%02x", regimm5);                          debug("unimplemented regimm5 = 0x%02x", regimm5);
1486                  }                  }
# Line 1283  void mips_cpu_register_dump(struct cpu * Line 1508  void mips_cpu_register_dump(struct cpu *
1508          int coprocnr, i, bits32;          int coprocnr, i, bits32;
1509          uint64_t offset;          uint64_t offset;
1510          char *symbol;          char *symbol;
1511            int bits128 = cpu->cd.mips.cpu_type.rev == MIPS_R5900;
1512    
1513          bits32 = cpu->is_32bit;          bits32 = cpu->is_32bit;
1514    
# Line 1292  void mips_cpu_register_dump(struct cpu * Line 1518  void mips_cpu_register_dump(struct cpu *
1518                      cpu->pc, &offset);                      cpu->pc, &offset);
1519    
1520                  if (bits32)                  if (bits32)
1521                          debug("cpu%i:  pc = %08x", cpu->cpu_id, (int)cpu->pc);                          debug("cpu%i:  pc = %08"PRIx32,
1522                                cpu->cpu_id, (uint32_t) cpu->pc);
1523                    else if (bits128)
1524                            debug("cpu%i:  pc=%016"PRIx64,
1525                                cpu->cpu_id, (uint64_t) cpu->pc);
1526                  else                  else
1527                          debug("cpu%i:    pc = 0x%016llx",                          debug("cpu%i:    pc = 0x%016"PRIx64,
1528                              cpu->cpu_id, (long long)cpu->pc);                              cpu->cpu_id, (uint64_t) cpu->pc);
1529    
1530                  debug("    <%s>\n", symbol != NULL? symbol :                  debug("    <%s>\n", symbol != NULL? symbol :
1531                      " no symbol ");                      " no symbol ");
1532    
1533                  if (bits32)                  if (bits32)
1534                          debug("cpu%i:  hi = %08x  lo = %08x\n",                          debug("cpu%i:  hi = %08"PRIx32"  lo = %08"PRIx32"\n",
1535                              cpu->cpu_id, (int)cpu->cd.mips.hi, (int)cpu->cd.mips.lo);                              cpu->cpu_id, (uint32_t) cpu->cd.mips.hi,
1536                  else                              (uint32_t) cpu->cd.mips.lo);
1537                          debug("cpu%i:    hi = 0x%016llx    lo = 0x%016llx\n",                  else if (bits128) {
1538                              cpu->cpu_id, (long long)cpu->cd.mips.hi,                          debug("cpu%i:  hi=%016"PRIx64"%016"PRIx64"  lo="
1539                              (long long)cpu->cd.mips.lo);                              "%016"PRIx64"%016"PRIx64"\n", cpu->cpu_id,
1540                                cpu->cd.mips.hi1, cpu->cd.mips.hi,
1541                                cpu->cd.mips.lo1, cpu->cd.mips.lo);
1542                    } else {
1543                            debug("cpu%i:    hi = 0x%016"PRIx64"    lo = 0x%016"
1544                                PRIx64"\n", cpu->cpu_id,
1545                                (uint64_t) cpu->cd.mips.hi,
1546                                (uint64_t) cpu->cd.mips.lo);
1547                    }
1548    
1549                  /*  General registers:  */                  /*  General registers:  */
1550                  if (cpu->cd.mips.cpu_type.rev == MIPS_R5900) {                  if (bits128) {
1551                          /*  128-bit:  */                          /*  128-bit:  */
1552                          for (i=0; i<32; i++) {                          for (i=0; i<32; i++) {
1553                                    int r = (i >> 1) + ((i & 1) << 4);
1554                                  if ((i & 1) == 0)                                  if ((i & 1) == 0)
1555                                          debug("cpu%i:", cpu->cpu_id);                                          debug("cpu%i:", cpu->cpu_id);
1556                                  debug(" %3s=%016llx%016llx",                                  if (r == MIPS_GPR_ZERO)
1557                                      regname(cpu->machine, i),                                          debug("                           "
1558                                      (long long)cpu->cd.mips.gpr_quadhi[i],                                              "          ");
1559                                      (long long)cpu->cd.mips.gpr[i]);                                  else
1560                                            debug(" %3s=%016"PRIx64"%016"PRIx64,
1561                                                regname(cpu->machine, r),
1562                                                (uint64_t)cpu->cd.mips.gpr_quadhi[r],
1563                                                (uint64_t)cpu->cd.mips.gpr[r]);
1564                                  if ((i & 1) == 1)                                  if ((i & 1) == 1)
1565                                          debug("\n");                                          debug("\n");
1566                          }                          }
# Line 1329  void mips_cpu_register_dump(struct cpu * Line 1572  void mips_cpu_register_dump(struct cpu *
1572                                  if (i == MIPS_GPR_ZERO)                                  if (i == MIPS_GPR_ZERO)
1573                                          debug("               ");                                          debug("               ");
1574                                  else                                  else
1575                                          debug(" %3s = %08x", regname(cpu->machine, i), (int)cpu->cd.mips.gpr[i]);                                          debug(" %3s = %08"PRIx32,
1576                                                regname(cpu->machine, i),
1577                                                (uint32_t)cpu->cd.mips.gpr[i]);
1578                                  if ((i & 3) == 3)                                  if ((i & 3) == 3)
1579                                          debug("\n");                                          debug("\n");
1580                          }                          }
# Line 1342  void mips_cpu_register_dump(struct cpu * Line 1587  void mips_cpu_register_dump(struct cpu *
1587                                  if (r == MIPS_GPR_ZERO)                                  if (r == MIPS_GPR_ZERO)
1588                                          debug("                           ");                                          debug("                           ");
1589                                  else                                  else
1590                                          debug("   %3s = 0x%016llx", regname(cpu->machine, r), (long long)cpu->cd.mips.gpr[r]);                                          debug("   %3s = 0x%016"PRIx64,
1591                                                regname(cpu->machine, r),
1592                                                (uint64_t)cpu->cd.mips.gpr[r]);
1593                                  if ((i & 1) == 1)                                  if ((i & 1) == 1)
1594                                          debug("\n");                                          debug("\n");
1595                          }                          }
# Line 1364  void mips_cpu_register_dump(struct cpu * Line 1611  void mips_cpu_register_dump(struct cpu *
1611                  }                  }
1612    
1613                  /*  Coprocessor registers:  */                  /*  Coprocessor registers:  */
                 /*  TODO: multiple selections per register?  */  
1614                  for (i=0; i<32; i++) {                  for (i=0; i<32; i++) {
1615                          /*  32-bit:  */                          /*  32-bit:  */
1616                          if ((i & nm1) == 0)                          if ((i & nm1) == 0)
# Line 1384  void mips_cpu_register_dump(struct cpu * Line 1630  void mips_cpu_register_dump(struct cpu *
1630                                      || i == COP0_RANDOM || i == COP0_WIRED))                                      || i == COP0_RANDOM || i == COP0_WIRED))
1631                                          debug(" =         0x%08x", (int)cpu->cd.mips.coproc[coprocnr]->reg[i]);                                          debug(" =         0x%08x", (int)cpu->cd.mips.coproc[coprocnr]->reg[i]);
1632                                  else                                  else
1633                                          debug(" = 0x%016llx", (long long)                                          debug(" = 0x%016"PRIx64, (uint64_t)
1634                                              cpu->cd.mips.coproc[coprocnr]->reg[i]);                                              cpu->cd.mips.coproc[coprocnr]->reg[i]);
1635                          }                          }
1636    
# Line 1401  void mips_cpu_register_dump(struct cpu * Line 1647  void mips_cpu_register_dump(struct cpu *
1647                          debug("cpu%i: ", cpu->cpu_id);                          debug("cpu%i: ", cpu->cpu_id);
1648                          debug("config_select1 = 0x");                          debug("config_select1 = 0x");
1649                          if (cpu->is_32bit)                          if (cpu->is_32bit)
1650                                  debug("%08x", (int)cpu->cd.mips.cop0_config_select1);                                  debug("%08"PRIx32, (uint32_t)cpu->cd.mips.cop0_config_select1);
1651                          else                          else
1652                                  debug("%016llx", (long long)cpu->cd.mips.cop0_config_select1);                                  debug("%016"PRIx64, (uint64_t)cpu->cd.mips.cop0_config_select1);
1653                          debug("\n");                          debug("\n");
1654                  }                  }
1655    
# Line 1411  void mips_cpu_register_dump(struct cpu * Line 1657  void mips_cpu_register_dump(struct cpu *
1657                  if (coprocnr == 1) {                  if (coprocnr == 1) {
1658                          for (i=0; i<32; i++)                          for (i=0; i<32; i++)
1659                                  switch (i) {                                  switch (i) {
1660                                  case 0: printf("cpu%i: fcr0  (fcir) = 0x%08x\n",                                  case MIPS_FPU_FCIR:
1661                                              cpu->cpu_id, (int)cpu->cd.mips.coproc[coprocnr]->fcr[i]);                                          printf("cpu%i: fcr0  (fcir) = 0x%08x\n",
1662                                                cpu->cpu_id, (int)cpu->cd.mips.
1663                                                coproc[coprocnr]->fcr[i]);
1664                                          break;                                          break;
1665                                  case 25:printf("cpu%i: fcr25 (fccr) = 0x%08x\n",                                  case MIPS_FPU_FCCR:
1666                                              cpu->cpu_id, (int)cpu->cd.mips.coproc[coprocnr]->fcr[i]);                                          printf("cpu%i: fcr25 (fccr) = 0x%08x\n",
1667                                                cpu->cpu_id, (int)cpu->cd.mips.
1668                                                coproc[coprocnr]->fcr[i]);
1669                                          break;                                          break;
1670                                  case 31:printf("cpu%i: fcr31 (fcsr) = 0x%08x\n",                                  case MIPS_FPU_FCSR:
1671                                              cpu->cpu_id, (int)cpu->cd.mips.coproc[coprocnr]->fcr[i]);                                          printf("cpu%i: fcr31 (fcsr) = 0x%08x\n",
1672                                                cpu->cpu_id, (int)cpu->cd.mips.
1673                                                coproc[coprocnr]->fcr[i]);
1674                                          break;                                          break;
1675                                  }                                  }
1676                  }                  }
1677          }          }
1678    
1679            if (cpu->cd.mips.rmw) {
1680                    printf("cpu%i: Read-Modify-Write in progress, address "
1681                        "0x%016"PRIx64"\n", cpu->cpu_id, cpu->cd.mips.rmw_addr);
1682            }
1683    }
1684    
1685    
1686    static void add_response_word(struct cpu *cpu, char *r, uint64_t value,
1687            size_t maxlen, int len)
1688    {
1689            char *format = (len == 4)? "%08"PRIx64 : "%016"PRIx64;
1690            if (len == 4)
1691                    value &= 0xffffffffULL;
1692            if (cpu->byte_order == EMUL_LITTLE_ENDIAN) {
1693                    if (len == 4) {
1694                            value = ((value & 0xff) << 24) +
1695                                    ((value & 0xff00) << 8) +
1696                                    ((value & 0xff0000) >> 8) +
1697                                    ((value & 0xff000000) >> 24);
1698                    } else {
1699                            value = ((value & 0xff) << 56) +
1700                                    ((value & 0xff00) << 40) +
1701                                    ((value & 0xff0000) << 24) +
1702                                    ((value & 0xff000000ULL) << 8) +
1703                                    ((value & 0xff00000000ULL) >> 8) +
1704                                    ((value & 0xff0000000000ULL) >> 24) +
1705                                    ((value & 0xff000000000000ULL) >> 40) +
1706                                    ((value & 0xff00000000000000ULL) >> 56);
1707                    }
1708            }
1709            snprintf(r + strlen(r), maxlen - strlen(r), format, (uint64_t)value);
1710  }  }
1711    
1712    
1713  #define DYNTRANS_FUNCTION_TRACE mips_cpu_functioncall_trace  /*
1714  #define DYNTRANS_MIPS   *  mips_cpu_gdb_stub():
1715  #define DYNTRANS_ARCH mips   *
1716  #include "cpu_dyntrans.c"   *  Execute a "remote GDB" command. Returns 1 on success, 0 on error.
1717  #undef DYNTRANS_MIPS   */
1718  #undef DYNTRANS_ARCH  char *mips_cpu_gdb_stub(struct cpu *cpu, char *cmd)
1719  #undef DYNTRANS_FUNCTION_TRACE  {
1720            if (strcmp(cmd, "g") == 0) {
1721                    /*  76 registers:  gprs, sr, lo, hi, badvaddr, cause, pc,
1722                        fprs, fsr, fir, fp.  */
1723                    int i;
1724                    char *r;
1725                    size_t wlen = cpu->is_32bit?
1726                        sizeof(uint32_t) : sizeof(uint64_t);
1727                    size_t len = 1 + 76 * wlen;
1728                    r = malloc(len);
1729                    if (r == NULL) {
1730                            fprintf(stderr, "out of memory\n");
1731                            exit(1);
1732                    }
1733                    r[0] = '\0';
1734                    for (i=0; i<32; i++)
1735                            add_response_word(cpu, r, cpu->cd.mips.gpr[i],
1736                                len, wlen);
1737                    add_response_word(cpu, r,
1738                        cpu->cd.mips.coproc[0]->reg[COP0_STATUS], len, wlen);
1739                    add_response_word(cpu, r, cpu->cd.mips.lo, len, wlen);
1740                    add_response_word(cpu, r, cpu->cd.mips.hi, len, wlen);
1741                    add_response_word(cpu, r,
1742                        cpu->cd.mips.coproc[0]->reg[COP0_BADVADDR], len, wlen);
1743                    add_response_word(cpu, r,
1744                        cpu->cd.mips.coproc[0]->reg[COP0_CAUSE], len, wlen);
1745                    add_response_word(cpu, r, cpu->pc, len, wlen);
1746                    for (i=0; i<32; i++)
1747                            add_response_word(cpu, r,
1748                                cpu->cd.mips.coproc[1]->reg[i], len, wlen);
1749                    add_response_word(cpu, r,
1750                        cpu->cd.mips.coproc[1]->reg[31] /* fcsr */, len, wlen);
1751                    add_response_word(cpu, r,
1752                        cpu->cd.mips.coproc[1]->reg[0] /* fcir */, len, wlen);
1753    
1754                    /*  TODO: fp = gpr 30?  */
1755                    add_response_word(cpu, r, cpu->cd.mips.gpr[30], len, wlen);
1756    
1757                    return r;
1758            }
1759    
1760            if (cmd[0] == 'p') {
1761                    int regnr = strtol(cmd + 1, NULL, 16);
1762                    size_t wlen = cpu->is_32bit? sizeof(uint32_t):sizeof(uint64_t);
1763                    size_t len = 2 * wlen + 1;
1764                    char *r = malloc(len);
1765                    r[0] = '\0';
1766                    if (regnr >= 0 && regnr <= 31) {
1767                            add_response_word(cpu, r,
1768                                cpu->cd.mips.gpr[regnr], len, wlen);
1769                    } else if (regnr == 0x20) {
1770                            add_response_word(cpu, r, cpu->cd.mips.coproc[0]->
1771                                reg[COP0_STATUS], len, wlen);
1772                    } else if (regnr == 0x21) {
1773                            add_response_word(cpu, r, cpu->cd.mips.lo, len, wlen);
1774                    } else if (regnr == 0x22) {
1775                            add_response_word(cpu, r, cpu->cd.mips.hi, len, wlen);
1776                    } else if (regnr == 0x23) {
1777                            add_response_word(cpu, r, cpu->cd.mips.coproc[0]->
1778                                reg[COP0_BADVADDR], len, wlen);
1779                    } else if (regnr == 0x24) {
1780                            add_response_word(cpu, r, cpu->cd.mips.coproc[0]->
1781                                reg[COP0_CAUSE], len, wlen);
1782                    } else if (regnr == 0x25) {
1783                            add_response_word(cpu, r, cpu->pc, len, wlen);
1784                    } else if (regnr >= 0x26 && regnr <= 0x45 &&
1785                        cpu->cd.mips.coproc[1] != NULL) {
1786                            add_response_word(cpu, r, cpu->cd.mips.coproc[1]->
1787                                reg[regnr - 0x26], len, wlen);
1788                    } else if (regnr == 0x46) {
1789                            add_response_word(cpu, r, cpu->cd.mips.coproc[1]->
1790                                fcr[MIPS_FPU_FCSR], len, wlen);
1791                    } else if (regnr == 0x47) {
1792                            add_response_word(cpu, r, cpu->cd.mips.coproc[1]->
1793                                fcr[MIPS_FPU_FCIR], len, wlen);
1794                    } else {
1795                            /*  Unimplemented:  */
1796                            add_response_word(cpu, r, 0xcc000 + regnr, len, wlen);
1797                    }
1798                    return r;
1799            }
1800    
1801            fatal("mips_cpu_gdb_stub(): cmd='%s' TODO\n", cmd);
1802            return NULL;
1803    }
1804    
1805    
1806  /*  /*
# Line 1447  int mips_cpu_interrupt(struct cpu *cpu, Line 1815  int mips_cpu_interrupt(struct cpu *cpu,
1815  {  {
1816          if (irq_nr >= 8) {          if (irq_nr >= 8) {
1817                  if (cpu->machine->md_interrupt != NULL)                  if (cpu->machine->md_interrupt != NULL)
1818                          cpu->machine->md_interrupt(cpu->machine, cpu, irq_nr, 1);                          cpu->machine->md_interrupt(cpu->machine,
1819                                cpu, irq_nr, 1);
1820                  else                  else
1821                          fatal("mips_cpu_interrupt(): irq_nr = %i, but md_interrupt = NULL ?\n", irq_nr);                          fatal("mips_cpu_interrupt(): irq_nr = %i, "
1822                                "but md_interrupt = NULL ?\n", irq_nr);
1823                  return 1;                  return 1;
1824          }          }
1825    
1826          if (irq_nr < 2)          if (irq_nr < 2)
1827                  return 0;                  return 0;
1828    
1829          cpu->cd.mips.coproc[0]->reg[COP0_CAUSE] |= ((1 << irq_nr) << STATUS_IM_SHIFT);          cpu->cd.mips.coproc[0]->reg[COP0_CAUSE] |=
1830          cpu->cd.mips.cached_interrupt_is_possible = 1;              ((1 << irq_nr) << STATUS_IM_SHIFT);
1831    
1832          return 1;          return 1;
1833  }  }
1834    
# Line 1475  int mips_cpu_interrupt_ack(struct cpu *c Line 1846  int mips_cpu_interrupt_ack(struct cpu *c
1846  {  {
1847          if (irq_nr >= 8) {          if (irq_nr >= 8) {
1848                  if (cpu->machine->md_interrupt != NULL)                  if (cpu->machine->md_interrupt != NULL)
1849                          cpu->machine->md_interrupt(cpu->machine, cpu, irq_nr, 0);                          cpu->machine->md_interrupt(cpu->machine, cpu,
1850                                irq_nr, 0);
1851                  else                  else
1852                          fatal("mips_cpu_interrupt_ack(): irq_nr = %i, but md_interrupt = NULL ?\n", irq_nr);                          fatal("mips_cpu_interrupt_ack(): irq_nr = %i, "
1853                                "but md_interrupt = NULL ?\n", irq_nr);
1854                  return 1;                  return 1;
1855          }          }
1856    
1857          if (irq_nr < 2)          if (irq_nr < 2)
1858                  return 0;                  return 0;
1859    
1860          cpu->cd.mips.coproc[0]->reg[COP0_CAUSE] &= ~((1 << irq_nr) << STATUS_IM_SHIFT);          cpu->cd.mips.coproc[0]->reg[COP0_CAUSE] &=
1861          if (!(cpu->cd.mips.coproc[0]->reg[COP0_CAUSE] & STATUS_IM_MASK))              ~((1 << irq_nr) << STATUS_IM_SHIFT);
                 cpu->cd.mips.cached_interrupt_is_possible = 0;  
1862    
1863          return 1;          return 1;
1864  }  }
# Line 1514  void mips_cpu_exception(struct cpu *cpu, Line 1886  void mips_cpu_exception(struct cpu *cpu,
1886          uint64_t *reg = &cpu->cd.mips.coproc[0]->reg[0];          uint64_t *reg = &cpu->cd.mips.coproc[0]->reg[0];
1887          int exc_model = cpu->cd.mips.cpu_type.exc_model;          int exc_model = cpu->cd.mips.cpu_type.exc_model;
1888    
1889            if (cpu->is_halted) {
1890                    /*
1891                     *  If the exception occurred on a 'wait' instruction, then let
1892                     *  the instruction following the wait instruction be the one
1893                     *  we continue at when the interrupt service routine returns.
1894                     */
1895                    cpu->is_halted = 0;
1896                    cpu->pc += sizeof(uint32_t);
1897            }
1898    
1899          if (!quiet_mode) {          if (!quiet_mode) {
1900                  uint64_t offset;                  uint64_t offset;
1901                  int x;                  int x;
1902                  char *symbol = get_symbol_name(&cpu->machine->symbol_context,                  char *symbol = get_symbol_name(&cpu->machine->symbol_context,
1903                      cpu->cd.mips.pc_last, &offset);                      cpu->pc, &offset);
1904    
1905                  debug("[ ");                  debug("[ ");
1906                  if (cpu->machine->ncpus > 1)                  if (cpu->machine->ncpus > 1)
# Line 1528  void mips_cpu_exception(struct cpu *cpu, Line 1910  void mips_cpu_exception(struct cpu *cpu,
1910                      exception_names[exccode], tlb? " <tlb>" : "");                      exception_names[exccode], tlb? " <tlb>" : "");
1911    
1912                  switch (exccode) {                  switch (exccode) {
1913    
1914                  case EXCEPTION_INT:                  case EXCEPTION_INT:
1915                          debug(" cause_im=0x%02x", (int)((reg[COP0_CAUSE] & CAUSE_IP_MASK) >> CAUSE_IP_SHIFT));                          debug(" cause_im=0x%02x", (int)((reg[COP0_CAUSE] & CAUSE_IP_MASK) >> CAUSE_IP_SHIFT));
1916                          break;                          break;
1917    
1918                  case EXCEPTION_SYS:                  case EXCEPTION_SYS:
1919                          debug(" v0=%i", (int)cpu->cd.mips.gpr[MIPS_GPR_V0]);                          debug(" v0=%i", (int)cpu->cd.mips.gpr[MIPS_GPR_V0]);
1920                          for (x=0; x<4; x++) {                          for (x=0; x<4; x++) {
1921                                  int64_t d = cpu->cd.mips.gpr[MIPS_GPR_A0 + x];                                  int64_t d = cpu->cd.mips.gpr[MIPS_GPR_A0 + x];
1922                                  char strbuf[30];                                  char strbuf[30];
1923    
1924                                  if (d > -256 && d < 256)                                  if (d > -256 && d < 256) {
1925                                          debug(" a%i=%i", x, (int)d);                                          debug(" a%i=%i", x, (int)d);
1926                                  else if (memory_points_to_string(cpu, cpu->mem, d, 1))                                  } else if (memory_points_to_string(cpu,
1927                                          debug(" a%i=\"%s\"", x, memory_conv_to_string(cpu, cpu->mem, d, strbuf, sizeof(strbuf)));                                      cpu->mem, d, 1)) {
1928                                  else                                          debug(" a%i=\"%s\"", x,
1929                                          debug(" a%i=0x%llx", x, (long long)d);                                              memory_conv_to_string(cpu, cpu->mem,
1930                                                d, strbuf, sizeof(strbuf)));
1931                                    } else {
1932                                            if (cpu->is_32bit)
1933                                                    debug(" a%i=0x%"PRIx32, x,
1934                                                        (uint32_t)d);
1935                                            else
1936                                                    debug(" a%i=0x%"PRIx64, x,
1937                                                        (uint64_t)d);
1938                                    }
1939                          }                          }
1940                          break;                          break;
1941    
1942                    case EXCEPTION_CPU:
1943                            debug(" coproc_nr=%i", coproc_nr);
1944                            break;
1945    
1946                  default:                  default:
1947                          if (cpu->is_32bit)                          if (cpu->is_32bit)
1948                                  debug(" vaddr=0x%08x", (int)vaddr);                                  debug(" vaddr=0x%08x", (int)vaddr);
1949                          else                          else
1950                                  debug(" vaddr=0x%016llx", (long long)vaddr);                                  debug(" vaddr=0x%016"PRIx64, (uint64_t)vaddr);
1951                  }                  }
1952    
1953                  if (cpu->is_32bit)                  if (cpu->is_32bit)
1954                          debug(" pc=0x%08x ", (int)cpu->cd.mips.pc_last);                          debug(" pc=0x%08"PRIx32" ", (uint32_t)cpu->pc);
1955                  else                  else
1956                          debug(" pc=0x%016llx ", (long long)cpu->cd.mips.pc_last);                          debug(" pc=0x%016"PRIx64" ", (uint64_t)cpu->pc);
1957    
1958                  if (symbol != NULL)                  if (symbol != NULL)
1959                          debug("<%s> ]\n", symbol);                          debug("<%s> ]\n", symbol);
# Line 1566  void mips_cpu_exception(struct cpu *cpu, Line 1964  void mips_cpu_exception(struct cpu *cpu,
1964          if (tlb && vaddr < 0x1000) {          if (tlb && vaddr < 0x1000) {
1965                  uint64_t offset;                  uint64_t offset;
1966                  char *symbol = get_symbol_name(&cpu->machine->symbol_context,                  char *symbol = get_symbol_name(&cpu->machine->symbol_context,
1967                      cpu->cd.mips.pc_last, &offset);                      cpu->pc, &offset);
1968                  fatal("[ ");                  fatal("[ ");
1969                  if (cpu->machine->ncpus > 1)                  if (cpu->machine->ncpus > 1)
1970                          fatal("cpu%i: ", cpu->cpu_id);                          fatal("cpu%i: ", cpu->cpu_id);
1971                  fatal("warning: LOW reference: vaddr=");                  fatal("warning: LOW reference: vaddr=");
1972                  if (cpu->is_32bit)                  if (cpu->is_32bit)
1973                          fatal("0x%08x", (int)vaddr);                          fatal("0x%08"PRIx32, (uint32_t) vaddr);
1974                  else                  else
1975                          fatal("0x%016llx", (long long)vaddr);                          fatal("0x%016"PRIx64, (uint64_t) vaddr);
1976                  fatal(", exception %s, pc=", exception_names[exccode]);                  fatal(", exception %s, pc=", exception_names[exccode]);
1977                  if (cpu->is_32bit)                  if (cpu->is_32bit)
1978                          fatal("0x%08x", (int)cpu->cd.mips.pc_last);                          fatal("0x%08"PRIx32, (uint32_t) cpu->pc);
1979                  else                  else
1980                          fatal("0x%016llx", (long long)cpu->cd.mips.pc_last);                          fatal("0x%016"PRIx64, (uint64_t)cpu->pc);
1981                  fatal(" <%s> ]\n", symbol? symbol : "(no symbol)");                  fatal(" <%s> ]\n", symbol? symbol : "(no symbol)");
   
 #ifdef TRACE_NULL_CRASHES  
                 /*  This can be useful for debugging kernel bugs:  */  
                 {  
                         int i = cpu->trace_null_index;  
                         do {  
                                 fatal("TRACE: 0x%016llx\n",  
                                     cpu->trace_null_addr[i]);  
                                 i ++;  
                                 i %= TRACE_NULL_N_ENTRIES;  
                         } while (i != cpu->trace_null_index);  
                 }  
                 cpu->running = 0;  
                 cpu->dead = 1;  
 #endif  
1982          }          }
1983    
1984          /*  Clear the exception code bits of the cause register...  */          /*  Clear the exception code bits of the cause register...  */
# Line 1614  void mips_cpu_exception(struct cpu *cpu, Line 1997  void mips_cpu_exception(struct cpu *cpu,
1997          if (tlb || (exccode >= EXCEPTION_MOD && exccode <= EXCEPTION_ADES) ||          if (tlb || (exccode >= EXCEPTION_MOD && exccode <= EXCEPTION_ADES) ||
1998              exccode == EXCEPTION_VCEI || exccode == EXCEPTION_VCED) {              exccode == EXCEPTION_VCEI || exccode == EXCEPTION_VCED) {
1999                  reg[COP0_BADVADDR] = vaddr;                  reg[COP0_BADVADDR] = vaddr;
2000  #if 1                  if (cpu->is_32bit)
2001  /*  TODO: This should be removed.  */                          reg[COP0_BADVADDR] = (int32_t)reg[COP0_BADVADDR];
2002                  /*  sign-extend vaddr, if it is 32-bit  */  
                 if ((vaddr >> 32) == 0 && (vaddr & 0x80000000ULL))  
                         reg[COP0_BADVADDR] |=  
                             0xffffffff00000000ULL;  
 #endif  
2003                  if (exc_model == EXC3K) {                  if (exc_model == EXC3K) {
2004                          reg[COP0_CONTEXT] &= ~R2K3K_CONTEXT_BADVPN_MASK;                          reg[COP0_CONTEXT] &= ~R2K3K_CONTEXT_BADVPN_MASK;
2005                          reg[COP0_CONTEXT] |= ((vaddr_vpn2 << R2K3K_CONTEXT_BADVPN_SHIFT) & R2K3K_CONTEXT_BADVPN_MASK);                          reg[COP0_CONTEXT] |= ((vaddr_vpn2 << R2K3K_CONTEXT_BADVPN_SHIFT) & R2K3K_CONTEXT_BADVPN_MASK);
# Line 1664  void mips_cpu_exception(struct cpu *cpu, Line 2043  void mips_cpu_exception(struct cpu *cpu,
2043                  }                  }
2044          }          }
2045    
2046          if (exc_model == EXC4K && reg[COP0_STATUS] & STATUS_EXL) {          if (exc_model != EXC3K && reg[COP0_STATUS] & STATUS_EXL) {
2047                  /*                  /*
2048                   *  Don't set EPC if STATUS_EXL is set, for R4000 and up.                   *  Don't set EPC if STATUS_EXL is set, for R4000 and up.
2049                   *  This actually happens when running IRIX and Ultrix, when                   *  This actually happens when running IRIX and Ultrix, when
2050                   *  they handle interrupts and/or tlb updates, I think, so                   *  they handle interrupts and/or tlb updates, I think, so
2051                   *  printing this with debug() looks better than with fatal().                   *  printing this with debug() looks better than with fatal().
2052                   */                   */
2053                  /*  debug("[ warning: cpu%i exception while EXL is set, not setting EPC ]\n", cpu->cpu_id);  */                  /*  debug("[ warning: cpu%i exception while EXL is set,"
2054                        " not setting EPC ]\n", cpu->cpu_id);  */
2055          } else {          } else {
2056                  if (cpu->cd.mips.delay_slot || cpu->cd.mips.nullify_next) {                  if (cpu->delay_slot) {
2057                          reg[COP0_EPC] = cpu->cd.mips.pc_last - 4;                          reg[COP0_EPC] = cpu->pc - 4;
2058                          reg[COP0_CAUSE] |= CAUSE_BD;                          reg[COP0_CAUSE] |= CAUSE_BD;
   
                         /*  TODO: Should the BD flag actually be set  
                             on nullified slots?  */  
2059                  } else {                  } else {
2060                          reg[COP0_EPC] = cpu->cd.mips.pc_last;                          reg[COP0_EPC] = cpu->pc;
2061                          reg[COP0_CAUSE] &= ~CAUSE_BD;                          reg[COP0_CAUSE] &= ~CAUSE_BD;
2062                  }                  }
2063          }          }
2064    
2065          cpu->cd.mips.delay_slot = NOT_DELAYED;          if (cpu->delay_slot)
2066          cpu->cd.mips.nullify_next = 0;                  cpu->delay_slot = EXCEPTION_IN_DELAY_SLOT;
2067            else
2068                    cpu->delay_slot = NOT_DELAYED;
2069    
2070          /*  TODO: This is true for MIPS64, but how about others?  */          /*  TODO: This is true for MIPS64, but how about others?  */
2071          if (reg[COP0_STATUS] & STATUS_BEV)          if (reg[COP0_STATUS] & STATUS_BEV)
# Line 1731  void mips_cpu_exception(struct cpu *cpu, Line 2110  void mips_cpu_exception(struct cpu *cpu,
2110          }          }
2111    
2112          if (exc_model == EXC3K) {          if (exc_model == EXC3K) {
2113                  /*  R2000/R3000:  Shift the lowest 6 bits to the left two steps:  */                  /*  R{2,3}000:  Shift the lowest 6 bits to the left two steps:*/
2114                  reg[COP0_STATUS] =                  reg[COP0_STATUS] = (reg[COP0_STATUS] & ~0x3f) +
                     (reg[COP0_STATUS] & ~0x3f) +  
2115                      ((reg[COP0_STATUS] & 0xf) << 2);                      ((reg[COP0_STATUS] & 0xf) << 2);
2116          } else {          } else {
2117                  /*  R4000:  */                  /*  R4000:  */
# Line 1743  void mips_cpu_exception(struct cpu *cpu, Line 2121  void mips_cpu_exception(struct cpu *cpu,
2121          /*  Sign-extend:  */          /*  Sign-extend:  */
2122          reg[COP0_CAUSE] = (int64_t)(int32_t)reg[COP0_CAUSE];          reg[COP0_CAUSE] = (int64_t)(int32_t)reg[COP0_CAUSE];
2123          reg[COP0_STATUS] = (int64_t)(int32_t)reg[COP0_STATUS];          reg[COP0_STATUS] = (int64_t)(int32_t)reg[COP0_STATUS];
 }  
   
   
 #ifdef BINTRANS  
 /*  
  *  mips_cpu_cause_simple_exception():  
  *  
  *  Useful for causing raw exceptions from bintrans, for example  
  *  SYSCALL or BREAK.  
  */  
 void mips_cpu_cause_simple_exception(struct cpu *cpu, int exc_code)  
 {  
         mips_cpu_exception(cpu, exc_code, 0, 0, 0, 0, 0, 0);  
 }  
 #endif  
   
2124    
 /*  Included here for better cache characteristics:  */  
 #include "memory_mips.c"  
   
   
 /*  
  *  mips_cpu_run_instr():  
  *  
  *  Execute one instruction on a cpu.  
  *  
  *  If we are in a delay slot, set cpu->pc to cpu->cd.mips.delay_jmpaddr  
  *  after the instruction is executed.  
  *  
  *  Return value is the number of instructions executed during this call,  
  *  0 if no instruction was executed.  
  */  
 int mips_cpu_run_instr(struct emul *emul, struct cpu *cpu)  
 {  
         int quiet_mode_cached = quiet_mode;  
         int instruction_trace_cached = cpu->machine->instruction_trace;  
         struct mips_coproc *cp0 = cpu->cd.mips.coproc[0];  
         int i, tmp, ninstrs_executed;  
         unsigned char instr[4];  
         uint32_t instrword;  
         uint64_t cached_pc;  
         int hi6, special6, regimm5, rd, rs, rt, sa, imm;  
         int copz, which_cache, cache_op;  
   
         int cond, likely, and_link;  
   
         /*  for unaligned load/store  */  
         uint64_t dir, is_left, reg_ofs, reg_dir;  
   
         uint64_t tmpvalue, tmpaddr;  
   
         int cpnr;                       /*  coprocessor nr  */  
   
         /*  for load/store  */  
         uint64_t addr, value, value_hi, result_value;  
         int wlen, st, signd, linked;  
         unsigned char d[16];            /*  room for at most 128 bits  */  
   
   
         /*  
          *  Update Coprocessor 0 registers:  
          *  
          *  The COUNT register needs to be updated on every [other] instruction.  
          *  The RANDOM register should decrease for every instruction.  
          */  
   
         if (cpu->cd.mips.cpu_type.exc_model == EXC3K) {  
                 int r = (cp0->reg[COP0_RANDOM] & R2K3K_RANDOM_MASK) >> R2K3K_RANDOM_SHIFT;  
                 r --;  
                 if (r >= cp0->nr_of_tlbs || r < 8)  
                         r = cp0->nr_of_tlbs-1;  
                 cp0->reg[COP0_RANDOM] = r << R2K3K_RANDOM_SHIFT;  
         } else {  
                 cp0->reg[COP0_RANDOM] --;  
                 if ((int64_t)cp0->reg[COP0_RANDOM] >= cp0->nr_of_tlbs ||  
                     (int64_t)cp0->reg[COP0_RANDOM] < (int64_t) cp0->reg[COP0_WIRED])  
                         cp0->reg[COP0_RANDOM] = cp0->nr_of_tlbs-1;  
   
                 /*  
                  *  TODO: only increase count every other instruction,  
                  *  according to the R4000 manual. But according to the  
                  *  R5000 manual: increment every other clock cycle.  
                  *  Which one is it? :-)  
                  */  
                 cp0->reg[COP0_COUNT] = (int64_t)(int32_t)(cp0->reg[COP0_COUNT] + 1);  
   
                 if (cpu->cd.mips.compare_register_set &&  
                     cp0->reg[COP0_COUNT] == cp0->reg[COP0_COMPARE]) {  
                         mips_cpu_interrupt(cpu, 7);  
                         cpu->cd.mips.compare_register_set = 0;  
                 }  
         }  
   
   
 #ifdef ENABLE_INSTRUCTION_DELAYS  
         if (cpu->cd.mips.instruction_delay > 0) {  
                 cpu->cd.mips.instruction_delay --;  
                 return 1;  
         }  
 #endif  
   
         /*  Cache the program counter in a local variable:  */  
         cached_pc = cpu->pc;  
   
 #ifdef TRACE_NULL_CRASHES  
         cpu->trace_null_addr[cpu->trace_null_index] = cached_pc;  
         cpu->trace_null_index ++;  
         cpu->trace_null_index %= TRACE_NULL_N_ENTRIES;  
 #endif  
   
         /*  Hardwire the zero register to 0:  */  
         cpu->cd.mips.gpr[MIPS_GPR_ZERO] = 0;  
   
         if (cpu->cd.mips.delay_slot) {  
                 if (cpu->cd.mips.delay_slot == DELAYED) {  
                         cached_pc = cpu->pc = cpu->cd.mips.delay_jmpaddr;  
                         cpu->cd.mips.delay_slot = NOT_DELAYED;  
                 } else /* if (cpu->cd.mips.delay_slot == TO_BE_DELAYED) */ {  
                         /*  next instruction will be delayed  */  
                         cpu->cd.mips.delay_slot = DELAYED;  
                 }  
         }  
   
         if (cpu->cd.mips.last_was_jumptoself > 0)  
                 cpu->cd.mips.last_was_jumptoself --;  
   
         /*  Check PC against breakpoints:  */  
         if (!single_step)  
                 for (i=0; i<cpu->machine->n_breakpoints; i++)  
                         if (cached_pc == cpu->machine->breakpoint_addr[i]) {  
                                 fatal("Breakpoint reached, pc=0x");  
                                 if (cpu->is_32bit)  
                                         fatal("%08x", (int)cached_pc);  
                                 else  
                                         fatal("%016llx", (long long)cached_pc);  
                                 fatal("\n");  
                                 single_step = 1;  
                                 return 0;  
                         }  
   
   
         /*  Remember where we are, in case of interrupt or exception:  */  
         cpu->cd.mips.pc_last = cached_pc;  
   
         /*  
          *  Any pending interrupts?  
          *  
          *  If interrupts are enabled, and any interrupt has arrived (ie its  
          *  bit in the cause register is set) and corresponding enable bits  
          *  in the status register are set, then cause an interrupt exception  
          *  instead of executing the current instruction.  
          *  
          *  NOTE: cached_interrupt_is_possible is set to 1 whenever an  
          *  interrupt bit in the cause register is set to one (in  
          *  mips_cpu_interrupt()) and set to 0 whenever all interrupt bits are  
          *  cleared (in mips_cpu_interrupt_ack()), so we don't need to do a  
          *  full check each time.  
          */  
         if (cpu->cd.mips.cached_interrupt_is_possible && !cpu->cd.mips.nullify_next) {  
                 if (cpu->cd.mips.cpu_type.exc_model == EXC3K) {  
                         /*  R3000:  */  
                         int enabled, mask;  
                         int status = cp0->reg[COP0_STATUS];  
   
                         enabled = status & MIPS_SR_INT_IE;  
                         mask  = status & cp0->reg[COP0_CAUSE] & STATUS_IM_MASK;  
                         if (enabled && mask) {  
                                 mips_cpu_exception(cpu, EXCEPTION_INT, 0, 0, 0, 0, 0, 0);  
                                 return 0;  
                         }  
                 } else {  
                         /*  R4000 and others:  */  
                         int enabled, mask;  
                         int status = cp0->reg[COP0_STATUS];  
   
                         enabled = (status & STATUS_IE)  
                             && !(status & STATUS_EXL)  
                             && !(status & STATUS_ERL);  
   
                         mask = status & cp0->reg[COP0_CAUSE] & STATUS_IM_MASK;  
                         if (enabled && mask) {  
                                 mips_cpu_exception(cpu, EXCEPTION_INT, 0, 0, 0, 0, 0, 0);  
                                 return 0;  
                         }  
                 }  
         }  
   
   
         /*  
          *  ROM emulation:  (0xbfcXXXXX or 0x9fcXXXXX)  
          *  
          *  This assumes that a jal was made to a ROM address,  
          *  and we should return via gpr ra.  
          */  
         if ((cached_pc & 0xdff00000) == 0x9fc00000 &&  
             cpu->machine->prom_emulation) {  
                 int rom_jal = 1, res = 1;  
                 switch (cpu->machine->machine_type) {  
                 case MACHINE_DEC:  
                         res = decstation_prom_emul(cpu);  
                         break;  
                 case MACHINE_PS2:  
                         res = playstation2_sifbios_emul(cpu);  
                         break;  
                 case MACHINE_ARC:  
                 case MACHINE_SGI:  
                         res = arcbios_emul(cpu);  
                         break;  
                 case MACHINE_EVBMIPS:  
                         res = yamon_emul(cpu);  
                         break;  
                 default:  
                         rom_jal = 0;  
                 }  
   
                 if (rom_jal) {  
                         /*  
                          *  Special hack:  If the PROM emulation layer needs  
                          *  to loop (for example when emulating blocking  
                          *  console input) then we should simply return, so  
                          *  that the same PROM routine is called on the next  
                          *  round as well.  
                          *  
                          *  This still has to count as one or more  
                          *  instructions, so 1000 is returned. (Ugly.)  
                          */  
                         if (!res)  
                                 return 1000;  
   
                         cpu->pc = cpu->cd.mips.gpr[MIPS_GPR_RA];  
                         /*  no need to update cached_pc, as we're returning  */  
                         cpu->cd.mips.delay_slot = NOT_DELAYED;  
   
                         if (cpu->machine->show_trace_tree)  
                                 cpu_functioncall_trace_return(cpu);  
   
                         /*  TODO: how many instrs should this count as?  */  
                         return 10;  
                 }  
         }  
   
 #ifdef ALWAYS_SIGNEXTEND_32  
         /*  
          *  An extra check for 32-bit mode to make sure that all  
          *  registers are sign-extended:   (Slow, but might be useful  
          *  to detect bugs that have to do with sign-extension.)  
          */  
2125          if (cpu->is_32bit) {          if (cpu->is_32bit) {
2126                  int warning = 0;                  reg[COP0_EPC] = (int64_t)(int32_t)reg[COP0_EPC];
2127                  uint64_t x;                  mips32_pc_to_pointers(cpu);
2128            } else {
2129                  if (cpu->cd.mips.gpr[0] != 0) {                  mips_pc_to_pointers(cpu);
                         fatal("\nWARNING: r0 was not zero! (%016llx)\n\n",  
                             (long long)cpu->cd.mips.gpr[0]);  
                         cpu->cd.mips.gpr[0] = 0;  
                         warning = 1;  
                 }  
   
                 if (cpu->pc != (int64_t)(int32_t)cpu->pc) {  
                         fatal("\nWARNING: pc was not sign-extended correctly"  
                             " (%016llx)\n\n", (long long)cpu->pc);  
                         cpu->pc = (int64_t)(int32_t)cpu->pc;  
                         warning = 1;  
                 }  
   
                 if (cpu->cd.mips.pc_last != (int64_t)(int32_t)cpu->cd.mips.pc_last) {  
                         fatal("\nWARNING: pc_last was not sign-extended correc"  
                             "tly (%016llx)\n\n", (long long)cpu->cd.mips.pc_last);  
                         cpu->cd.mips.pc_last = (int64_t)(int32_t)cpu->cd.mips.pc_last;  
                         warning = 1;  
                 }  
   
                 /*  Sign-extend ALL registers, including coprocessor registers and tlbs:  */  
                 for (i=1; i<32; i++) {  
                         x = cpu->cd.mips.gpr[i];  
                         cpu->cd.mips.gpr[i] &= 0xffffffff;  
                         if (cpu->cd.mips.gpr[i] & 0x80000000ULL)  
                                 cpu->cd.mips.gpr[i] |= 0xffffffff00000000ULL;  
                         if (x != cpu->cd.mips.gpr[i]) {  
                                 fatal("\nWARNING: r%i (%s) was not sign-"  
                                     "extended correctly (%016llx != "  
                                     "%016llx)\n\n", i, regname(cpu->machine, i),  
                                     (long long)x, (long long)cpu->cd.mips.gpr[i]);  
                                 warning = 1;  
                         }  
                 }  
                 for (i=0; i<32; i++) {  
                         x = cpu->cd.mips.coproc[0]->reg[i];  
                         cpu->cd.mips.coproc[0]->reg[i] &= 0xffffffffULL;  
                         if (cpu->cd.mips.coproc[0]->reg[i] & 0x80000000ULL)  
                                 cpu->cd.mips.coproc[0]->reg[i] |=  
                                     0xffffffff00000000ULL;  
                         if (x != cpu->cd.mips.coproc[0]->reg[i]) {  
                                 fatal("\nWARNING: cop0,r%i was not sign-extended correctly (%016llx != %016llx)\n\n",  
                                     i, (long long)x, (long long)cpu->cd.mips.coproc[0]->reg[i]);  
                                 warning = 1;  
                         }  
                 }  
                 for (i=0; i<cpu->cd.mips.coproc[0]->nr_of_tlbs; i++) {  
                         x = cpu->cd.mips.coproc[0]->tlbs[i].hi;  
                         cpu->cd.mips.coproc[0]->tlbs[i].hi &= 0xffffffffULL;  
                         if (cpu->cd.mips.coproc[0]->tlbs[i].hi & 0x80000000ULL)  
                                 cpu->cd.mips.coproc[0]->tlbs[i].hi |=  
                                     0xffffffff00000000ULL;  
                         if (x != cpu->cd.mips.coproc[0]->tlbs[i].hi) {  
                                 fatal("\nWARNING: tlb[%i].hi was not sign-extended correctly (%016llx != %016llx)\n\n",  
                                     i, (long long)x, (long long)cpu->cd.mips.coproc[0]->tlbs[i].hi);  
                                 warning = 1;  
                         }  
   
                         x = cpu->cd.mips.coproc[0]->tlbs[i].lo0;  
                         cpu->cd.mips.coproc[0]->tlbs[i].lo0 &= 0xffffffffULL;  
                         if (cpu->cd.mips.coproc[0]->tlbs[i].lo0 & 0x80000000ULL)  
                                 cpu->cd.mips.coproc[0]->tlbs[i].lo0 |=  
                                     0xffffffff00000000ULL;  
                         if (x != cpu->cd.mips.coproc[0]->tlbs[i].lo0) {  
                                 fatal("\nWARNING: tlb[%i].lo0 was not sign-extended correctly (%016llx != %016llx)\n\n",  
                                     i, (long long)x, (long long)cpu->cd.mips.coproc[0]->tlbs[i].lo0);  
                                 warning = 1;  
                         }  
                 }  
   
                 if (warning) {  
                         fatal("Halting. pc = %016llx\n", (long long)cpu->pc);  
                         cpu->running = 0;  
                 }  
         }  
 #endif  
   
         PREFETCH(cpu->cd.mips.pc_last_host_4k_page + (cached_pc & 0xfff));  
   
 #ifdef HALT_IF_PC_ZERO  
         /*  Halt if PC = 0:  */  
         if (cached_pc == 0) {  
                 debug("cpu%i: pc=0, halting\n", cpu->cpu_id);  
                 cpu->running = 0;  
                 return 0;  
         }  
 #endif  
   
 #ifdef BINTRANS  
         if ((single_step || instruction_trace_cached)  
             && cpu->machine->bintrans_enable)  
                 cpu->cd.mips.dont_run_next_bintrans = 1;  
 #endif  
   
         if (!quiet_mode_cached) {  
                 /*  Dump CPU registers for debugging:  */  
                 if (cpu->machine->register_dump) {  
                         debug("\n");  
                         mips_cpu_register_dump(cpu, 1, 0x1);  
                 }  
         }  
   
         /*  Trace tree:  */  
         if (cpu->machine->show_trace_tree && cpu->cd.mips.show_trace_delay > 0) {  
                 cpu->cd.mips.show_trace_delay --;  
                 if (cpu->cd.mips.show_trace_delay == 0)  
                         cpu_functioncall_trace(cpu, cpu->cd.mips.show_trace_addr);  
         }  
   
 #ifdef MFHILO_DELAY  
         /*  Decrease the MFHI/MFLO delays:  */  
         if (cpu->mfhi_delay > 0)  
                 cpu->mfhi_delay--;  
         if (cpu->mflo_delay > 0)  
                 cpu->mflo_delay--;  
 #endif  
   
         /*  Read an instruction from memory:  */  
 #ifdef ENABLE_MIPS16  
         if (cpu->cd.mips.mips16 && (cached_pc & 1)) {  
                 /*  16-bit instruction word:  */  
                 unsigned char instr16[2];  
                 int mips16_offset = 0;  
   
                 if (!cpu->memory_rw(cpu, cpu->mem, cached_pc ^ 1, &instr16[0],  
                     sizeof(instr16), MEM_READ, CACHE_INSTRUCTION))  
                         return 0;  
   
                 /*  TODO:  If Reverse-endian is set in the status cop0 register, and  
                         we are in usermode, then reverse endianness!  */  
   
                 /*  The rest of the code is written for little endian, so swap if necessary:  */  
                 if (cpu->byte_order == EMUL_BIG_ENDIAN) {  
                         int tmp;  
                         tmp  = instr16[0]; instr16[0] = instr16[1]; instr16[1] = tmp;  
                 }  
   
                 cpu->cd.mips.mips16_extend = 0;  
   
                 /*  
                  *  Translate into 32-bit instruction, little endian (instr[3..0]):  
                  *  
                  *  This ugly loop is necessary because if we would get an exception between  
                  *  reading an extend instruction and the next instruction, and execution  
                  *  continues on the second instruction, the extend data would be lost. So the  
                  *  entire instruction (the two parts) need to be read in. If an exception is  
                  *  caused, it will appear as if it was caused when reading the extend instruction.  
                  */  
                 while (mips16_to_32(cpu, instr16, instr) == 0) {  
                         if (instruction_trace_cached)  
                                 debug("cpu%i @ %016llx: %02x%02x\t\t\textend\n",  
                                     cpu->cpu_id, (cpu->cd.mips.pc_last ^ 1) + mips16_offset,  
                                     instr16[1], instr16[0]);  
   
                         /*  instruction with extend:  */  
                         mips16_offset += 2;  
                         if (!cpu->memory_rw(cpu, cpu->mem, (cached_pc ^ 1) +  
                             mips16_offset, &instr16[0], sizeof(instr16),  
                             MEM_READ, CACHE_INSTRUCTION))  
                                 return 0;  
   
                         if (cpu->byte_order == EMUL_BIG_ENDIAN) {  
                                 int tmp;  
                                 tmp  = instr16[0]; instr16[0] = instr16[1]; instr16[1] = tmp;  
                         }  
                 }  
   
                 /*  TODO: bintrans like in 32-bit mode?  */  
   
                 /*  Advance the program counter:  */  
                 cpu->pc += sizeof(instr16) + mips16_offset;  
                 cached_pc = cpu->pc;  
   
                 if (instruction_trace_cached) {  
                         uint64_t offset;  
                         char *symbol = get_symbol_name(&cpu->machine->  
                             symbol_context, cpu->cd.mips.pc_last ^ 1, &offset);  
                         if (symbol != NULL && offset==0)  
                                 debug("<%s>\n", symbol);  
   
                         debug("cpu%i @ %016llx: %02x%02x => %02x%02x%02x%02x%s\t",  
                             cpu->cpu_id, (cpu->cd.mips.pc_last ^ 1) + mips16_offset,  
                             instr16[1], instr16[0],  
                             instr[3], instr[2], instr[1], instr[0],  
                             cpu_flags(cpu));  
                 }  
         } else  
 #endif  
             {  
                 /*  
                  *  Fetch a 32-bit instruction word from memory:  
                  *  
                  *  1)  The special case of reading an instruction from the  
                  *      same host RAM page as the last one is handled here,  
                  *      to gain a little bit performance.  
                  *  
                  *  2)  Fallback to reading from memory the usual way.  
                  */  
                 if (cached_pc & 3) {  
                         mips_cpu_exception(cpu, EXCEPTION_ADEL,  
                             0, cached_pc, 0, 0, 0, 0);  
                         return 0;  
                 }  
                 if (cpu->cd.mips.pc_last_host_4k_page != NULL &&  
                     (cached_pc & ~0xfff) == cpu->cd.mips.pc_last_virtual_page) {  
                         /*  NOTE: This only works on the host if offset is  
                             aligned correctly!  (TODO)  */  
                         *(uint32_t *)instr = *(uint32_t *)  
                             (cpu->cd.mips.pc_last_host_4k_page + (cached_pc & 0xffc));  
 #ifdef BINTRANS  
                         cpu->cd.mips.pc_bintrans_paddr_valid = 1;  
                         cpu->cd.mips.pc_bintrans_paddr =  
                             cpu->cd.mips.pc_last_physical_page | (cached_pc & 0xfff);  
                         cpu->cd.mips.pc_bintrans_host_4kpage = cpu->cd.mips.pc_last_host_4k_page;  
 #endif  
                 } else {  
                         if (!cpu->memory_rw(cpu, cpu->mem, cached_pc, &instr[0],  
                             sizeof(instr), MEM_READ, CACHE_INSTRUCTION))  
                                 return 0;  
                 }  
   
 #ifdef BINTRANS  
                 if (cpu->cd.mips.dont_run_next_bintrans) {  
                         cpu->cd.mips.dont_run_next_bintrans = 0;  
                 } else if (cpu->machine->bintrans_enable &&  
                     cpu->cd.mips.pc_bintrans_paddr_valid) {  
                         int res;  
                         cpu->cd.mips.bintrans_instructions_executed = 0;  
   
                         res = bintrans_attempt_translate(cpu,  
                             cpu->cd.mips.pc_bintrans_paddr);  
   
                         if (res >= 0) {  
                                 /*  debug("BINTRANS translation + hit,"  
                                     " pc = %016llx\n", (long long)cached_pc);  */  
                                 if (res > 0 || cpu->pc != cached_pc) {  
                                         if (instruction_trace_cached)  
                                                 mips_cpu_disassemble_instr(cpu, instr, 1, 0, 1);  
                                         if (res & BINTRANS_DONT_RUN_NEXT)  
                                                 cpu->cd.mips.dont_run_next_bintrans = 1;  
                                         res &= BINTRANS_N_MASK;  
   
                                         if (cpu->cd.mips.cpu_type.exc_model != EXC3K) {  
                                                 int x = cp0->reg[COP0_COUNT], y = cp0->reg[COP0_COMPARE];  
                                                 int diff = x - y;  
                                                 if (diff < 0 && diff + (res-1) >= 0  
                                                     && cpu->cd.mips.compare_register_set) {  
                                                         mips_cpu_interrupt(cpu, 7);  
                                                         cpu->cd.mips.compare_register_set = 0;  
                                                 }  
   
                                                 cp0->reg[COP0_COUNT] = (int64_t)  
                                                     (int32_t)(cp0->reg[COP0_COUNT] + res-1);  
                                         }  
   
                                         return res;  
                                 }  
                         }  
                 }  
 #endif  
   
                 if (instruction_trace_cached)  
                         mips_cpu_disassemble_instr(cpu, instr, 1, 0, 0);  
   
                 /*  Advance the program counter:  */  
                 cpu->pc += sizeof(instr);  
                 cached_pc = cpu->pc;  
   
                 /*  
                  *  TODO:  If Reverse-endian is set in the status cop0 register  
                  *  and we are in usermode, then reverse endianness!  
                  */  
   
                 /*  
                  *  The rest of the code is written for little endian, so  
                  *  swap if necessary:  
                  */  
                 if (cpu->byte_order == EMUL_BIG_ENDIAN) {  
                         int tmp = instr[0]; instr[0] = instr[3]; instr[3] = tmp;  
                             tmp = instr[1]; instr[1] = instr[2]; instr[2] = tmp;  
                 }  
         }  
   
   
         /*  
          *  Nullify this instruction?  (Set by a previous branch-likely  
          *  instruction.)  
          *  
          *  Note: The return value is 1, even if no instruction was actually  
          *  executed.  
          */  
         if (cpu->cd.mips.nullify_next) {  
                 cpu->cd.mips.nullify_next = 0;  
                 return 1;  
         }  
   
   
         /*  
          *  Execute the instruction:  
          */  
   
         /*  Get the top 6 bits of the instruction:  */  
         hi6 = instr[3] >> 2;    /*  & 0x3f  */  
   
         if (show_opcode_statistics)  
                 cpu->cd.mips.stats_opcode[hi6] ++;  
   
         switch (hi6) {  
         case HI6_SPECIAL:  
                 special6 = instr[0] & 0x3f;  
   
                 if (show_opcode_statistics)  
                         cpu->cd.mips.stats__special[special6] ++;  
   
                 switch (special6) {  
                 case SPECIAL_SLL:  
                 case SPECIAL_SRL:  
                 case SPECIAL_SRA:  
                 case SPECIAL_DSLL:  
                 case SPECIAL_DSRL:  
                 case SPECIAL_DSRA:  
                 case SPECIAL_DSLL32:  
                 case SPECIAL_DSRL32:  
                 case SPECIAL_DSRA32:  
                         rt = instr[2] & 31;  
                         rd = (instr[1] >> 3) & 31;  
                         sa = ((instr[1] & 7) << 2) + ((instr[0] >> 6) & 3);  
   
                         /*  
                          *  Check for NOP:  
                          *  
                          *  The R4000 manual says that a shift amount of zero  
                          *  is treated as a nop by some assemblers. Checking  
                          *  for sa == 0 here would not be correct, though,  
                          *  because instructions such as sll r3,r4,0 are  
                          *  possible, and are definitely not a nop.  
                          *  Instead, check if the destination register is r0.  
                          *  
                          *  TODO:  ssnop should wait until the _next_  
                          *  cycle boundary, or something like that. The  
                          *  code here is incorrect.  
                          */  
                         if (rd == 0 && special6 == SPECIAL_SLL) {  
                                 if (sa == 1) {  
                                         /*  ssnop  */  
 #ifdef ENABLE_INSTRUCTION_DELAYS  
                                         cpu->cd.mips.instruction_delay +=  
                                             cpu->cd.mips.cpu_type.  
                                             instrs_per_cycle - 1;  
 #endif  
                                 }  
                                 return 1;  
                         }  
   
                         if (special6 == SPECIAL_SLL) {  
                                 switch (sa) {  
                                 case 8: cpu->cd.mips.gpr[rd] = cpu->cd.mips.gpr[rt] << 8; break;  
                                 case 16:cpu->cd.mips.gpr[rd] = cpu->cd.mips.gpr[rt] << 16; break;  
                                 default:cpu->cd.mips.gpr[rd] = cpu->cd.mips.gpr[rt] << sa;  
                                 }  
                                 /*  Sign-extend rd:  */  
                                 cpu->cd.mips.gpr[rd] = (int64_t) (int32_t) cpu->cd.mips.gpr[rd];  
                         }  
                         if (special6 == SPECIAL_DSLL) {  
                                 cpu->cd.mips.gpr[rd] = cpu->cd.mips.gpr[rt] << sa;  
                         }  
                         if (special6 == SPECIAL_DSRL) {  
                                 cpu->cd.mips.gpr[rd] = cpu->cd.mips.gpr[rt] >> sa;  
                         }  
                         if (special6 == SPECIAL_DSLL32) {  
                                 cpu->cd.mips.gpr[rd] = cpu->cd.mips.gpr[rt] << (sa + 32);  
                         }  
                         if (special6 == SPECIAL_SRL) {  
                                 /*  
                                  *  Three cases:  
                                  *      shift amount = zero:  just copy  
                                  *      high bit of rt zero:  plain shift right (of all bits)  
                                  *      high bit of rt one:   plain shift right (of lowest 32 bits)  
                                  */  
                                 if (sa == 0)  
                                         cpu->cd.mips.gpr[rd] = cpu->cd.mips.gpr[rt];  
                                 else if (!(cpu->cd.mips.gpr[rt] & 0x80000000ULL)) {  
                                         cpu->cd.mips.gpr[rd] = cpu->cd.mips.gpr[rt] >> sa;  
                                 } else  
                                         cpu->cd.mips.gpr[rd] = (cpu->cd.mips.gpr[rt] & 0xffffffffULL) >> sa;  
                         }  
                         if (special6 == SPECIAL_SRA) {  
                                 int topbit = cpu->cd.mips.gpr[rt] & 0x80000000ULL;  
                                 switch (sa) {  
                                 case 8: cpu->cd.mips.gpr[rd] = cpu->cd.mips.gpr[rt] >> 8; break;  
                                 case 16:cpu->cd.mips.gpr[rd] = cpu->cd.mips.gpr[rt] >> 16; break;  
                                 default:cpu->cd.mips.gpr[rd] = cpu->cd.mips.gpr[rt] >> sa;  
                                 }  
                                 if (topbit)  
                                         cpu->cd.mips.gpr[rd] |= 0xffffffff00000000ULL;  
                         }  
                         if (special6 == SPECIAL_DSRL32) {  
                                 cpu->cd.mips.gpr[rd] = cpu->cd.mips.gpr[rt] >> (sa + 32);  
                         }  
                         if (special6 == SPECIAL_DSRA32 || special6 == SPECIAL_DSRA) {  
                                 if (special6 == SPECIAL_DSRA32)  
                                         sa += 32;  
                                 cpu->cd.mips.gpr[rd] = cpu->cd.mips.gpr[rt];  
                                 while (sa > 0) {  
                                         cpu->cd.mips.gpr[rd] = cpu->cd.mips.gpr[rd] >> 1;  
                                         sa--;  
                                         if (cpu->cd.mips.gpr[rd] & ((uint64_t)1 << 62))         /*  old signbit  */  
                                                 cpu->cd.mips.gpr[rd] |= ((uint64_t)1 << 63);  
                                 }  
                         }  
                         return 1;  
                 case SPECIAL_DSRLV:  
                 case SPECIAL_DSRAV:  
                 case SPECIAL_DSLLV:  
                 case SPECIAL_SLLV:  
                 case SPECIAL_SRAV:  
                 case SPECIAL_SRLV:  
                         rs = ((instr[3] & 3) << 3) + ((instr[2] >> 5) & 7);  
                         rt = instr[2] & 31;  
                         rd = (instr[1] >> 3) & 31;  
   
                         if (special6 == SPECIAL_DSRLV) {  
                                 sa = cpu->cd.mips.gpr[rs] & 63;  
                                 cpu->cd.mips.gpr[rd] = cpu->cd.mips.gpr[rt] >> sa;  
                         }  
                         if (special6 == SPECIAL_DSRAV) {  
                                 sa = cpu->cd.mips.gpr[rs] & 63;  
                                 cpu->cd.mips.gpr[rd] = cpu->cd.mips.gpr[rt];  
                                 while (sa > 0) {  
                                         cpu->cd.mips.gpr[rd] = cpu->cd.mips.gpr[rd] >> 1;  
                                         sa--;  
                                         if (cpu->cd.mips.gpr[rd] & ((uint64_t)1 << 62))         /*  old sign-bit  */  
                                                 cpu->cd.mips.gpr[rd] |= ((uint64_t)1 << 63);  
                                 }  
                         }  
                         if (special6 == SPECIAL_DSLLV) {  
                                 sa = cpu->cd.mips.gpr[rs] & 63;  
                                 cpu->cd.mips.gpr[rd] = cpu->cd.mips.gpr[rt];  
                                 cpu->cd.mips.gpr[rd] = cpu->cd.mips.gpr[rd] << sa;  
                         }  
                         if (special6 == SPECIAL_SLLV) {  
                                 sa = cpu->cd.mips.gpr[rs] & 31;  
                                 cpu->cd.mips.gpr[rd] = cpu->cd.mips.gpr[rt];  
                                 cpu->cd.mips.gpr[rd] = cpu->cd.mips.gpr[rd] << sa;  
                                 /*  Sign-extend rd:  */  
                                 cpu->cd.mips.gpr[rd] &= 0xffffffffULL;  
                                 if (cpu->cd.mips.gpr[rd] & 0x80000000ULL)  
                                         cpu->cd.mips.gpr[rd] |= 0xffffffff00000000ULL;  
                         }  
                         if (special6 == SPECIAL_SRAV) {  
                                 sa = cpu->cd.mips.gpr[rs] & 31;  
                                 cpu->cd.mips.gpr[rd] = cpu->cd.mips.gpr[rt];  
                                 /*  Sign-extend rd:  */  
                                 cpu->cd.mips.gpr[rd] &= 0xffffffffULL;  
                                 if (cpu->cd.mips.gpr[rd] & 0x80000000ULL)  
                                         cpu->cd.mips.gpr[rd] |= 0xffffffff00000000ULL;  
                                 while (sa > 0) {  
                                         cpu->cd.mips.gpr[rd] = cpu->cd.mips.gpr[rd] >> 1;  
                                         sa--;  
                                 }  
                                 if (cpu->cd.mips.gpr[rd] & 0x80000000ULL)  
                                         cpu->cd.mips.gpr[rd] |= 0xffffffff00000000ULL;  
                         }  
                         if (special6 == SPECIAL_SRLV) {  
                                 sa = cpu->cd.mips.gpr[rs] & 31;  
                                 cpu->cd.mips.gpr[rd] = cpu->cd.mips.gpr[rt];  
                                 cpu->cd.mips.gpr[rd] &= 0xffffffffULL;  
                                 cpu->cd.mips.gpr[rd] = cpu->cd.mips.gpr[rd] >> sa;  
                                 /*  And finally sign-extend rd:  */  
                                 if (cpu->cd.mips.gpr[rd] & 0x80000000ULL)  
                                         cpu->cd.mips.gpr[rd] |= 0xffffffff00000000ULL;  
                         }  
                         return 1;  
                 case SPECIAL_JR:  
                         if (cpu->cd.mips.delay_slot) {  
                                 fatal("jr: jump inside a jump's delay slot, or similar. TODO\n");  
                                 cpu->running = 0;  
                                 return 1;  
                         }  
   
                         rs = ((instr[3] & 3) << 3) + ((instr[2] >> 5) & 7);  
   
                         cpu->cd.mips.delay_slot = TO_BE_DELAYED;  
                         cpu->cd.mips.delay_jmpaddr = cpu->cd.mips.gpr[rs];  
   
                         if (cpu->machine->show_trace_tree && rs == 31)  
                                 cpu_functioncall_trace_return(cpu);  
   
                         return 1;  
                 case SPECIAL_JALR:  
                         if (cpu->cd.mips.delay_slot) {  
                                 fatal("jalr: jump inside a jump's delay slot, or similar. TODO\n");  
                                 cpu->running = 0;  
                                 return 1;  
                         }  
   
                         rs = ((instr[3] & 3) << 3) + ((instr[2] >> 5) & 7);  
                         rd = (instr[1] >> 3) & 31;  
   
                         tmpvalue = cpu->cd.mips.gpr[rs];  
                         cpu->cd.mips.gpr[rd] = cached_pc + 4;  
                             /*  already increased by 4 earlier  */  
   
                         if (cpu->machine->show_trace_tree && rd == 31) {  
                                 cpu->cd.mips.show_trace_delay = 2;  
                                 cpu->cd.mips.show_trace_addr = tmpvalue;  
                         }  
   
                         cpu->cd.mips.delay_slot = TO_BE_DELAYED;  
                         cpu->cd.mips.delay_jmpaddr = tmpvalue;  
                         return 1;  
                 case SPECIAL_MFHI:  
                 case SPECIAL_MFLO:  
                         rd = (instr[1] >> 3) & 31;  
   
                         if (special6 == SPECIAL_MFHI) {  
                                 cpu->cd.mips.gpr[rd] = cpu->cd.mips.hi;  
 #ifdef MFHILO_DELAY  
                                 cpu->mfhi_delay = 3;  
 #endif  
                         }  
                         if (special6 == SPECIAL_MFLO) {  
                                 cpu->cd.mips.gpr[rd] = cpu->cd.mips.lo;  
 #ifdef MFHILO_DELAY  
                                 cpu->mflo_delay = 3;  
 #endif  
                         }  
                         return 1;  
                 case SPECIAL_ADD:  
                 case SPECIAL_ADDU:  
                 case SPECIAL_SUB:  
                 case SPECIAL_SUBU:  
                 case SPECIAL_AND:  
                 case SPECIAL_OR:  
                 case SPECIAL_XOR:  
                 case SPECIAL_NOR:  
                 case SPECIAL_SLT:  
                 case SPECIAL_SLTU:  
                 case SPECIAL_MTLO:  
                 case SPECIAL_MTHI:  
                 case SPECIAL_MULT:  
                 case SPECIAL_MULTU:  
                 case SPECIAL_DMULT:  
                 case SPECIAL_DMULTU:  
                 case SPECIAL_DIV:  
                 case SPECIAL_DIVU:  
                 case SPECIAL_DDIV:  
                 case SPECIAL_DDIVU:  
                 case SPECIAL_TGE:  
                 case SPECIAL_TGEU:  
                 case SPECIAL_TLT:  
                 case SPECIAL_TLTU:  
                 case SPECIAL_TEQ:  
                 case SPECIAL_TNE:  
                 case SPECIAL_DADD:  
                 case SPECIAL_DADDU:  
                 case SPECIAL_DSUB:  
                 case SPECIAL_DSUBU:  
                 case SPECIAL_MOVZ:  
                 case SPECIAL_MOVN:  
                         rs = ((instr[3] & 3) << 3) + ((instr[2] >> 5) & 7);  
                         rt = instr[2] & 31;  
                         rd = (instr[1] >> 3) & 31;  
   
 #ifdef MFHILO_DELAY  
                         if (cpu->mflo_delay > 0 && (  
                             special6 == SPECIAL_DDIV ||   special6 == SPECIAL_DDIVU ||  
                             special6 == SPECIAL_DIV ||    special6 == SPECIAL_DIVU ||  
                             special6 == SPECIAL_DMULT ||  special6 == SPECIAL_DMULTU ||  
                             special6 == SPECIAL_MTLO ||   special6 == SPECIAL_MULT  
                             || special6 == SPECIAL_MULTU  
                             ) )  
                                 debug("warning: instruction modifying LO too early after mflo!\n");  
   
                         if (cpu->mfhi_delay > 0 && (  
                             special6 == SPECIAL_DDIV ||  special6 == SPECIAL_DDIVU ||  
                             special6 == SPECIAL_DIV ||   special6 == SPECIAL_DIVU ||  
                             special6 == SPECIAL_DMULT || special6 == SPECIAL_DMULTU ||  
                             special6 == SPECIAL_MTHI ||  special6 == SPECIAL_MULT  
                             || special6 == SPECIAL_MULTU  
                             ) )  
                                 debug("warning: instruction modifying HI too early after mfhi!\n");  
 #endif  
   
                         if (special6 == SPECIAL_ADDU) {  
                                 cpu->cd.mips.gpr[rd] = cpu->cd.mips.gpr[rs] + cpu->cd.mips.gpr[rt];  
                                 cpu->cd.mips.gpr[rd] &= 0xffffffffULL;  
                                 if (cpu->cd.mips.gpr[rd] & 0x80000000ULL)  
                                         cpu->cd.mips.gpr[rd] |= 0xffffffff00000000ULL;  
                                 break;  
                         }  
                         if (special6 == SPECIAL_ADD) {  
                                 /*  According to the MIPS64 manual:  */  
                                 uint64_t temp, temp1, temp2;  
                                 temp1 = cpu->cd.mips.gpr[rs] + ((cpu->cd.mips.gpr[rs] & 0x80000000ULL) << 1);  
                                 temp2 = cpu->cd.mips.gpr[rt] + ((cpu->cd.mips.gpr[rt] & 0x80000000ULL) << 1);  
                                 temp = temp1 + temp2;  
 #if 0  
         /*  TODO: apparently this doesn't work (an example of  
         something that breaks is NetBSD/sgimips' mips3_TBIA()  */  
                                 /*  If bits 32 and 31 of temp differ, then it's an overflow  */  
                                 temp1 = temp & 0x100000000ULL;  
                                 temp2 = temp & 0x80000000ULL;  
                                 if ((temp1 && !temp2) || (!temp1 && temp2)) {  
                                         mips_cpu_exception(cpu, EXCEPTION_OV, 0, 0, 0, 0, 0, 0);  
                                         break;  
                                 }  
 #endif  
                                 cpu->cd.mips.gpr[rd] = temp & 0xffffffffULL;  
                                 if (cpu->cd.mips.gpr[rd] & 0x80000000ULL)  
                                         cpu->cd.mips.gpr[rd] |= 0xffffffff00000000ULL;  
                                 break;  
                         }  
                         if (special6 == SPECIAL_SUBU) {  
                                 cpu->cd.mips.gpr[rd] = cpu->cd.mips.gpr[rs] - cpu->cd.mips.gpr[rt];  
                                 cpu->cd.mips.gpr[rd] &= 0xffffffffULL;  
                                 if (cpu->cd.mips.gpr[rd] & 0x80000000ULL)  
                                         cpu->cd.mips.gpr[rd] |= 0xffffffff00000000ULL;  
                                 break;  
                         }  
                         if (special6 == SPECIAL_SUB) {  
                                 /*  According to the MIPS64 manual:  */  
                                 uint64_t temp, temp1, temp2;  
                                 temp1 = cpu->cd.mips.gpr[rs] + ((cpu->cd.mips.gpr[rs] & 0x80000000ULL) << 1);  
                                 temp2 = cpu->cd.mips.gpr[rt] + ((cpu->cd.mips.gpr[rt] & 0x80000000ULL) << 1);  
                                 temp = temp1 - temp2;  
 #if 0  
                                 /*  If bits 32 and 31 of temp differ, then it's an overflow  */  
                                 temp1 = temp & 0x100000000ULL;  
                                 temp2 = temp & 0x80000000ULL;  
                                 if ((temp1 && !temp2) || (!temp1 && temp2)) {  
                                         mips_cpu_exception(cpu, EXCEPTION_OV, 0, 0, 0, 0, 0, 0);  
                                         break;  
                                 }  
 #endif  
                                 cpu->cd.mips.gpr[rd] = temp & 0xffffffffULL;  
                                 if (cpu->cd.mips.gpr[rd] & 0x80000000ULL)  
                                         cpu->cd.mips.gpr[rd] |= 0xffffffff00000000ULL;  
                                 break;  
                         }  
   
                         if (special6 == SPECIAL_AND) {  
                                 cpu->cd.mips.gpr[rd] = cpu->cd.mips.gpr[rs] & cpu->cd.mips.gpr[rt];  
                                 break;  
                         }  
                         if (special6 == SPECIAL_OR) {  
                                 cpu->cd.mips.gpr[rd] = cpu->cd.mips.gpr[rs] | cpu->cd.mips.gpr[rt];  
                                 break;  
                         }  
                         if (special6 == SPECIAL_XOR) {  
                                 cpu->cd.mips.gpr[rd] = cpu->cd.mips.gpr[rs] ^ cpu->cd.mips.gpr[rt];  
                                 break;  
                         }  
                         if (special6 == SPECIAL_NOR) {  
                                 cpu->cd.mips.gpr[rd] = ~(cpu->cd.mips.gpr[rs] | cpu->cd.mips.gpr[rt]);  
                                 break;  
                         }  
                         if (special6 == SPECIAL_SLT) {  
                                 cpu->cd.mips.gpr[rd] = (int64_t)cpu->cd.mips.gpr[rs] < (int64_t)cpu->cd.mips.gpr[rt];  
                                 break;  
                         }  
                         if (special6 == SPECIAL_SLTU) {  
                                 cpu->cd.mips.gpr[rd] = cpu->cd.mips.gpr[rs] < cpu->cd.mips.gpr[rt];  
                                 break;  
                         }  
                         if (special6 == SPECIAL_MTLO) {  
                                 cpu->cd.mips.lo = cpu->cd.mips.gpr[rs];  
                                 break;  
                         }  
                         if (special6 == SPECIAL_MTHI) {  
                                 cpu->cd.mips.hi = cpu->cd.mips.gpr[rs];  
                                 break;  
                         }  
                         if (special6 == SPECIAL_MULT) {  
                                 int64_t f1, f2, sum;  
                                 f1 = cpu->cd.mips.gpr[rs] & 0xffffffffULL;  
                                 /*  sign extend f1  */  
                                 if (f1 & 0x80000000ULL)  
                                         f1 |= 0xffffffff00000000ULL;  
                                 f2 = cpu->cd.mips.gpr[rt] & 0xffffffffULL;  
                                 /*  sign extend f2  */  
                                 if (f2 & 0x80000000ULL)  
                                         f2 |= 0xffffffff00000000ULL;  
                                 sum = f1 * f2;  
   
                                 cpu->cd.mips.lo = sum & 0xffffffffULL;  
                                 cpu->cd.mips.hi = ((uint64_t)sum >> 32) & 0xffffffffULL;  
   
                                 /*  sign-extend:  */  
                                 if (cpu->cd.mips.lo & 0x80000000ULL)  
                                         cpu->cd.mips.lo |= 0xffffffff00000000ULL;  
                                 if (cpu->cd.mips.hi & 0x80000000ULL)  
                                         cpu->cd.mips.hi |= 0xffffffff00000000ULL;  
   
                                 /*  
                                  *  NOTE:  The stuff about rd!=0 is just a  
                                  *  guess, judging from how some NetBSD code  
                                  *  seems to execute.  It is not documented in  
                                  *  the MIPS64 ISA docs :-/  
                                  */  
   
                                 if (rd != 0) {  
                                         if (cpu->cd.mips.cpu_type.rev != MIPS_R5900)  
                                                 debug("WARNING! mult_xx is an undocumented instruction!");  
                                         cpu->cd.mips.gpr[rd] = cpu->cd.mips.lo;  
                                 }  
                                 break;  
                         }  
                         if (special6 == SPECIAL_MULTU) {  
                                 uint64_t f1, f2, sum;  
                                 /*  zero extend f1 and f2  */  
                                 f1 = cpu->cd.mips.gpr[rs] & 0xffffffffULL;  
                                 f2 = cpu->cd.mips.gpr[rt] & 0xffffffffULL;  
                                 sum = f1 * f2;  
                                 cpu->cd.mips.lo = sum & 0xffffffffULL;  
                                 cpu->cd.mips.hi = (sum >> 32) & 0xffffffffULL;  
   
                                 /*  sign-extend:  */  
                                 if (cpu->cd.mips.lo & 0x80000000ULL)  
                                         cpu->cd.mips.lo |= 0xffffffff00000000ULL;  
                                 if (cpu->cd.mips.hi & 0x80000000ULL)  
                                         cpu->cd.mips.hi |= 0xffffffff00000000ULL;  
                                 break;  
                         }  
                         if (special6 == SPECIAL_DMULT) {  
                                 /*  64x64 = 128 bit multiplication, signed.  */  
                                 uint64_t s1 = cpu->cd.mips.gpr[rt];  
                                 uint64_t s2 = cpu->cd.mips.gpr[rs];  
                                 int n_negative = 0;  
                                 int i;  
   
                                 if ((int64_t)s1 < 0) {  
                                         s1 = -(int64_t)s1;  
                                         n_negative ++;  
                                 }  
                                 if ((int64_t)s2 < 0) {  
                                         s2 = -(int64_t)s2;  
                                         n_negative ++;  
                                 }  
   
                                 cpu->cd.mips.lo = cpu->cd.mips.hi = 0;  
   
                                 for (i=0; i<64; i++) {  
                                         int bit = (s1 & 0x8000000000000000ULL)? 1 : 0;  
                                         s1 <<= 1;  
                                         /*  If bit in s1 set, then add s2 to hi/lo:  */  
                                         if (bit) {  
                                                 uint64_t old_lo = cpu->cd.mips.lo;  
                                                 cpu->cd.mips.lo += s2;  
                                                 if (cpu->cd.mips.lo < old_lo)  
                                                         cpu->cd.mips.hi ++;  
                                         }  
                                         if (i != 63) {  
                                                 cpu->cd.mips.hi <<= 1;  
                                                 cpu->cd.mips.hi +=  
                                                     (cpu->cd.mips.lo & 0x8000000000000000ULL) ? 1 : 0;  
                                                 cpu->cd.mips.lo <<= 1;  
                                         }  
                                 }  
   
                                 if (n_negative == 1) {  
                                         cpu->cd.mips.hi = -(int64_t)cpu->cd.mips.hi;  
                                         cpu->cd.mips.lo = -(int64_t)cpu->cd.mips.lo;  
                                         if ((int64_t)cpu->cd.mips.lo < 0)  
                                                 cpu->cd.mips.hi --;  
                                 }  
                                 break;  
                         }  
                         if (special6 == SPECIAL_DMULTU) {  
                                 /*  64x64 = 128 bit multiplication, unsigned.  */  
                                 uint64_t s1 = cpu->cd.mips.gpr[rt];  
                                 uint64_t s2 = cpu->cd.mips.gpr[rs];  
                                 int i;  
   
                                 cpu->cd.mips.lo = cpu->cd.mips.hi = 0;  
   
                                 for (i=0; i<64; i++) {  
                                         int bit = (s1 & 0x8000000000000000ULL)? 1 : 0;  
                                         s1 <<= 1;  
                                         /*  If bit in s1 set, then add s2 to hi/lo:  */  
                                         if (bit) {  
                                                 uint64_t old_lo = cpu->cd.mips.lo;  
                                                 cpu->cd.mips.lo += s2;  
                                                 if (cpu->cd.mips.lo < old_lo)  
                                                         cpu->cd.mips.hi ++;  
                                         }  
                                         if (i != 63) {  
                                                 cpu->cd.mips.hi <<= 1;  
                                                 cpu->cd.mips.hi +=  
                                                     (cpu->cd.mips.lo & 0x8000000000000000ULL) ? 1 : 0;  
                                                 cpu->cd.mips.lo <<= 1;  
                                         }  
                                 }  
                                 break;  
                         }  
                         if (special6 == SPECIAL_DIV) {  
                                 int64_t a, b;  
                                 /*  Signextend rs and rt:  */  
                                 a = cpu->cd.mips.gpr[rs] & 0xffffffffULL;  
                                 if (a & 0x80000000ULL)  
                                         a |= 0xffffffff00000000ULL;  
                                 b = cpu->cd.mips.gpr[rt] & 0xffffffffULL;  
                                 if (b & 0x80000000ULL)  
                                         b |= 0xffffffff00000000ULL;  
   
                                 if (b == 0) {  
                                         /*  undefined  */  
                                         cpu->cd.mips.lo = cpu->cd.mips.hi = 0;  
                                 } else {  
                                         cpu->cd.mips.lo = a / b;  
                                         cpu->cd.mips.hi = a % b;  
                                 }  
                                 /*  Sign-extend lo and hi:  */  
                                 cpu->cd.mips.lo &= 0xffffffffULL;  
                                 if (cpu->cd.mips.lo & 0x80000000ULL)  
                                         cpu->cd.mips.lo |= 0xffffffff00000000ULL;  
                                 cpu->cd.mips.hi &= 0xffffffffULL;  
                                 if (cpu->cd.mips.hi & 0x80000000ULL)  
                                         cpu->cd.mips.hi |= 0xffffffff00000000ULL;  
                                 break;  
                         }  
                         if (special6 == SPECIAL_DIVU) {  
                                 int64_t a, b;  
                                 /*  Zero-extend rs and rt:  */  
                                 a = cpu->cd.mips.gpr[rs] & 0xffffffffULL;  
                                 b = cpu->cd.mips.gpr[rt] & 0xffffffffULL;  
                                 if (b == 0) {  
                                         /*  undefined  */  
                                         cpu->cd.mips.lo = cpu->cd.mips.hi = 0;  
                                 } else {  
                                         cpu->cd.mips.lo = a / b;  
                                         cpu->cd.mips.hi = a % b;  
                                 }  
                                 /*  Sign-extend lo and hi:  */  
                                 cpu->cd.mips.lo &= 0xffffffffULL;  
                                 if (cpu->cd.mips.lo & 0x80000000ULL)  
                                         cpu->cd.mips.lo |= 0xffffffff00000000ULL;  
                                 cpu->cd.mips.hi &= 0xffffffffULL;  
                                 if (cpu->cd.mips.hi & 0x80000000ULL)  
                                         cpu->cd.mips.hi |= 0xffffffff00000000ULL;  
                                 break;  
                         }  
                         if (special6 == SPECIAL_DDIV) {  
                                 if (cpu->cd.mips.gpr[rt] == 0) {  
                                         cpu->cd.mips.lo = cpu->cd.mips.hi = 0;          /*  undefined  */  
                                 } else {  
                                         cpu->cd.mips.lo = (int64_t)cpu->cd.mips.gpr[rs] / (int64_t)cpu->cd.mips.gpr[rt];  
                                         cpu->cd.mips.hi = (int64_t)cpu->cd.mips.gpr[rs] % (int64_t)cpu->cd.mips.gpr[rt];  
                                 }  
                                 break;  
                         }  
                         if (special6 == SPECIAL_DDIVU) {  
                                 if (cpu->cd.mips.gpr[rt] == 0) {  
                                         cpu->cd.mips.lo = cpu->cd.mips.hi = 0;          /*  undefined  */  
                                 } else {  
                                         cpu->cd.mips.lo = cpu->cd.mips.gpr[rs] / cpu->cd.mips.gpr[rt];  
                                         cpu->cd.mips.hi = cpu->cd.mips.gpr[rs] % cpu->cd.mips.gpr[rt];  
                                 }  
                                 break;  
                         }  
                         if (special6 == SPECIAL_TGE) {  
                                 if ((int64_t)cpu->cd.mips.gpr[rs] >= (int64_t)cpu->cd.mips.gpr[rt])  
                                         mips_cpu_exception(cpu, EXCEPTION_TR, 0, 0, 0, 0, 0, 0);  
                                 break;  
                         }  
                         if (special6 == SPECIAL_TGEU) {  
                                 if (cpu->cd.mips.gpr[rs] >= cpu->cd.mips.gpr[rt])  
                                         mips_cpu_exception(cpu, EXCEPTION_TR, 0, 0, 0, 0, 0, 0);  
                                 break;  
                         }  
                         if (special6 == SPECIAL_TLT) {  
                                 if ((int64_t)cpu->cd.mips.gpr[rs] < (int64_t)cpu->cd.mips.gpr[rt])  
                                         mips_cpu_exception(cpu, EXCEPTION_TR, 0, 0, 0, 0, 0, 0);  
                                 break;  
                         }  
                         if (special6 == SPECIAL_TLTU) {  
                                 if (cpu->cd.mips.gpr[rs] < cpu->cd.mips.gpr[rt])  
                                         mips_cpu_exception(cpu, EXCEPTION_TR, 0, 0, 0, 0, 0, 0);  
                                 break;  
                         }  
                         if (special6 == SPECIAL_TEQ) {  
                                 if (cpu->cd.mips.gpr[rs] == cpu->cd.mips.gpr[rt])  
                                         mips_cpu_exception(cpu, EXCEPTION_TR, 0, 0, 0, 0, 0, 0);  
                                 break;  
                         }  
                         if (special6 == SPECIAL_TNE) {  
                                 if (cpu->cd.mips.gpr[rs] != cpu->cd.mips.gpr[rt])  
                                         mips_cpu_exception(cpu, EXCEPTION_TR, 0, 0, 0, 0, 0, 0);  
                                 break;  
                         }  
                         if (special6 == SPECIAL_DADD) {  
                                 cpu->cd.mips.gpr[rd] = cpu->cd.mips.gpr[rs] + cpu->cd.mips.gpr[rt];  
                                 /*  TODO:  exception on overflow  */  
                                 break;  
                         }  
                         if (special6 == SPECIAL_DADDU) {  
                                 cpu->cd.mips.gpr[rd] = cpu->cd.mips.gpr[rs] + cpu->cd.mips.gpr[rt];  
                                 break;  
                         }  
                         if (special6 == SPECIAL_DSUB) {  
                                 cpu->cd.mips.gpr[rd] = cpu->cd.mips.gpr[rs] - cpu->cd.mips.gpr[rt];  
                                 /*  TODO:  exception on overflow  */  
                                 break;  
                         }  
                         if (special6 == SPECIAL_DSUBU) {  
                                 cpu->cd.mips.gpr[rd] = cpu->cd.mips.gpr[rs] - cpu->cd.mips.gpr[rt];  
                                 break;  
                         }  
                         if (special6 == SPECIAL_MOVZ) {  
                                 if (cpu->cd.mips.gpr[rt] == 0)  
                                         cpu->cd.mips.gpr[rd] = cpu->cd.mips.gpr[rs];  
                                 break;  
                         }  
                         if (special6 == SPECIAL_MOVN) {  
                                 if (cpu->cd.mips.gpr[rt] != 0)  
                                         cpu->cd.mips.gpr[rd] = cpu->cd.mips.gpr[rs];  
                                 return 1;  
                         }  
                         return 1;  
                 case SPECIAL_SYNC:  
                         /*  imm = ((instr[1] & 7) << 2) + (instr[0] >> 6);  */  
                         /*  TODO: actually sync  */  
   
                         /*  Clear the LLbit (at least on R10000):  */  
                         cpu->cd.mips.rmw = 0;  
                         return 1;  
                 case SPECIAL_SYSCALL:  
                         imm = ((instr[3] << 24) + (instr[2] << 16) +  
                             (instr[1] << 8) + instr[0]) >> 6;  
                         imm &= 0xfffff;  
   
                         if (cpu->machine->userland_emul != NULL)  
                                 useremul_syscall(cpu, imm);  
                         else  
                                 mips_cpu_exception(cpu, EXCEPTION_SYS,  
                                     0, 0, 0, 0, 0, 0);  
                         return 1;  
                 case SPECIAL_BREAK:  
                         mips_cpu_exception(cpu, EXCEPTION_BP, 0, 0, 0, 0, 0, 0);  
                         return 1;  
                 case SPECIAL_MFSA:  
                         /*  R5900? Move from shift amount register?  */  
                         /*  rd = (instr[1] >> 3) & 31;  */  
                         /*  TODO  */  
                         return 1;  
                 case SPECIAL_MTSA:  
                         /*  R5900? Move to shift amount register?  */  
                         /*  rs = ((instr[3] & 3) << 3) + ((instr[2] >> 5) & 7);  */  
                         /*  TODO  */  
                         return 1;  
                 default:  
                         if (!instruction_trace_cached) {  
                                 fatal("cpu%i @ %016llx: %02x%02x%02x%02x%s\t",  
                                     cpu->cpu_id, (long long)cpu->cd.mips.pc_last,  
                                     instr[3], instr[2], instr[1], instr[0], cpu_flags(cpu));  
                         }  
                         fatal("unimplemented special6 = 0x%02x\n", special6);  
                         cpu->running = 0;  
                         return 1;  
                 }  
                 return 1;  
         case HI6_BEQ:  
         case HI6_BEQL:  
         case HI6_BNE:  
         case HI6_BGTZ:  
         case HI6_BGTZL:  
         case HI6_BLEZ:  
         case HI6_BLEZL:  
         case HI6_BNEL:  
         case HI6_ADDI:  
         case HI6_ADDIU:  
         case HI6_DADDI:  
         case HI6_DADDIU:  
         case HI6_SLTI:  
         case HI6_SLTIU:  
         case HI6_ANDI:  
         case HI6_ORI:  
         case HI6_XORI:  
         case HI6_LUI:  
         case HI6_LB:  
         case HI6_LBU:  
         case HI6_LH:  
         case HI6_LHU:  
         case HI6_LW:  
         case HI6_LWU:  
         case HI6_LD:  
         case HI6_LQ_MDMX:  
         case HI6_LWC1:  
         case HI6_LWC2:  
         case HI6_LWC3:  
         case HI6_LDC1:  
         case HI6_LDC2:  
         case HI6_LL:  
         case HI6_LLD:  
         case HI6_SB:  
         case HI6_SH:  
         case HI6_SW:  
         case HI6_SD:  
         case HI6_SQ:  
         case HI6_SC:  
         case HI6_SCD:  
         case HI6_SWC1:  
         case HI6_SWC2:  
         case HI6_SWC3:  
         case HI6_SDC1:  
         case HI6_SDC2:  
         case HI6_LWL:   /*  Unaligned load/store  */  
         case HI6_LWR:  
         case HI6_LDL:  
         case HI6_LDR:  
         case HI6_SWL:  
         case HI6_SWR:  
         case HI6_SDL:  
         case HI6_SDR:  
                 rs = ((instr[3] & 3) << 3) + ((instr[2] >> 5) & 7);  
                 rt = instr[2] & 31;  
                 imm = (instr[1] << 8) + instr[0];  
                 if (imm >= 32768)               /*  signed 16-bit  */  
                         imm -= 65536;  
   
                 tmpvalue = imm;         /*  used later in several cases  */  
   
                 switch (hi6) {  
                 case HI6_ADDI:  
                 case HI6_ADDIU:  
                 case HI6_DADDI:  
                 case HI6_DADDIU:  
                         tmpvalue = cpu->cd.mips.gpr[rs];  
                         result_value = cpu->cd.mips.gpr[rs] + imm;  
   
                         if (hi6 == HI6_ADDI || hi6 == HI6_DADDI) {  
                                 /*  
                                  *  addi and daddi should trap on overflow:  
                                  *  
                                  *  TODO:  This is incorrect? The R4000 manual  
                                  *  says that overflow occurs if the carry bits  
                                  *  out of bit 62 and 63 differ. The  
                                  *  destination register should not be modified  
                                  *  on overflow.  
                                  */  
                                 if (imm >= 0) {  
                                         /*  Turn around from 0x7fff.. to 0x800 ?  Then overflow.  */  
                                         if (   ((hi6 == HI6_ADDI && (result_value &  
                                             0x80000000ULL) && (tmpvalue &  
                                             0x80000000ULL)==0))  
                                             || ((hi6 == HI6_DADDI && (result_value &  
                                             0x8000000000000000ULL) && (tmpvalue &  
                                             0x8000000000000000ULL)==0)) ) {  
                                                 mips_cpu_exception(cpu, EXCEPTION_OV, 0, 0, 0, 0, 0, 0);  
                                                 break;  
                                         }  
                                 } else {  
                                         /*  Turn around from 0x8000.. to 0x7fff.. ?  Then overflow.  */  
                                         if (   ((hi6 == HI6_ADDI && (result_value &  
                                             0x80000000ULL)==0 && (tmpvalue &  
                                             0x80000000ULL)))  
                                             || ((hi6 == HI6_DADDI && (result_value &  
                                             0x8000000000000000ULL)==0 && (tmpvalue &  
                                             0x8000000000000000ULL))) ) {  
                                                 mips_cpu_exception(cpu, EXCEPTION_OV, 0, 0, 0, 0, 0, 0);  
                                                 break;  
                                         }  
                                 }  
                         }  
   
                         cpu->cd.mips.gpr[rt] = result_value;  
   
                         /*  
                          *  Super-ugly speed-hack:  (only if speed_tricks != 0)  
                          *  NOTE: This makes the emulation less correct.  
                          *  
                          *  If we encounter a loop such as:  
                          *  
                          *      8012f5f4: 1c40ffff      bgtz r0,r2,ffffffff8012f5f4  
                          *      8012f5f8: 2442ffff (d)  addiu r2,r2,-1  
                          *  
                          *  then it is a small loop which simply waits for r2  
                          *  to become zero.  
                          *  
                          *  TODO:  increaste the count register, and cause  
                          *  interrupts!!!  For now: return as if we just  
                          *  executed 1 instruction.  
                          */  
                         ninstrs_executed = 1;  
                         if (cpu->machine->speed_tricks && cpu->cd.mips.delay_slot &&  
                             cpu->cd.mips.last_was_jumptoself &&  
                             cpu->cd.mips.jump_to_self_reg == rt &&  
                             cpu->cd.mips.jump_to_self_reg == rs) {  
                                 if ((int64_t)cpu->cd.mips.gpr[rt] > 1 && (int64_t)cpu->cd.mips.gpr[rt] < 0x70000000  
                                     && (imm >= -30000 && imm <= -1)) {  
                                         if (instruction_trace_cached)  
                                                 debug("changing r%i from %016llx to", rt, (long long)cpu->cd.mips.gpr[rt]);  
   
                                         while ((int64_t)cpu->cd.mips.gpr[rt] > 0 && ninstrs_executed < 1000  
                                             && ((int64_t)cpu->cd.mips.gpr[rt] + (int64_t)imm) > 0) {  
                                                 cpu->cd.mips.gpr[rt] += (int64_t)imm;  
                                                 ninstrs_executed += 2;  
                                         }  
   
                                         if (instruction_trace_cached)  
                                                 debug(" %016llx\n", (long long)cpu->cd.mips.gpr[rt]);  
   
                                         /*  TODO: return value, cpu->cd.mips.gpr[rt] * 2;  */  
                                 }  
                                 if ((int64_t)cpu->cd.mips.gpr[rt] > -0x70000000 && (int64_t)cpu->cd.mips.gpr[rt] < -1  
                                      && (imm >= 1 && imm <= 30000)) {  
                                         if (instruction_trace_cached)  
                                                 debug("changing r%i from %016llx to", rt, (long long)cpu->cd.mips.gpr[rt]);  
   
                                         while ((int64_t)cpu->cd.mips.gpr[rt] < 0 && ninstrs_executed < 1000  
                                             && ((int64_t)cpu->cd.mips.gpr[rt] + (int64_t)imm) < 0) {  
                                                 cpu->cd.mips.gpr[rt] += (int64_t)imm;  
                                                 ninstrs_executed += 2;  
                                         }  
   
                                         if (instruction_trace_cached)  
                                                 debug(" %016llx\n", (long long)cpu->cd.mips.gpr[rt]);  
                                 }  
                         }  
   
                         if (hi6 == HI6_ADDI || hi6 == HI6_ADDIU) {  
                                 /*  Sign-extend:  */  
                                 cpu->cd.mips.gpr[rt] &= 0xffffffffULL;  
                                 if (cpu->cd.mips.gpr[rt] & 0x80000000ULL)  
                                         cpu->cd.mips.gpr[rt] |= 0xffffffff00000000ULL;  
                         }  
                         return ninstrs_executed;  
                 case HI6_BEQ:  
                 case HI6_BNE:  
                 case HI6_BGTZ:  
                 case HI6_BGTZL:  
                 case HI6_BLEZ:  
                 case HI6_BLEZL:  
                 case HI6_BEQL:  
                 case HI6_BNEL:  
                         if (cpu->cd.mips.delay_slot) {  
                                 fatal("b*: jump inside a jump's delay slot, or similar. TODO\n");  
                                 cpu->running = 0;  
                                 return 1;  
                         }  
                         likely = cond = 0;  
                         switch (hi6) {  
                         case HI6_BNEL:  likely = 1;  
                         case HI6_BNE:   cond = (cpu->cd.mips.gpr[rt] != cpu->cd.mips.gpr[rs]);  
                                         break;  
                         case HI6_BEQL:  likely = 1;  
                         case HI6_BEQ:   cond = (cpu->cd.mips.gpr[rt] == cpu->cd.mips.gpr[rs]);  
                                         break;  
                         case HI6_BLEZL: likely = 1;  
                         case HI6_BLEZ:  cond = ((int64_t)cpu->cd.mips.gpr[rs] <= 0);  
                                         break;  
                         case HI6_BGTZL: likely = 1;  
                         case HI6_BGTZ:  cond = ((int64_t)cpu->cd.mips.gpr[rs] > 0);  
                                         break;  
                         }  
   
                         if (cond) {  
                                 cpu->cd.mips.delay_slot = TO_BE_DELAYED;  
                                 cpu->cd.mips.delay_jmpaddr = cached_pc + (imm << 2);  
                         } else {  
                                 if (likely)  
                                         cpu->cd.mips.nullify_next = 1;          /*  nullify delay slot  */  
                         }  
   
                         if (imm==-1 && (hi6 == HI6_BGTZ || hi6 == HI6_BLEZ ||  
                             (hi6 == HI6_BGTZL && cond) ||  
                             (hi6 == HI6_BLEZL && cond) ||  
                             (hi6 == HI6_BNE && (rt==0 || rs==0)) ||  
                             (hi6 == HI6_BEQ && (rt==0 || rs==0)))) {  
                                 cpu->cd.mips.last_was_jumptoself = 2;  
                                 if (rs == 0)  
                                         cpu->cd.mips.jump_to_self_reg = rt;  
                                 else  
                                         cpu->cd.mips.jump_to_self_reg = rs;  
                         }  
                         return 1;  
                 case HI6_LUI:  
                         cpu->cd.mips.gpr[rt] = (imm << 16);  
                         /*  No sign-extending necessary, as imm already  
                             was sign-extended if it was negative.  */  
                         break;  
                 case HI6_SLTI:  
                         cpu->cd.mips.gpr[rt] = (int64_t)cpu->cd.mips.gpr[rs] < (int64_t)tmpvalue;  
                         break;  
                 case HI6_SLTIU:  
                         cpu->cd.mips.gpr[rt] = cpu->cd.mips.gpr[rs] < (uint64_t)imm;  
                         break;  
                 case HI6_ANDI:  
                         cpu->cd.mips.gpr[rt] = cpu->cd.mips.gpr[rs] & (tmpvalue & 0xffff);  
                         break;  
                 case HI6_ORI:  
                         cpu->cd.mips.gpr[rt] = cpu->cd.mips.gpr[rs] | (tmpvalue & 0xffff);  
                         break;  
                 case HI6_XORI:  
                         cpu->cd.mips.gpr[rt] = cpu->cd.mips.gpr[rs] ^ (tmpvalue & 0xffff);  
                         break;  
                 case HI6_LB:  
                 case HI6_LBU:  
                 case HI6_LH:  
                 case HI6_LHU:  
                 case HI6_LW:  
                 case HI6_LWU:  
                 case HI6_LD:  
                 case HI6_LQ_MDMX:  
                 case HI6_LWC1:  
                 case HI6_LWC2:  
                 case HI6_LWC3:  /*  pref  */  
                 case HI6_LDC1:  
                 case HI6_LDC2:  
                 case HI6_LL:  
                 case HI6_LLD:  
                 case HI6_SB:  
                 case HI6_SH:  
                 case HI6_SW:  
                 case HI6_SD:  
                 case HI6_SQ:  
                 case HI6_SC:  
                 case HI6_SCD:  
                 case HI6_SWC1:  
                 case HI6_SWC2:  
                 case HI6_SWC3:  
                 case HI6_SDC1:  
                 case HI6_SDC2:  
                         /*  These are the default "assumptions".  */  
                         linked = 0;  
                         st = 1;  
                         signd = 1;  
                         wlen = 4;  
   
                         switch (hi6) {  
                         /*  The most common ones:  */  
                         case HI6_LW:    {           st = 0;            }  break;  
                         case HI6_SW:    {                   signd = 0; }  break;  
   
                         case HI6_LB:    { wlen = 1; st = 0;            }  break;  
                         case HI6_LBU:   { wlen = 1; st = 0; signd = 0; }  break;  
                         case HI6_SB:    { wlen = 1;         signd = 0; }  break;  
   
                         case HI6_LD:    { wlen = 8; st = 0; signd = 0; }  break;  
                         case HI6_SD:    { wlen = 8;         signd = 0; }  break;  
   
                         case HI6_LQ_MDMX:       { wlen = 16; st = 0; signd = 0; }  break;       /*  R5900, otherwise MDMX (TODO)  */  
                         case HI6_SQ:            { wlen = 16;         signd = 0; }  break;       /*  R5900 ?  */  
   
                         /*  The rest:  */  
                         case HI6_LH:    { wlen = 2; st = 0;            }  break;  
                         case HI6_LHU:   { wlen = 2; st = 0; signd = 0; }  break;  
                         case HI6_LWU:   {           st = 0; signd = 0; }  break;  
                         case HI6_LWC1:  {           st = 0;            }  break;  
                         case HI6_LWC2:  {           st = 0;            }  break;  
                         case HI6_LWC3:  {           st = 0;            }  break;  
                         case HI6_LDC1:  { wlen = 8; st = 0; signd = 0; }  break;  
                         case HI6_LDC2:  { wlen = 8; st = 0; signd = 0; }  break;  
   
                         case HI6_SH:    { wlen = 2;         signd = 0; }  break;  
                         case HI6_SDC1:  
                         case HI6_SDC2:  wlen = 8;  
                         case HI6_SWC1:  
                         case HI6_SWC2:  
                         case HI6_SWC3:  {                   signd = 0; }  break;  
   
                         case HI6_LL:    {           st = 0; signd = 1; linked = 1; }  break;  
                         case HI6_LLD:   { wlen = 8; st = 0; signd = 0; linked = 1; }  break;  
   
                         case HI6_SC:    {                   signd = 1; linked = 1; }  break;  
                         case HI6_SCD:   { wlen = 8;         signd = 0; linked = 1; }  break;  
   
                         default:  
                                 fatal("cannot be here\n");  
                                 wlen = 4; st = 0; signd = 0;  
                         }  
   
                         /*  
                          *  In the MIPS IV ISA, the 'lwc3' instruction is changed into 'pref'.  
                          *  The pref instruction is emulated by not doing anything. :-)  TODO  
                          */  
                         if (hi6 == HI6_LWC3 && cpu->cd.mips.cpu_type.isa_level >= 4) {  
                                 /*  Clear the LLbit (at least on R10000):  */  
                                 cpu->cd.mips.rmw = 0;  
                                 break;  
                         }  
   
                         addr = cpu->cd.mips.gpr[rs] + imm;  
   
                         /*  Check for natural alignment:  */  
                         if ((addr & (wlen - 1)) != 0) {  
                                 mips_cpu_exception(cpu, st? EXCEPTION_ADES : EXCEPTION_ADEL,  
                                     0, addr, 0, 0, 0, 0);  
                                 break;  
                         }  
   
 #if 0  
                         if (cpu->cd.mips.cpu_type.isa_level == 4 && (imm & (wlen - 1)) != 0)  
                                 debug("WARNING: low bits of imm value not zero! (MIPS IV) "  
                                     "pc=%016llx", (long long)cpu->cd.mips.pc_last);  
 #endif  
   
                         /*  
                          *  Load Linked: This initiates a Read-Modify-Write  
                          *  sequence.  
                          */  
                         if (linked) {  
                                 if (st==0) {  
                                         /*  st == 0:  Load  */  
                                         cpu->cd.mips.rmw      = 1;  
                                         cpu->cd.mips.rmw_addr = addr;  
                                         cpu->cd.mips.rmw_len  = wlen;  
   
                                         /*  
                                          *  COP0_LLADDR is updated for  
                                          *  diagnostic purposes, except for  
                                          *  CPUs in the R10000 family.  
                                          */  
                                         if (cpu->cd.mips.cpu_type.exc_model != MMU10K)  
                                                 cp0->reg[COP0_LLADDR] =  
                                                     (addr >> 4) & 0xffffffffULL;  
                                 } else {  
                                         /*  
                                          *  st == 1:  Store  
                                          *  If rmw is 0, then the store failed.  
                                          *  (This cache-line was written to by  
                                          *  someone else.)  
                                          */  
                                         if (cpu->cd.mips.rmw == 0 ||  
                                             cpu->cd.mips.rmw_addr != addr ||  
                                             cpu->cd.mips.rmw_len != wlen) {  
                                                 /*  The store failed:  */  
                                                 cpu->cd.mips.gpr[rt] = 0;  
                                                 if (instruction_trace_cached)  
                                                         debug(" [COLLISION] ");  
                                                 break;  
                                         }  
                                 }  
                         } else {  
                                 /*  
                                  *  If any kind of load or store occurs between  
                                  *  an ll and an sc, then the ll-sc sequence  
                                  *  should fail.  (This is local to each cpu.)  
                                  */  
                                 cpu->cd.mips.rmw = 0;  
                         }  
   
                         value_hi = 0;  
   
                         if (st) {  
                                 /*  store:  */  
                                 int cpnr, success;  
   
                                 if (hi6 == HI6_SWC3 || hi6 == HI6_SWC2 ||  
                                     hi6 == HI6_SDC1 || hi6 == HI6_SWC1) {  
                                         cpnr = 1;  
                                         switch (hi6) {  
                                         case HI6_SWC3:  cpnr++;         /*  fallthrough  */  
                                         case HI6_SWC2:  cpnr++;  
                                         case HI6_SDC1:  
                                         case HI6_SWC1:  if (cpu->cd.mips.coproc[cpnr] == NULL ||  
                                                             (!(cp0->reg[COP0_STATUS] & ((1 << cpnr) << STATUS_CU_SHIFT))) ) {  
                                                                 mips_cpu_exception(cpu, EXCEPTION_CPU, 0, 0, cpnr, 0, 0, 0);  
                                                                 cpnr = -1;  
                                                                 break;  
                                                         } else {  
                                                                 /*  Special handling of 64-bit stores  
                                                                     on 32-bit CPUs, and on newer CPUs  
                                                                     in 32-bit compatiblity mode:  */  
                                                                 if ((hi6==HI6_SDC1 || hi6==HI6_SDC2) &&  
                                                                     (cpu->cd.mips.cpu_type.isa_level <= 2 ||  
                                                                     !(cp0->reg[COP0_STATUS] & STATUS_FR))) {  
                                                                         uint64_t a, b;  
                                                                         coproc_register_read(cpu,  
                                                                             cpu->cd.mips.coproc[cpnr], rt, &a, 0);  
                                                                         coproc_register_read(cpu,  
                                                                             cpu->cd.mips.coproc[cpnr], rt^1, &b, 0);  
                                                                         if (rt & 1)  
                                                                                 fatal("WARNING: SDCx in 32-bit mode from odd register!\n");  
                                                                         value = (a & 0xffffffffULL)  
                                                                             | (b << 32);  
                                                                 } else  
                                                                         coproc_register_read(cpu, cpu->cd.mips.coproc[cpnr], rt, &value, 0);  
                                                         }  
                                                         break;  
                                         default:  
                                                         ;  
                                         }  
                                         if (cpnr < 0)  
                                                 break;  
                                 } else  
                                         value = cpu->cd.mips.gpr[rt];  
   
                                 if (wlen == 4) {  
                                         /*  Special case for 32-bit stores... (perhaps not worth it)  */  
                                         if (cpu->byte_order == EMUL_LITTLE_ENDIAN) {  
                                                 d[0] = value & 0xff;         d[1] = (value >> 8) & 0xff;  
                                                 d[2] = (value >> 16) & 0xff; d[3] = (value >> 24) & 0xff;  
                                         } else {  
                                                 d[3] = value & 0xff;         d[2] = (value >> 8) & 0xff;  
                                                 d[1] = (value >> 16) & 0xff; d[0] = (value >> 24) & 0xff;  
                                         }  
                                 } else if (wlen == 16) {  
                                         value_hi = cpu->cd.mips.gpr_quadhi[rt];  
                                         /*  Special case for R5900 128-bit stores:  */  
                                         if (cpu->byte_order == EMUL_LITTLE_ENDIAN)  
                                                 for (i=0; i<8; i++) {  
                                                         d[i] = (value >> (i*8)) & 255;  
                                                         d[i+8] = (value_hi >> (i*8)) & 255;  
                                                 }  
                                         else  
                                                 for (i=0; i<8; i++) {  
                                                         d[i] = (value >> ((wlen-1-i)*8)) & 255;  
                                                         d[i + 8] = (value_hi >> ((wlen-1-i)*8)) & 255;  
                                                 }  
                                 } else if (wlen == 1) {  
                                         d[0] = value & 0xff;  
                                 } else {  
                                         /*  General case:  */  
                                         uint64_t v = value;  
                                         if (cpu->byte_order ==  
                                             EMUL_LITTLE_ENDIAN)  
                                                 for (i=0; i<wlen; i++) {  
                                                         d[i] = v & 255;  
                                                         v >>= 8;  
                                                 }  
                                         else  
                                                 for (i=0; i<wlen; i++) {  
                                                         d[wlen-1-i] = v & 255;  
                                                         v >>= 8;  
                                                 }  
                                 }  
   
                                 success = cpu->memory_rw(cpu, cpu->mem, addr,  
                                     d, wlen, MEM_WRITE, CACHE_DATA);  
                                 if (!success) {  
                                         /*  The store failed, and might have caused an exception.  */  
                                         if (instruction_trace_cached)  
                                                 debug("(failed)]\n");  
                                         break;  
                                 }  
                         } else {  
                                 /*  load:  */  
                                 int cpnr = 1;  
                                 int success;  
   
                                 success = cpu->memory_rw(cpu, cpu->mem, addr,  
                                     d, wlen, MEM_READ, CACHE_DATA);  
                                 if (!success) {  
                                         /*  The load failed, and might have caused an exception.  */  
                                         if (instruction_trace_cached)  
                                                 debug("(failed)]\n");  
                                         break;  
                                 }  
   
                                 if (wlen == 1)  
                                         value = d[0] | (signd && (d[0]&128)? (-1 << 8) : 0);  
                                 else if (wlen != 16) {  
                                         /*  General case (except for 128-bit):  */  
                                         int i;  
                                         value = 0;  
                                         if (cpu->byte_order == EMUL_LITTLE_ENDIAN) {  
                                                 if (signd && (d[wlen-1] & 128)!=0)      /*  sign extend  */  
                                                         value = -1;  
                                                 for (i=wlen-1; i>=0; i--) {  
                                                         value <<= 8;  
                                                         value += d[i];  
                                                 }  
                                         } else {  
                                                 if (signd && (d[0] & 128)!=0)           /*  sign extend  */  
                                                         value = -1;  
                                                 for (i=0; i<wlen; i++) {  
                                                         value <<= 8;  
                                                         value += d[i];  
                                                 }  
                                         }  
                                 } else {  
                                         /*  R5900 128-bit quadword:  */  
                                         int i;  
                                         value_hi = 0;  
                                         value = 0;  
                                         if (cpu->byte_order == EMUL_LITTLE_ENDIAN) {  
                                                 for (i=wlen-1; i>=0; i--) {  
                                                         value_hi <<= 8;  
                                                         value_hi += (value >> 56) & 255;  
                                                         value <<= 8;  
                                                         value += d[i];  
                                                 }  
                                         } else {  
                                                 for (i=0; i<wlen; i++) {  
                                                         value_hi <<= 8;  
                                                         value_hi += (value >> 56) & 255;  
                                                         value <<= 8;  
                                                         value += d[i];  
                                                 }  
                                         }  
                                         cpu->cd.mips.gpr_quadhi[rt] = value_hi;  
                                 }  
   
                                 switch (hi6) {  
                                 case HI6_LWC3:  cpnr++;         /*  fallthrough  */  
                                 case HI6_LDC2:  
                                 case HI6_LWC2:  cpnr++;  
                                 case HI6_LDC1:  
                                 case HI6_LWC1:  if (cpu->cd.mips.coproc[cpnr] == NULL ||  
                                                     (!(cp0->reg[COP0_STATUS] & ((1 << cpnr) << STATUS_CU_SHIFT))) ) {  
                                                         mips_cpu_exception(cpu, EXCEPTION_CPU, 0, 0, cpnr, 0, 0, 0);  
                                                 } else {  
                                                         /*  Special handling of 64-bit loads  
                                                             on 32-bit CPUs, and on newer CPUs  
                                                             in 32-bit compatiblity mode:  */  
                                                         if ((hi6==HI6_LDC1 || hi6==HI6_LDC2) &&  
                                                             (cpu->cd.mips.cpu_type.isa_level <= 2 ||  
                                                             !(cp0->reg[COP0_STATUS] & STATUS_FR))) {  
                                                                 uint64_t a, b;  
                                                                 a = (int64_t)(int32_t) (value & 0xffffffffULL);  
                                                                 b = (int64_t)(int32_t) (value >> 32);  
                                                                 coproc_register_write(cpu,  
                                                                     cpu->cd.mips.coproc[cpnr], rt, &a,  
                                                                     hi6==HI6_LDC1 || hi6==HI6_LDC2, 0);  
                                                                 coproc_register_write(cpu,  
                                                                     cpu->cd.mips.coproc[cpnr], rt ^ 1, &b,  
                                                                     hi6==HI6_LDC1 || hi6==HI6_LDC2, 0);  
                                                                 if (rt & 1)  
                                                                         fatal("WARNING: LDCx in 32-bit mode to odd register!\n");  
                                                         } else {  
                                                                 coproc_register_write(cpu,  
                                                                     cpu->cd.mips.coproc[cpnr], rt, &value,  
                                                                     hi6==HI6_LDC1 || hi6==HI6_LDC2, 0);  
                                                         }  
                                                 }  
                                                 break;  
                                 default:        if (rt != 0)  
                                                         cpu->cd.mips.gpr[rt] = value;  
                                 }  
                         }  
   
                         if (linked && st==1) {  
                                 /*  
                                  *  The store succeeded. Invalidate any other  
                                  *  cpu's store to this cache line, and then  
                                  *  return 1 in gpr rt:  
                                  *  
                                  *  (this is a semi-ugly hack using global  
                                  * 'cpus')  
                                  *  
                                  *  TODO: How about invalidating other CPUs  
                                  *  stores to this cache line, even if this  
                                  *  was _NOT_ a linked store?  
                                  */  
                                 for (i=0; i<cpu->machine->ncpus; i++) {  
                                         if (cpu->machine->cpus[i]->cd.mips.rmw) {  
                                                 uint64_t yaddr = addr;  
                                                 uint64_t xaddr =  
                                                     cpu->machine->cpus[i]->cd.mips.rmw_addr;  
                                                 uint64_t mask;  
                                                 mask = ~(cpu->machine->cpus[i]->  
                                                     cd.mips.cache_linesize[CACHE_DATA]  
                                                     - 1);  
                                                 xaddr &= mask;  
                                                 yaddr &= mask;  
                                                 if (xaddr == yaddr) {  
                                                         cpu->machine->cpus[i]->cd.mips.rmw = 0;  
                                                         cpu->machine->cpus[i]->cd.mips.rmw_addr = 0;  
                                                 }  
                                         }  
                                 }  
   
                                 if (rt != 0)  
                                         cpu->cd.mips.gpr[rt] = 1;  
   
                                 if (instruction_trace_cached)  
                                         debug(" [no collision] ");  
                                 cpu->cd.mips.rmw = 0;  
                         }  
   
                         if (instruction_trace_cached) {  
                                 switch (wlen) {  
                                 case 2: debug("0x%04x", (int)value); break;  
                                 case 4: debug("0x%08x", (int)value); break;  
                                 case 8: debug("0x%016llx", (long long)value);  
                                         break;  
                                 case 16:debug("0x%016llx", (long long)value_hi);  
                                         debug("%016llx", (long long)value);  
                                         break;  
                                 default:debug("0x%02x", (int)value);  
                                 }  
                                 debug("]\n");  
                         }  
                         return 1;  
                 case HI6_LWL:   /*  Unaligned load/store  */  
                 case HI6_LWR:  
                 case HI6_LDL:  
                 case HI6_LDR:  
                 case HI6_SWL:  
                 case HI6_SWR:  
                 case HI6_SDL:  
                 case HI6_SDR:  
                         /*  For L (Left):   address is the most significant byte  */  
                         /*  For R (Right):  address is the least significant byte  */  
                         addr = cpu->cd.mips.gpr[rs] + imm;  
   
                         is_left = 0;  
                         if (hi6 == HI6_SWL || hi6 == HI6_LWL ||  
                             hi6 == HI6_SDL || hi6 == HI6_LDL)  
                                 is_left = 1;  
   
                         wlen = 0; st = 0;  
                         signd = 0;  
                         if (hi6 == HI6_LWL || hi6 == HI6_LWR)  
                                 signd = 1;  
   
                         if (hi6 == HI6_LWL || hi6 == HI6_LWR)   { wlen = 4; st = 0; }  
                         if (hi6 == HI6_SWL || hi6 == HI6_SWR)   { wlen = 4; st = 1; }  
                         if (hi6 == HI6_LDL || hi6 == HI6_LDR)   { wlen = 8; st = 0; }  
                         if (hi6 == HI6_SDL || hi6 == HI6_SDR)   { wlen = 8; st = 1; }  
   
                         dir = 1;                /*  big endian, Left  */  
                         reg_dir = -1;  
                         reg_ofs = wlen - 1;     /*  byte offset in the register  */  
                         if (!is_left) {  
                                 dir = -dir;  
                                 reg_ofs = 0;  
                                 reg_dir = 1;  
                         }  
                         if (cpu->byte_order == EMUL_LITTLE_ENDIAN)  
                                 dir = -dir;  
   
                         result_value = cpu->cd.mips.gpr[rt];  
   
                         if (st) {  
                                 /*  Store:  */  
                                 uint64_t aligned_addr = addr & ~(wlen-1);  
                                 unsigned char aligned_word[8];  
                                 uint64_t oldpc = cpu->pc;  
                                 /*  
                                  *  NOTE (this is ugly): The memory_rw()  
                                  *  call generates a TLBL exception, if there  
                                  *  is a tlb refill exception. However, since  
                                  *  this is a Store, the exception is converted  
                                  *  to a TLBS:  
                                  */  
                                 int ok = cpu->memory_rw(cpu, cpu->mem,  
                                     aligned_addr, &aligned_word[0], wlen,  
                                     MEM_READ, CACHE_DATA);  
                                 if (!ok) {  
                                         if (cpu->pc != oldpc) {  
                                                 cp0->reg[COP0_CAUSE] &= ~CAUSE_EXCCODE_MASK;  
                                                 cp0->reg[COP0_CAUSE] |= (EXCEPTION_TLBS << CAUSE_EXCCODE_SHIFT);  
                                         }  
                                         return 1;  
                                 }  
   
                                 for (i=0; i<wlen; i++) {  
                                         tmpaddr = addr + i*dir;  
                                         /*  Have we moved into another word/dword? Then stop:  */  
                                         if ( (tmpaddr & ~(wlen-1)) != (addr & ~(wlen-1)) )  
                                                 break;  
   
                                         /*  debug("unaligned byte at %016llx, reg_ofs=%i reg=0x%016llx\n",  
                                             tmpaddr, reg_ofs, (long long)result_value);  */  
   
                                         /*  Store one byte:  */  
                                         aligned_word[tmpaddr & (wlen-1)] = (result_value >> (reg_ofs * 8)) & 255;  
   
                                         reg_ofs += reg_dir;  
                                 }  
   
                                 ok = cpu->memory_rw(cpu, cpu->mem,  
                                     aligned_addr, &aligned_word[0], wlen,  
                                     MEM_WRITE, CACHE_DATA);  
                                 if (!ok)  
                                         return 1;  
                         } else {  
                                 /*  Load:  */  
                                 uint64_t aligned_addr = addr & ~(wlen-1);  
                                 unsigned char aligned_word[8], databyte;  
                                 int ok = cpu->memory_rw(cpu, cpu->mem,  
                                     aligned_addr, &aligned_word[0], wlen,  
                                     MEM_READ, CACHE_DATA);  
                                 if (!ok)  
                                         return 1;  
   
                                 for (i=0; i<wlen; i++) {  
                                         tmpaddr = addr + i*dir;  
                                         /*  Have we moved into another word/dword? Then stop:  */  
                                         if ( (tmpaddr & ~(wlen-1)) != (addr & ~(wlen-1)) )  
                                                 break;  
   
                                         /*  debug("unaligned byte at %016llx, reg_ofs=%i reg=0x%016llx\n",  
                                             tmpaddr, reg_ofs, (long long)result_value);  */  
   
                                         /*  Load one byte:  */  
                                         databyte = aligned_word[tmpaddr & (wlen-1)];  
                                         result_value &= ~((uint64_t)0xff << (reg_ofs * 8));  
                                         result_value |= (uint64_t)databyte << (reg_ofs * 8);  
   
                                         reg_ofs += reg_dir;  
                                 }  
   
                                 if (rt != 0)  
                                         cpu->cd.mips.gpr[rt] = result_value;  
                         }  
   
                         /*  Sign extend for 32-bit load lefts:  */  
                         if (!st && signd && wlen == 4) {  
                                 cpu->cd.mips.gpr[rt] &= 0xffffffffULL;  
                                 if (cpu->cd.mips.gpr[rt] & 0x80000000ULL)  
                                         cpu->cd.mips.gpr[rt] |= 0xffffffff00000000ULL;  
                         }  
   
                         if (instruction_trace_cached) {  
                                 char *t;  
                                 switch (wlen) {  
                                 case 2:         t = "0x%04llx"; break;  
                                 case 4:         t = "0x%08llx"; break;  
                                 case 8:         t = "0x%016llx"; break;  
                                 default:        t = "0x%02llx";  
                                 }  
                                 debug(t, (long long)cpu->cd.mips.gpr[rt]);  
                                 debug("]\n");  
                         }  
   
                         return 1;  
                 }  
                 return 1;  
         case HI6_REGIMM:  
                 regimm5 = instr[2] & 0x1f;  
   
                 if (show_opcode_statistics)  
                         cpu->cd.mips.stats__regimm[regimm5] ++;  
   
                 switch (regimm5) {  
                 case REGIMM_BLTZ:  
                 case REGIMM_BGEZ:  
                 case REGIMM_BLTZL:  
                 case REGIMM_BGEZL:  
                 case REGIMM_BLTZAL:  
                 case REGIMM_BLTZALL:  
                 case REGIMM_BGEZAL:  
                 case REGIMM_BGEZALL:  
                         rs = ((instr[3] & 3) << 3) + ((instr[2] >> 5) & 7);  
                         imm = (instr[1] << 8) + instr[0];  
                         if (imm >= 32768)               /*  signed 16-bit  */  
                                 imm -= 65536;  
   
                         cond = and_link = likely = 0;  
   
                         switch (regimm5) {  
                         case REGIMM_BLTZL:      likely = 1;  
                         case REGIMM_BLTZ:       cond = (cpu->cd.mips.gpr[rs] & ((uint64_t)1 << 63)) != 0;  
                                                 break;  
                         case REGIMM_BGEZL:      likely = 1;  
                         case REGIMM_BGEZ:       cond = (cpu->cd.mips.gpr[rs] & ((uint64_t)1 << 63)) == 0;  
                                                 break;  
   
                         case REGIMM_BLTZALL:    likely = 1;  
                         case REGIMM_BLTZAL:     and_link = 1;  
                                                 cond = (cpu->cd.mips.gpr[rs] & ((uint64_t)1 << 63)) != 0;  
                                                 break;  
                         case REGIMM_BGEZALL:    likely = 1;  
                         case REGIMM_BGEZAL:     and_link = 1;  
                                                 cond = (cpu->cd.mips.gpr[rs] & ((uint64_t)1 << 63)) == 0;  
                                                 break;  
                         }  
   
                         if (and_link)  
                                 cpu->cd.mips.gpr[31] = cached_pc + 4;  
   
                         if (cond) {  
                                 cpu->cd.mips.delay_slot = TO_BE_DELAYED;  
                                 cpu->cd.mips.delay_jmpaddr = cached_pc + (imm << 2);  
                         } else {  
                                 if (likely)  
                                         cpu->cd.mips.nullify_next = 1;          /*  nullify delay slot  */  
                         }  
   
                         return 1;  
                 default:  
                         if (!instruction_trace_cached) {  
                                 fatal("cpu%i @ %016llx: %02x%02x%02x%02x%s\t",  
                                     cpu->cpu_id, (long long)cpu->cd.mips.pc_last,  
                                     instr[3], instr[2], instr[1], instr[0], cpu_flags(cpu));  
                         }  
                         fatal("unimplemented regimm5 = 0x%02x\n", regimm5);  
                         cpu->running = 0;  
                         return 1;  
                 }  
                 /*  NOT REACHED  */  
         case HI6_J:  
         case HI6_JAL:  
                 if (cpu->cd.mips.delay_slot) {  
                         fatal("j/jal: jump inside a jump's delay slot, or similar. TODO\n");  
                         cpu->running = 0;  
                         return 1;  
                 }  
                 imm = ((instr[3] & 3) << 24) + (instr[2] << 16) + (instr[1] << 8) + instr[0];  
                 imm <<= 2;  
   
                 if (hi6 == HI6_JAL)  
                         cpu->cd.mips.gpr[31] = cached_pc + 4;           /*  pc already increased by 4 earlier  */  
   
                 addr = cached_pc & ~((1 << 28) - 1);  
                 addr |= imm;  
   
                 cpu->cd.mips.delay_slot = TO_BE_DELAYED;  
                 cpu->cd.mips.delay_jmpaddr = addr;  
   
                 if (cpu->machine->show_trace_tree && hi6 == HI6_JAL) {  
                         cpu->cd.mips.show_trace_delay = 2;  
                         cpu->cd.mips.show_trace_addr = addr;  
                 }  
   
                 return 1;  
         case HI6_COP0:  
         case HI6_COP1:  
         case HI6_COP2:  
         case HI6_COP3:  
                 imm = (instr[3] << 24) + (instr[2] << 16) + (instr[1] << 8) + instr[0];  
                 imm &= ((1 << 26) - 1);  
   
                 cpnr = 0;  
                 if (hi6 == HI6_COP0)    cpnr = 0;  
                 if (hi6 == HI6_COP1)    cpnr = 1;  
                 if (hi6 == HI6_COP2)    cpnr = 2;  
                 if (hi6 == HI6_COP3)    cpnr = 3;  
   
                 /*  
                  *  If there is no coprocessor nr cpnr, or we are running in  
                  *  userland and the coprocessor is not marked as Useable in  
                  *  the status register of CP0, then we get an exception.  
                  *  
                  *  An exception (hehe) to this rule is that the kernel should  
                  *  always be able to access CP0.  
                  */  
                 /*  Set tmp = 1 if we're in user mode.  */  
                 tmp = 0;  
                 switch (cpu->cd.mips.cpu_type.exc_model) {  
                 case EXC3K:  
                         /*  
                          *  NOTE: If the KU bit is checked, Linux crashes.  
                          *  It is the PC that counts.  TODO: Check whether  
                          *  this is true or not for R4000 as well.  
                          */  
                         if (cached_pc <= 0x7fffffff) /* if (cp0->reg[COP0_STATUS] & MIPS1_SR_KU_CUR) */  
                                 tmp = 1;  
                         break;  
                 default:  
                         /*  R4000 etc:  (TODO: How about supervisor mode?)  */  
                         if (((cp0->reg[COP0_STATUS] & STATUS_KSU_MASK) >> STATUS_KSU_SHIFT) != KSU_KERNEL)  
                                 tmp = 1;  
                         if (cp0->reg[COP0_STATUS] & STATUS_ERL)  
                                 tmp = 0;  
                         if (cp0->reg[COP0_STATUS] & STATUS_EXL)  
                                 tmp = 0;  
                         break;  
                 }  
                 if (cpu->cd.mips.coproc[cpnr] == NULL ||  
                     (tmp && !(cp0->reg[COP0_STATUS] & ((1 << cpnr) << STATUS_CU_SHIFT))) ||  
                     (!tmp && cpnr >= 1 && !(cp0->reg[COP0_STATUS] & ((1 << cpnr) << STATUS_CU_SHIFT)))  
                     ) {  
                         if (instruction_trace_cached)  
                                 debug("cop%i\t0x%08x => coprocessor unusable\n", cpnr, (int)imm);  
                         mips_cpu_exception(cpu, EXCEPTION_CPU, 0, 0, cpnr, 0, 0, 0);  
                 } else {  
                         /*  
                          *  Execute the coprocessor function. The  
                          *  coproc_function code outputs instruction  
                          *  trace, if necessary.  
                          */  
                         coproc_function(cpu, cpu->cd.mips.coproc[cpnr],  
                             cpnr, imm, 0, 1);  
                 }  
                 return 1;  
         case HI6_CACHE:  
                 rt   = ((instr[3] & 3) << 3) + (instr[2] >> 5); /*  base  */  
                 copz = instr[2] & 31;  
                 imm  = (instr[1] << 8) + instr[0];  
   
                 cache_op    = copz >> 2;  
                 which_cache = copz & 3;  
   
                 /*  
                  *  TODO:  The cache instruction is implementation dependant.  
                  */  
   
                 /*  
                  *  Clear the LLbit (at least on R10000):  
                  *  TODO: How about R4000?  
                  */  
                 cpu->cd.mips.rmw = 0;  
   
                 return 1;  
         case HI6_SPECIAL2:  
                 special6 = instr[0] & 0x3f;  
   
                 if (show_opcode_statistics)  
                         cpu->cd.mips.stats__special2[special6] ++;  
   
                 instrword = (instr[3] << 24) + (instr[2] << 16) + (instr[1] << 8) + instr[0];  
   
                 rs = ((instr[3] & 3) << 3) + ((instr[2] >> 5) & 7);  
                 rt = instr[2] & 31;  
                 rd = (instr[1] >> 3) & 31;  
   
                 /*  printf("special2 %08x  rs=0x%02x rt=0x%02x rd=0x%02x\n", instrword, rs,rt,rd);  */  
   
                 /*  
                  *  Many of these can be found in the R5000 docs, or figured out  
                  *  by studying binutils source code for MIPS instructions.  
                  */  
   
                 if ((instrword & 0xfc0007ffULL) == 0x70000000) {  
                         {  
                                 int32_t a, b;  
                                 int64_t c;  
                                 a = (int32_t)cpu->cd.mips.gpr[rs];  
                                 b = (int32_t)cpu->cd.mips.gpr[rt];  
                                 c = a * b;  
                                 c += (cpu->cd.mips.lo & 0xffffffffULL)  
                                     + (cpu->cd.mips.hi << 32);  
                                 cpu->cd.mips.lo = (int64_t)((int32_t)c);  
                                 cpu->cd.mips.hi = (int64_t)((int32_t)(c >> 32));  
   
                                 /*  
                                  *  The R5000 manual says that rd should be all zeros,  
                                  *  but it isn't on R5900.   I'm just guessing here that  
                                  *  it stores the value in register rd, in addition to hi/lo.  
                                  *  TODO  
                                  */  
                                 if (rd != 0)  
                                         cpu->cd.mips.gpr[rd] = cpu->cd.mips.lo;  
                         }  
                 } else if ((instrword & 0xffff07ffULL) == 0x70000209  
                     || (instrword & 0xffff07ffULL) == 0x70000249) {  
                         /*  
                          *  This is just a guess for R5900, I've not found any docs on this one yet.  
                          *  
                          *      pmfhi/pmflo rd  
                          *  
                          *  If the lowest 8 bits of the instruction word are 0x09, it's a pmfhi.  
                          *  If the lowest bits are 0x49, it's a pmflo.  
                          *  
                          *  A wild guess is that this is a 128-bit version of mfhi/mflo.  
                          *  For now, this is implemented as 64-bit only.  (TODO)  
                          */  
                         if (instr[0] == 0x49) {  
                                 cpu->cd.mips.gpr[rd] = cpu->cd.mips.lo;  
                         } else {  
                                 cpu->cd.mips.gpr[rd] = cpu->cd.mips.hi;  
                         }  
                 } else if ((instrword & 0xfc1fffff) == 0x70000269 || (instrword & 0xfc1fffff) == 0x70000229) {  
                         /*  
                          *  This is just a guess for R5900, I've not found any docs on this one yet.  
                          *  
                          *      pmthi/pmtlo rs          (pmtlo = 269, pmthi = 229)  
                          *  
                          *  A wild guess is that this is a 128-bit version of mthi/mtlo.  
                          *  For now, this is implemented as 64-bit only.  (TODO)  
                          */  
                         if (instr[0] == 0x69) {  
                                 cpu->cd.mips.lo = cpu->cd.mips.gpr[rs];  
                         } else {  
                                 cpu->cd.mips.hi = cpu->cd.mips.gpr[rs];  
                         }  
                 } else if ((instrword & 0xfc0007ff) == 0x700004a9) {  
                         /*  
                          *  This is just a guess for R5900, I've not found any docs on this one yet.  
                          *  
                          *      por dst,src,src2  ==> rs=src rt=src2 rd=dst  
                          *  
                          *  A wild guess is that this is a 128-bit "or" between two registers.  
                          *  For now, let's just or using 64-bits.  (TODO)  
                          */  
                         cpu->cd.mips.gpr[rd] = cpu->cd.mips.gpr[rs] | cpu->cd.mips.gpr[rt];  
                 } else if ((instrword & 0xfc0007ff) == 0x70000488) {  
                         /*  
                          *  R5900 "undocumented" pextlw. TODO: find out if this is correct.  
                          *  It seems that this instruction is used to combine two 32-bit  
                          *  words into a 64-bit dword, typically before a sd (store dword).  
                          */  
                         cpu->cd.mips.gpr[rd] =  
                             ((cpu->cd.mips.gpr[rs] & 0xffffffffULL) << 32)              /*  TODO: switch rt and rs?  */  
                             | (cpu->cd.mips.gpr[rt] & 0xffffffffULL);  
                 } else if (special6 == SPECIAL2_MUL) {  
                         cpu->cd.mips.gpr[rd] = (int64_t)cpu->cd.mips.gpr[rt] *  
                             (int64_t)cpu->cd.mips.gpr[rs];  
                 } else if (special6 == SPECIAL2_CLZ) {  
                         /*  clz: count leading zeroes  */  
                         int i, n=0;  
                         for (i=31; i>=0; i--) {  
                                 if (cpu->cd.mips.gpr[rs] & ((uint32_t)1 << i))  
                                         break;  
                                 else  
                                         n++;  
                         }  
                         cpu->cd.mips.gpr[rd] = n;  
                 } else if (special6 == SPECIAL2_CLO) {  
                         /*  clo: count leading ones  */  
                         int i, n=0;  
                         for (i=31; i>=0; i--) {  
                                 if (cpu->cd.mips.gpr[rs] & ((uint32_t)1 << i))  
                                         n++;  
                                 else  
                                         break;  
                         }  
                         cpu->cd.mips.gpr[rd] = n;  
                 } else if (special6 == SPECIAL2_DCLZ) {  
                         /*  dclz: count leading zeroes  */  
                         int i, n=0;  
                         for (i=63; i>=0; i--) {  
                                 if (cpu->cd.mips.gpr[rs] & ((uint64_t)1 << i))  
                                         break;  
                                 else  
                                         n++;  
                         }  
                         cpu->cd.mips.gpr[rd] = n;  
                 } else if (special6 == SPECIAL2_DCLO) {  
                         /*  dclo: count leading ones  */  
                         int i, n=0;  
                         for (i=63; i>=0; i--) {  
                                 if (cpu->cd.mips.gpr[rs] & ((uint64_t)1 << i))  
                                         n++;  
                                 else  
                                         break;  
                         }  
                         cpu->cd.mips.gpr[rd] = n;  
                 } else {  
                         if (!instruction_trace_cached) {  
                                 fatal("cpu%i @ %016llx: %02x%02x%02x%02x%s\t",  
                                     cpu->cpu_id, (long long)cpu->cd.mips.pc_last,  
                                     instr[3], instr[2], instr[1], instr[0], cpu_flags(cpu));  
                         }  
                         fatal("unimplemented special_2 = 0x%02x, rs=0x%02x rt=0x%02x rd=0x%02x\n",  
                             special6, rs, rt, rd);  
                         cpu->running = 0;  
                         return 1;  
                 }  
                 return 1;  
         default:  
                 if (!instruction_trace_cached) {  
                         fatal("cpu%i @ %016llx: %02x%02x%02x%02x%s\t",  
                             cpu->cpu_id, (long long)cpu->cd.mips.pc_last,  
                             instr[3], instr[2], instr[1], instr[0], cpu_flags(cpu));  
                 }  
                 fatal("unimplemented hi6 = 0x%02x\n", hi6);  
                 cpu->running = 0;  
                 return 1;  
         }  
   
         /*  NOTREACHED  */  
 }  
   
   
 #define CPU_RUN         mips_cpu_run  
 #define CPU_RUN_MIPS  
 #define CPU_RINSTR      mips_cpu_run_instr  
 #include "cpu_run.c"  
 #undef CPU_RINSTR  
 #undef CPU_RUN_MIPS  
 #undef CPU_RUN  
   
   
 /*  
  *  mips_cpu_dumpinfo():  
  *  
  *  Debug dump of MIPS-specific CPU data for specific CPU.  
  */  
 void mips_cpu_dumpinfo(struct cpu *cpu)  
 {  
         int iadd = 4;  
         struct mips_cpu_type_def *ct = &cpu->cd.mips.cpu_type;  
   
         debug_indentation(iadd);  
   
         debug("\n%i-bit %s (MIPS",  
             cpu->is_32bit? 32 : 64,  
             cpu->byte_order == EMUL_BIG_ENDIAN? "BE" : "LE");  
   
         switch (ct->isa_level) {  
         case 1: debug(" ISA I"); break;  
         case 2: debug(" ISA II"); break;  
         case 3: debug(" ISA III"); break;  
         case 4: debug(" ISA IV"); break;  
         case 5: debug(" ISA V"); break;  
         case 32:  
         case 64:debug("%i", ct->isa_level); break;  
         default:debug(" ISA level %i", ct->isa_level);  
         }  
   
         debug("), ");  
         if (ct->nr_of_tlb_entries)  
                 debug("%i TLB entries", ct->nr_of_tlb_entries);  
         else  
                 debug("no TLB");  
         debug("\n");  
   
         if (ct->picache) {  
                 debug("L1 I-cache: %i KB", (1 << ct->picache) / 1024);  
                 if (ct->pilinesize)  
                         debug(", %i bytes per line", 1 << ct->pilinesize);  
                 if (ct->piways > 1)  
                         debug(", %i-way", ct->piways);  
                 else  
                         debug(", direct-mapped");  
                 debug("\n");  
         }  
   
         if (ct->pdcache) {  
                 debug("L1 D-cache: %i KB", (1 << ct->pdcache) / 1024);  
                 if (ct->pdlinesize)  
                         debug(", %i bytes per line", 1 << ct->pdlinesize);  
                 if (ct->pdways > 1)  
                         debug(", %i-way", ct->pdways);  
                 else  
                         debug(", direct-mapped");  
                 debug("\n");  
         }  
   
         if (ct->scache) {  
                 int kb = (1 << ct->scache) / 1024;  
                 debug("L2 cache: %i %s",  
                     kb >= 1024? kb / 1024 : kb, kb >= 1024? "MB":"KB");  
                 if (ct->slinesize)  
                         debug(", %i bytes per line", 1 << ct->slinesize);  
                 if (ct->sways > 1)  
                         debug(", %i-way", ct->sways);  
                 else  
                         debug(", direct-mapped");  
                 debug("\n");  
2130          }          }
   
         debug_indentation(-iadd);  
2131  }  }
2132    
2133    
2134  /*  #include "memory_mips.c"
  *  mips_cpu_list_available_types():  
  *  
  *  Print a list of available MIPS CPU types.  
  */  
 void mips_cpu_list_available_types(void)  
 {  
         int i, j;  
         struct mips_cpu_type_def cpu_type_defs[] = MIPS_CPU_TYPE_DEFS;  
   
         i = 0;  
         while (cpu_type_defs[i].name != NULL) {  
                 debug("%s", cpu_type_defs[i].name);  
                 for (j=10 - strlen(cpu_type_defs[i].name); j>0; j--)  
                         debug(" ");  
                 i++;  
                 if ((i % 6) == 0 || cpu_type_defs[i].name == NULL)  
                         debug("\n");  
         }  
 }  
   
2135    
 CPU_FAMILY_INIT(mips,"MIPS")  
2136    
2137    #include "tmp_mips_tail.c"
2138    
 #endif  /*  ENABLE_MIPS  */  
Legend:
Removed from v.18  
changed lines
  Added in v.32
  ViewVC Help
Powered by ViewVC 1.1.26