source/mupen64plus-core/src/debugger/dbg_memory.c

   1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
   2  *   Mupen64plus - dbg_memory.c                                            *
   3  *   Mupen64Plus homepage: http://code.google.com/p/mupen64plus/           *
   4  *   Copyright (C) 2008 DarkJeztr                                          *
   5  *   Copyright (C) 2002 Blight                                             *
   6  *                                                                         *
   7  *   This program is free software; you can redistribute it and/or modify  *
   8  *   it under the terms of the GNU General Public License as published by  *
   9  *   the Free Software Foundation; either version 2 of the License, or     *
  10  *   (at your option) any later version.                                   *
  11  *                                                                         *
  12  *   This program is distributed in the hope that it will be useful,       *
  13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  15  *   GNU General Public License for more details.                          *
  16  *                                                                         *
  17  *   You should have received a copy of the GNU General Public License     *
  18  *   along with this program; if not, write to the                         *
  19  *   Free Software Foundation, Inc.,                                       *
  20  *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.          *
  21  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  22
  23 #include <string.h>
  24
  25 #include "dbg_types.h"
  26 #include "dbg_memory.h"
  27 #include "dbg_breakpoints.h"
  28
  29 #include "api/m64p_types.h"
  30 #include "api/callbacks.h"
  31 #include "memory/memory.h"
  32 #include "r4300/r4300.h"
  33 #include "r4300/ops.h"
  34 #include "main/rom.h"
  35
  36 /* Following are the breakpoint functions for memory access calls.  See debugger/memory.h
  37  * These macros generate the memory breakpoint function calls.*/
  38 MEMBREAKALL_local(nothing);
  39 MEMBREAKALL_local(nomem);
  40 MEMBREAKALL(rdram);
  41 MEMBREAKALL(rdramFB);
  42 MEMBREAKALL_local(rdramreg);
  43 MEMBREAKALL_local(rsp_mem);
  44 MEMBREAKALL_local(rsp_reg);
  45 MEMBREAKALL_local(rsp);
  46 MEMBREAKALL_local(dp);
  47 MEMBREAKALL_local(dps);
  48 MEMBREAKALL_local(mi);
  49 MEMBREAKALL_local(vi);
  50 MEMBREAKALL_local(ai);
  51 MEMBREAKALL_local(pi);
  52 MEMBREAKALL_local(ri);
  53 MEMBREAKALL_local(si);
  54 MEMBREAKALL_local(pif);
  55
  56 static MEMBREAKREAD(read_flashram_status, 4);
  57 static MEMBREAKREAD(read_flashram_statusb, 1);
  58 static MEMBREAKREAD(read_flashram_statush, 2);
  59 static MEMBREAKREAD(read_flashram_statusd, 8);
  60 static MEMBREAKWRITE(write_flashram_dummy, 4);
  61 static MEMBREAKWRITE(write_flashram_dummyb, 1);
  62 static MEMBREAKWRITE(write_flashram_dummyh, 2);
  63 static MEMBREAKWRITE(write_flashram_dummyd, 8);
  64 static MEMBREAKWRITE(write_flashram_command, 4);
  65 static MEMBREAKWRITE(write_flashram_commandb, 1);
  66 static MEMBREAKWRITE(write_flashram_commandh, 2);
  67 static MEMBREAKWRITE(write_flashram_commandd, 8);
  68
  69 static MEMBREAKREAD(read_rom, 4);
  70 static MEMBREAKREAD(read_romb, 1);
  71 static MEMBREAKREAD(read_romh, 2);
  72 static MEMBREAKREAD(read_romd, 8);
  73
  74 static MEMBREAKWRITE(write_rom, 8);
  75
  76 #if !defined(NO_ASM) && (defined(__i386__) || defined(__x86_64__))
  77
  78 #include <dis-asm.h>
  79 #include <stdarg.h>
  80
  81 static int  lines_recompiled;
  82 static uint32 addr_recompiled;
  83 static int  num_decoded;
  84
  85 static char opcode_recompiled[564][MAX_DISASSEMBLY];
  86 static char args_recompiled[564][MAX_DISASSEMBLY*4];
  87 static void *opaddr_recompiled[564];
  88
  89 static disassemble_info dis_info;
  90
  91 #define CHECK_MEM(address) \
  92    if (!invalid_code[(address) >> 12] && blocks[(address) >> 12]->block[((address) & 0xFFF) / 4].ops != current_instruction_table.NOTCOMPILED) \
  93      invalid_code[(address) >> 12] = 1;
  94
  95 static void process_opcode_out(void *strm, const char *fmt, ...){
  96   va_list ap;
  97   va_start(ap, fmt);
  98   char *arg;
  99   char buff[256];
 100
 101   if(num_decoded==0)
 102     {
 103       if(strcmp(fmt,"%s")==0)
 104     {
 105       arg = va_arg(ap, char*);
 106       strcpy(opcode_recompiled[lines_recompiled],arg);
 107     }
 108       else
 109     strcpy(opcode_recompiled[lines_recompiled],"OPCODE-X");
 110       num_decoded++;
 111       *(args_recompiled[lines_recompiled])=0;
 112     }
 113   else
 114     {
 115       vsprintf(buff, fmt, ap);
 116       sprintf(args_recompiled[lines_recompiled],"%s%s",
 117           args_recompiled[lines_recompiled],buff);
 118     }
 119   va_end(ap);
 120 }
 121
 122 // Callback function that will be called by libopcodes to read the
 123 // bytes to disassemble ('read_memory_func' member of 'disassemble_info').
 124 static int read_memory_func(bfd_vma memaddr, bfd_byte *myaddr,
 125                             unsigned int length, disassemble_info *info) {
 126   char* from = (char*)(long)(memaddr);
 127   char* to =   (char*)myaddr;
 128
 129   while (length-- != 0) {
 130     *to++ = *from++;
 131   }
 132   return (0);
 133 }
 134
 135 void init_host_disassembler(void){
 136
 137
 138   INIT_DISASSEMBLE_INFO(dis_info, stderr, process_opcode_out);
 139   dis_info.fprintf_func = (fprintf_ftype) process_opcode_out;
 140   dis_info.stream = stderr;
 141   dis_info.bytes_per_line=1;
 142   dis_info.endian = 1;
 143   dis_info.mach = bfd_mach_i386_i8086;
 144   dis_info.disassembler_options = (char*) "i386,suffix";
 145   dis_info.read_memory_func = read_memory_func;
 146 }
 147
 148 static void decode_recompiled(uint32 addr)
 149 {
 150     unsigned char *assemb, *end_addr;
 151
 152     lines_recompiled=0;
 153
 154     if(blocks[addr>>12] == NULL)
 155         return;
 156
 157     if(blocks[addr>>12]->block[(addr&0xFFF)/4].ops == current_instruction_table.NOTCOMPILED)
 158     //      recompile_block((int *) SP_DMEM, blocks[addr>>12], addr);
 159       {
 160     strcpy(opcode_recompiled[0],"INVLD");
 161     strcpy(args_recompiled[0],"NOTCOMPILED");
 162     opaddr_recompiled[0] = (void *) 0;
 163     addr_recompiled=0;
 164     lines_recompiled++;
 165     return;
 166       }
 167
 168     assemb = (blocks[addr>>12]->code) +
 169       (blocks[addr>>12]->block[(addr&0xFFF)/4].local_addr);
 170
 171     end_addr = blocks[addr>>12]->code;
 172
 173     if( (addr & 0xFFF) >= 0xFFC)
 174         end_addr += blocks[addr>>12]->code_length;
 175     else
 176         end_addr += blocks[addr>>12]->block[(addr&0xFFF)/4+1].local_addr;
 177
 178     while(assemb < end_addr)
 179       {
 180         opaddr_recompiled[lines_recompiled] = assemb;
 181         num_decoded=0;
 182
 183         assemb += print_insn_i386((bfd_vma)(long) assemb, &dis_info);
 184
 185         lines_recompiled++;
 186       }
 187
 188     addr_recompiled = addr;
 189 }
 190
 191 char* get_recompiled_opcode(uint32 addr, int index)
 192 {
 193     if(addr != addr_recompiled)
 194         decode_recompiled(addr);
 195
 196     if(index < lines_recompiled)
 197         return opcode_recompiled[index];
 198     else
 199         return NULL;
 200 }
 201
 202 char* get_recompiled_args(uint32 addr, int index)
 203 {
 204     if(addr != addr_recompiled)
 205         decode_recompiled(addr);
 206
 207     if(index < lines_recompiled)
 208         return args_recompiled[index];
 209     else
 210         return NULL;
 211 }
 212
 213 void * get_recompiled_addr(uint32 addr, int index)
 214 {
 215     if(addr != addr_recompiled)
 216         decode_recompiled(addr);
 217
 218     if(index < lines_recompiled)
 219         return opaddr_recompiled[index];
 220     else
 221         return 0;
 222 }
 223
 224 int get_num_recompiled(uint32 addr)
 225 {
 226     if(addr != addr_recompiled)
 227         decode_recompiled(addr);
 228
 229     return lines_recompiled;
 230 }
 231
 232 int get_has_recompiled(uint32 addr)
 233 {
 234     unsigned char *assemb, *end_addr;
 235
 236     if(r4300emu != CORE_DYNAREC || blocks[addr>>12] == NULL)
 237         return FALSE;
 238
 239     assemb = (blocks[addr>>12]->code) +
 240       (blocks[addr>>12]->block[(addr&0xFFF)/4].local_addr);
 241
 242     end_addr = blocks[addr>>12]->code;
 243
 244     if( (addr & 0xFFF) >= 0xFFC)
 245         end_addr += blocks[addr>>12]->code_length;
 246     else
 247         end_addr += blocks[addr>>12]->block[(addr&0xFFF)/4+1].local_addr;
 248     if(assemb==end_addr)
 249       return FALSE;
 250
 251     return TRUE;
 252 }
 253
 254 #else
 255
 256 #define CHECK_MEM(address)
 257
 258 int get_num_recompiled(uint32 addr)
 259 {
 260     return 0;
 261 }
 262
 263 char* get_recompiled_opcode(uint32 addr, int index)
 264 {
 265     return NULL;
 266 }
 267
 268 char* get_recompiled_args(uint32 addr, int index)
 269 {
 270     return NULL;
 271 }
 272
 273 void * get_recompiled_addr(uint32 addr, int index)
 274 {
 275     return 0;
 276 }
 277
 278 int get_has_recompiled(uint32 addr)
 279 {
 280     return 0;
 281 }
 282
 283 void init_host_disassembler(void)
 284 {
 285
 286 }
 287
 288 #endif
 289
 290 uint64 read_memory_64(uint32 addr)
 291 {
 292     return ((uint64)read_memory_32(addr) << 32) | (uint64)read_memory_32(addr + 4);
 293 }
 294
 295 uint64 read_memory_64_unaligned(uint32 addr)
 296 {
 297     uint64 w[2];
 298
 299     w[0] = read_memory_32_unaligned(addr);
 300     w[1] = read_memory_32_unaligned(addr + 4);
 301     return (w[0] << 32) | w[1];
 302 }
 303
 304 void write_memory_64(uint32 addr, uint64 value)
 305 {
 306     write_memory_32(addr, (uint32) (value >> 32));
 307     write_memory_32(addr + 4, (uint32) (value & 0xFFFFFFFF));
 308 }
 309
 310 void write_memory_64_unaligned(uint32 addr, uint64 value)
 311 {
 312     write_memory_32_unaligned(addr, (uint32) (value >> 32));
 313     write_memory_32_unaligned(addr + 4, (uint32) (value & 0xFFFFFFFF));
 314 }
 315
 316 uint32 read_memory_32(uint32 addr){
 317   const uint32 addrlow = (addr & 0xFFFF);
 318
 319   switch(get_memory_type(addr))
 320     {
 321     case M64P_MEM_NOMEM:
 322       if(tlb_LUT_r[addr>>12])
 323         return read_memory_32((tlb_LUT_r[addr>>12]&0xFFFFF000)|(addr&0xFFF));
 324       return M64P_MEM_INVALID;
 325     case M64P_MEM_RDRAM:
 326       return *((uint32 *)(rdramb + (addr & 0xFFFFFF)));
 327     case M64P_MEM_RSPMEM:
 328       if ((addr & 0xFFFF) < 0x1000)
 329         return *((uint32 *)(SP_DMEMb + (addr&0xFFF)));
 330       else if ((addr&0xFFFF) < 0x2000)
 331         return *((uint32 *)(SP_IMEMb + (addr&0xFFF)));
 332       else
 333         return M64P_MEM_INVALID;
 334     case M64P_MEM_ROM:
 335       return *((uint32 *)(rom + (addr & 0x03FFFFFF)));
 336     case M64P_MEM_RDRAMREG:
 337       if (addrlow < 0x28)
 338         return *(readrdramreg[addrlow&0xfffc]);
 339       break;
 340     case M64P_MEM_RSPREG:
 341       if (addrlow < 0x20)
 342         return *(readrspreg[addrlow&0xfffc]);
 343       break;
 344     case M64P_MEM_RSP:
 345       if (addrlow < 0x8)
 346         return *(readrsp[addrlow&0xfffc]);
 347       break;
 348     case M64P_MEM_DP:
 349       if (addrlow < 0x20)
 350         return *(readdp[addrlow&0xfffc]);
 351       break;
 352     case M64P_MEM_DPS:
 353       if (addrlow < 0x10)
 354         return *(readdps[addrlow&0xfffc]);
 355       break;
 356     case M64P_MEM_VI:
 357       if (addrlow < 0x38)
 358         return *(readvi[addrlow&0xfffc]);
 359       break;
 360     case M64P_MEM_AI:
 361       if (addrlow < 0x18)
 362         return *(readai[addrlow&0xfffc]);
 363       break;
 364     case M64P_MEM_PI:
 365       if (addrlow < 0x34)
 366         return *(readpi[addrlow&0xfffc]);
 367       break;
 368     case M64P_MEM_RI:
 369       if (addrlow < 0x20)
 370         return *(readri[addrlow&0xfffc]);
 371       break;
 372     case M64P_MEM_SI:
 373       if (addrlow < 0x1c)
 374         return *(readsi[addrlow&0xfffc]);
 375       break;
 376     case M64P_MEM_PIF:
 377       if (addrlow >= 0x7C0 && addrlow <= 0x7FF)
 378         return sl(*((unsigned int *)(PIF_RAMb + (addrlow & 0x7FF) - 0x7C0)));
 379       break;
 380     case M64P_MEM_MI:
 381       if (addrlow < 0x10)
 382         return *(readmi[addrlow&0xfffc]);
 383       break;
 384     default:
 385       break;
 386     }
 387     return M64P_MEM_INVALID;
 388 }
 389
 390 uint32 read_memory_32_unaligned(uint32 addr)
 391 {
 392     uint8 i, b[4];
 393
 394     for(i=0; i<4; i++) b[i] = read_memory_8(addr + i);
 395     return (b[0] << 24) | (b[1] << 16) | (b[2] << 8) | b[3];
 396 }
 397
 398 void write_memory_32(uint32 addr, uint32 value){
 399   switch(get_memory_type(addr))
 400     {
 401     case M64P_MEM_RDRAM:
 402       *((uint32 *)(rdramb + (addr & 0xFFFFFF))) = value;
 403       CHECK_MEM(addr)
 404       break;
 405     }
 406 }
 407
 408 void write_memory_32_unaligned(uint32 addr, uint32 value)
 409 {
 410     write_memory_8(addr + 0, value >> 24);
 411     write_memory_8(addr + 1, (value >> 16) & 0xFF);
 412     write_memory_8(addr + 2, (value >> 8) & 0xFF);
 413     write_memory_8(addr + 3, value & 0xFF);
 414 }
 415
 416 //read_memory_16_unaligned and write_memory_16_unaligned don't exist because
 417 //read_memory_16 and write_memory_16 work unaligned already.
 418 uint16 read_memory_16(uint32 addr)
 419 {
 420     return ((uint16)read_memory_8(addr) << 8) | (uint16)read_memory_8(addr+1); //cough cough hack hack
 421 }
 422
 423 void write_memory_16(uint32 addr, uint16 value)
 424 {
 425     write_memory_8(addr, value >> 8); //this isn't much better
 426     write_memory_8(addr + 1, value & 0xFF); //then again, it works unaligned
 427 }
 428
 429 uint8 read_memory_8(uint32 addr)
 430 {
 431     uint32 word;
 432
 433     word = read_memory_32(addr & ~3);
 434     return (word >> ((3 - (addr & 3)) * 8)) & 0xFF;
 435 }
 436
 437 void write_memory_8(uint32 addr, uint8 value)
 438 {
 439     uint32 word, mask;
 440
 441     word = read_memory_32(addr & ~3);
 442     mask = 0xFF << ((3 - (addr & 3)) * 8);
 443     word = (word & ~mask) | (value << ((3 - (addr & 3)) * 8));
 444     write_memory_32(addr & ~3, word);
 445 }
 446
 447 uint32 get_memory_flags(uint32 addr)
 448 {
 449   int type=get_memory_type(addr);
 450   const uint32 addrlow = (addr & 0xFFFF);
 451   uint32 flags = 0;
 452
 453   switch(type)
 454   {
 455     case M64P_MEM_NOMEM:
 456       if(tlb_LUT_r[addr>>12])
 457         flags = M64P_MEM_FLAG_READABLE | M64P_MEM_FLAG_WRITABLE_EMUONLY;
 458       break;
 459     case M64P_MEM_NOTHING:
 460       if (((addr >> 16) == 0x8801 || (addr >> 16 == 0xA801)) && addrlow == 0)
 461         flags = M64P_MEM_FLAG_WRITABLE_EMUONLY; // for flashram command
 462       break;
 463     case M64P_MEM_RDRAM:
 464       flags = M64P_MEM_FLAG_WRITABLE;
 465     case M64P_MEM_ROM:
 466       flags |= M64P_MEM_FLAG_READABLE;
 467       break;
 468     case M64P_MEM_RDRAMREG:
 469       if (addrlow < 0x28)
 470         flags = M64P_MEM_FLAG_READABLE | M64P_MEM_FLAG_WRITABLE_EMUONLY;
 471       break;
 472     case M64P_MEM_RSPMEM:
 473       if (addrlow < 0x2000)
 474         flags = M64P_MEM_FLAG_READABLE | M64P_MEM_FLAG_WRITABLE_EMUONLY;
 475       break;
 476     case M64P_MEM_RSPREG:
 477       if (addrlow < 0x20)
 478         flags = M64P_MEM_FLAG_READABLE | M64P_MEM_FLAG_WRITABLE_EMUONLY;
 479       break;
 480     case M64P_MEM_RSP:
 481       if (addrlow < 0x8)
 482         flags = M64P_MEM_FLAG_READABLE | M64P_MEM_FLAG_WRITABLE_EMUONLY;
 483       break;
 484     case M64P_MEM_DP:
 485       if (addrlow < 0x20)
 486         flags = M64P_MEM_FLAG_READABLE | M64P_MEM_FLAG_WRITABLE_EMUONLY;
 487       break;
 488     case M64P_MEM_DPS:
 489       if (addrlow < 0x10)
 490         flags = M64P_MEM_FLAG_READABLE | M64P_MEM_FLAG_WRITABLE_EMUONLY;
 491       break;
 492     case M64P_MEM_VI:
 493       if (addrlow < 0x38)
 494         flags = M64P_MEM_FLAG_READABLE | M64P_MEM_FLAG_WRITABLE_EMUONLY;
 495       break;
 496     case M64P_MEM_AI:
 497       if (addrlow < 0x18)
 498         flags = M64P_MEM_FLAG_READABLE | M64P_MEM_FLAG_WRITABLE_EMUONLY;
 499       break;
 500     case M64P_MEM_PI:
 501       if (addrlow < 0x34)
 502         flags = M64P_MEM_FLAG_READABLE | M64P_MEM_FLAG_WRITABLE_EMUONLY;
 503       break;
 504     case M64P_MEM_RI:
 505       if (addrlow < 0x20)
 506         flags = M64P_MEM_FLAG_READABLE | M64P_MEM_FLAG_WRITABLE_EMUONLY;
 507       break;
 508     case M64P_MEM_SI:
 509       if (addrlow < 0x1c)
 510         flags = M64P_MEM_FLAG_READABLE | M64P_MEM_FLAG_WRITABLE_EMUONLY;
 511       break;
 512     case M64P_MEM_FLASHRAMSTAT:
 513       if (addrlow == 0)
 514         flags = M64P_MEM_FLAG_READABLE_EMUONLY;
 515       break;
 516     case M64P_MEM_PIF:
 517       if (addrlow >= 0x7C0 && addrlow <= 0x7FF)
 518         flags = M64P_MEM_FLAG_READABLE | M64P_MEM_FLAG_WRITABLE_EMUONLY;
 519       break;
 520     case M64P_MEM_MI:
 521       if (addrlow < 0x10)
 522         flags = M64P_MEM_FLAG_READABLE | M64P_MEM_FLAG_WRITABLE_EMUONLY;
 523       break;
 524     default:
 525       break;
 526   }
 527
 528   return flags;
 529 }
 530
 531 int get_memory_type(uint32 addr){
 532   void (*readfunc)() = readmem[addr >> 16];
 533
 534   if((readfunc == read_nomem) || (readfunc == read_nomem_break))
 535     return M64P_MEM_NOMEM;
 536   else if((readfunc == read_nothing) || (readfunc == read_nothing_break))
 537     return M64P_MEM_NOTHING;
 538   else if((readfunc == read_rdram) || (readfunc == read_rdram_break))
 539     return M64P_MEM_RDRAM;
 540   else if((readfunc == read_rdramreg) || (readfunc == read_rdramreg_break))
 541     return M64P_MEM_RDRAMREG;
 542   else if((readfunc == read_rsp_mem) || (readfunc == read_rsp_mem_break))
 543     return M64P_MEM_RSPMEM;
 544   else if((readfunc == read_rsp_reg) || (readfunc == read_rsp_reg_break))
 545     return M64P_MEM_RSPREG;
 546   else if((readfunc == read_rsp) || (readfunc == read_rsp_break))
 547     return M64P_MEM_RSP;
 548   else if((readfunc == read_dp) || (readfunc == read_dp_break))
 549     return M64P_MEM_DP;
 550   else if((readfunc == read_dps) || (readfunc == read_dps_break))
 551     return M64P_MEM_DPS;
 552   else if((readfunc == read_vi) || (readfunc == read_vi_break))
 553     return M64P_MEM_VI;
 554   else if((readfunc == read_ai) || (readfunc == read_ai_break))
 555     return M64P_MEM_AI;
 556   else if((readfunc == read_pi) || (readfunc == read_pi_break))
 557     return M64P_MEM_PI;
 558   else if((readfunc == read_ri) || (readfunc == read_ri_break))
 559     return M64P_MEM_RI;
 560   else if((readfunc == read_si) || (readfunc == read_si_break))
 561     return M64P_MEM_SI;
 562   else if((readfunc == read_flashram_status) ||
 563           (readfunc == read_flashram_status_break))
 564     return M64P_MEM_FLASHRAMSTAT;
 565   else if((readfunc == read_rom) || (readfunc == read_rom_break))
 566     return M64P_MEM_ROM;
 567   else if((readfunc == read_pif) || (readfunc == read_pif_break))
 568     return M64P_MEM_PIF;
 569   else if((readfunc == read_mi) || (readfunc == read_mi_break))
 570     return M64P_MEM_MI;
 571   else
 572     DebugMessage(M64MSG_ERROR, "Unknown memory type in debugger get_memory_type(): %p", readfunc);
 573   return M64P_MEM_NOMEM;
 574 }
 575
 576 void activate_memory_break_read(uint32 addr) {
 577     void (*readfunc)() = readmem[addr >> 16];
 578
 579     if(readfunc == read_nomem) {
 580         readmem[addr >> 16]  = read_nomem_break;
 581         readmemb[addr >> 16] = read_nomemb_break;
 582         readmemh[addr >> 16] = read_nomemh_break;
 583         readmemd[addr >> 16] = read_nomemd_break;
 584     }
 585     else if(readfunc == read_nothing) {
 586         readmem[addr >> 16]  = read_nothing_break;
 587         readmemb[addr >> 16] = read_nothingb_break;
 588         readmemh[addr >> 16] = read_nothingh_break;
 589         readmemd[addr >> 16] = read_nothingd_break;
 590     }
 591     else if(readfunc == read_rdram) {
 592         readmem[addr >> 16]  = read_rdram_break;
 593         readmemb[addr >> 16] = read_rdramb_break;
 594         readmemh[addr >> 16] = read_rdramh_break;
 595         readmemd[addr >> 16] = read_rdramd_break;
 596     }
 597     else if(readfunc == read_rdramFB) {
 598         readmem[addr >> 16]  = read_rdramFB_break;
 599         readmemb[addr >> 16] = read_rdramFBb_break;
 600         readmemh[addr >> 16] = read_rdramFBh_break;
 601         readmemd[addr >> 16] = read_rdramFBd_break;
 602     }
 603     else if(readfunc == read_rdramreg) {
 604         readmem[addr >> 16]  = read_rdramreg_break;
 605         readmemb[addr >> 16] = read_rdramregb_break;
 606         readmemh[addr >> 16] = read_rdramregh_break;
 607         readmemd[addr >> 16] = read_rdramregd_break;
 608     }
 609     else if(readfunc == read_rsp_mem) {
 610         readmem[addr >> 16]  = read_rsp_mem_break;
 611         readmemb[addr >> 16] = read_rsp_memb_break;
 612         readmemh[addr >> 16] = read_rsp_memh_break;
 613         readmemd[addr >> 16] = read_rsp_memd_break;
 614     }
 615     else if(readfunc == read_rsp_reg) {
 616         readmem[addr >> 16] = read_rsp_reg_break;
 617         readmemb[addr >> 16] = read_rsp_regh_break;
 618         readmemh[addr >> 16] = read_rsp_regb_break;
 619         readmemd[addr >> 16] = read_rsp_regd_break;
 620     }
 621     else if(readfunc == read_rsp) {
 622         readmem[addr >> 16] = read_rsp_break;
 623         readmemb[addr >> 16] = read_rsph_break;
 624         readmemh[addr >> 16] = read_rspb_break;
 625         readmemd[addr >> 16] = read_rspd_break;
 626     }
 627     else if(readfunc == read_dp) {
 628         readmem[addr >> 16] = read_dp_break;
 629         readmemb[addr >> 16] = read_dpb_break;
 630         readmemh[addr >> 16] = read_dph_break;
 631         readmemd[addr >> 16] = read_dpd_break;
 632     }
 633     else if(readfunc == read_dps) {
 634         readmem[addr >> 16] = read_dps_break;
 635         readmemb[addr >> 16] = read_dpsb_break;
 636         readmemh[addr >> 16] = read_dpsh_break;
 637         readmemd[addr >> 16] = read_dpsd_break;
 638     }
 639     else if(readfunc == read_mi) {
 640         readmem[addr >> 16] = read_mi_break;
 641         readmemb[addr >> 16] = read_mib_break;
 642         readmemh[addr >> 16] = read_mih_break;
 643         readmemd[addr >> 16] = read_mid_break;
 644     }
 645     else if(readfunc == read_vi) {
 646         readmem[addr >> 16] = read_vi_break;
 647         readmemb[addr >> 16] = read_vib_break;
 648         readmemh[addr >> 16] = read_vih_break;
 649         readmemd[addr >> 16] = read_vid_break;
 650     }
 651     else if(readfunc == read_ai) {
 652         readmem[addr >> 16] = read_ai_break;
 653         readmemb[addr >> 16] = read_aib_break;
 654         readmemh[addr >> 16] = read_aih_break;
 655         readmemd[addr >> 16] = read_aid_break;
 656     }
 657     else if(readfunc == read_pi) {
 658         readmem[addr >> 16] = read_pi_break;
 659         readmemb[addr >> 16] = read_pib_break;
 660         readmemh[addr >> 16] = read_pih_break;
 661         readmemd[addr >> 16] = read_pid_break;
 662     }
 663     else if(readfunc == read_ri) {
 664         readmem[addr >> 16] = read_ri_break;
 665         readmemb[addr >> 16] = read_rib_break;
 666         readmemh[addr >> 16] = read_rih_break;
 667         readmemd[addr >> 16] = read_rid_break;
 668     }
 669     else if(readfunc == read_si) {
 670         readmem[addr >> 16] = read_si_break;
 671         readmemb[addr >> 16] = read_sib_break;
 672         readmemh[addr >> 16] = read_sih_break;
 673         readmemd[addr >> 16] = read_sid_break;
 674     }
 675     else if(readfunc == read_pif) {
 676         readmem[addr >> 16] = read_pif_break;
 677         readmemb[addr >> 16] = read_pifb_break;
 678         readmemh[addr >> 16] = read_pifh_break;
 679         readmemd[addr >> 16] = read_pifd_break;
 680     }
 681     else if(readfunc == read_flashram_status) {
 682         readmem[addr >> 16] = read_flashram_status_break;
 683         readmemb[addr >> 16] = read_flashram_statusb_break;
 684         readmemh[addr >> 16] = read_flashram_statush_break;
 685         readmemd[addr >> 16] = read_flashram_statusd_break;
 686     }
 687     else if(readfunc == read_rom) {
 688         readmem[addr >> 16] = read_rom_break;
 689         readmemb[addr >> 16] = read_romb_break;
 690         readmemh[addr >> 16] = read_romh_break;
 691         readmemd[addr >> 16] = read_romd_break;
 692    }
 693    else
 694         DebugMessage(M64MSG_ERROR, "Unknown memory type in debugger activate_memory_break_read(): %p", readfunc);
 695 }
 696
 697 void deactivate_memory_break_read(uint32 addr) {
 698     void (*readfunc)() = readmem[addr >> 16];
 699
 700     if(readfunc == read_nomem_break) {
 701         readmem[addr >> 16]  = read_nomem;
 702         readmemb[addr >> 16] = read_nomemb;
 703         readmemh[addr >> 16] = read_nomemh;
 704         readmemd[addr >> 16] = read_nomemd;
 705     }
 706     else if(readfunc == read_nothing_break) {
 707         readmem[addr >> 16]  = read_nothing;
 708         readmemb[addr >> 16] = read_nothingb;
 709         readmemh[addr >> 16] = read_nothingh;
 710         readmemd[addr >> 16] = read_nothingd;
 711     }
 712     else if(readfunc == read_rdram_break) {
 713         readmem[addr >> 16]  = read_rdram;
 714         readmemb[addr >> 16] = read_rdramb;
 715         readmemh[addr >> 16] = read_rdramh;
 716         readmemd[addr >> 16] = read_rdramd;
 717     }
 718     else if(readfunc == read_rdramFB_break) {
 719         readmem[addr >> 16]  = read_rdramFB;
 720         readmemb[addr >> 16] = read_rdramFBb;
 721         readmemh[addr >> 16] = read_rdramFBh;
 722         readmemd[addr >> 16] = read_rdramFBd;
 723     }
 724     else if(readfunc == read_rdramreg_break) {
 725         readmem[addr >> 16]  = read_rdramreg;
 726         readmemb[addr >> 16] = read_rdramregb;
 727         readmemh[addr >> 16] = read_rdramregh;
 728         readmemd[addr >> 16] = read_rdramregd;
 729     }
 730     else if(readfunc == read_rsp_mem_break) {
 731         readmem[addr >> 16]  = read_rsp_mem;
 732         readmemb[addr >> 16] = read_rsp_memb;
 733         readmemh[addr >> 16] = read_rsp_memh;
 734         readmemd[addr >> 16] = read_rsp_memd;
 735     }
 736     else if(readfunc == read_rsp_reg_break) {
 737         readmem[addr >> 16] = read_rsp_reg;
 738         readmemb[addr >> 16] = read_rsp_regh;
 739         readmemh[addr >> 16] = read_rsp_regb;
 740         readmemd[addr >> 16] = read_rsp_regd;
 741     }
 742     else if(readfunc == read_rsp_break) {
 743         readmem[addr >> 16] = read_rsp;
 744         readmemb[addr >> 16] = read_rsph;
 745         readmemh[addr >> 16] = read_rspb;
 746         readmemd[addr >> 16] = read_rspd;
 747     }
 748     else if(readfunc == read_dp_break) {
 749         readmem[addr >> 16] = read_dp;
 750         readmemb[addr >> 16] = read_dpb;
 751         readmemh[addr >> 16] = read_dph;
 752         readmemd[addr >> 16] = read_dpd;
 753     }
 754     else if(readfunc == read_dps_break) {
 755         readmem[addr >> 16] = read_dps;
 756         readmemb[addr >> 16] = read_dpsb;
 757         readmemh[addr >> 16] = read_dpsh;
 758         readmemd[addr >> 16] = read_dpsd;
 759     }
 760     else if(readfunc == read_mi_break) {
 761         readmem[addr >> 16] = read_mi;
 762         readmemb[addr >> 16] = read_mib;
 763         readmemh[addr >> 16] = read_mih;
 764         readmemd[addr >> 16] = read_mid;
 765     }
 766     else if(readfunc == read_vi_break) {
 767         readmem[addr >> 16] = read_vi;
 768         readmemb[addr >> 16] = read_vib;
 769         readmemh[addr >> 16] = read_vih;
 770         readmemd[addr >> 16] = read_vid;
 771     }
 772     else if(readfunc == read_ai_break) {
 773         readmem[addr >> 16] = read_ai;
 774         readmemb[addr >> 16] = read_aib;
 775         readmemh[addr >> 16] = read_aih;
 776         readmemd[addr >> 16] = read_aid;
 777     }
 778     else if(readfunc == read_pi_break) {
 779         readmem[addr >> 16] = read_pi;
 780         readmemb[addr >> 16] = read_pib;
 781         readmemh[addr >> 16] = read_pih;
 782         readmemd[addr >> 16] = read_pid;
 783     }
 784     else if(readfunc == read_ri_break) {
 785         readmem[addr >> 16] = read_ri;
 786         readmemb[addr >> 16] = read_rib;
 787         readmemh[addr >> 16] = read_rih;
 788         readmemd[addr >> 16] = read_rid;
 789     }
 790     else if(readfunc == read_si_break) {
 791         readmem[addr >> 16] = read_si;
 792         readmemb[addr >> 16] = read_sib;
 793         readmemh[addr >> 16] = read_sih;
 794         readmemd[addr >> 16] = read_sid;
 795     }
 796     else if(readfunc == read_pif_break) {
 797         readmem[addr >> 16] = read_pif;
 798         readmemb[addr >> 16] = read_pifb;
 799         readmemh[addr >> 16] = read_pifh;
 800         readmemd[addr >> 16] = read_pifd;
 801     }
 802     else if(readfunc == read_flashram_status_break) {
 803         readmem[addr >> 16] = read_flashram_status;
 804         readmemb[addr >> 16] = read_flashram_statusb;
 805         readmemh[addr >> 16] = read_flashram_statush;
 806         readmemd[addr >> 16] = read_flashram_statusd;
 807     }
 808     else if(readfunc == read_rom_break) {
 809         readmem[addr >> 16] = read_rom;
 810         readmemb[addr >> 16] = read_romb;
 811         readmemh[addr >> 16] = read_romh;
 812         readmemd[addr >> 16] = read_romd;
 813     }
 814     else
 815         DebugMessage(M64MSG_ERROR, "Unknown memory type in debugger deactivate_memory_break_read(): %p", readfunc);
 816 }
 817
 818 void activate_memory_break_write(uint32 addr) {
 819     void (*writefunc)() = writemem[addr >> 16];
 820
 821     if(writefunc == write_nomem) {
 822         writemem[addr >> 16]  = write_nomem_break;
 823         writememb[addr >> 16] = write_nomemb_break;
 824         writememh[addr >> 16] = write_nomemh_break;
 825         writememd[addr >> 16] = write_nomemd_break;
 826     }
 827     else if(writefunc == write_nothing) {
 828         writemem[addr >> 16]  = write_nothing_break;
 829         writememb[addr >> 16] = write_nothingb_break;
 830         writememh[addr >> 16] = write_nothingh_break;
 831         writememd[addr >> 16] = write_nothingd_break;
 832     }
 833     else if(writefunc == write_rdram) {
 834         writemem[addr >> 16]  = write_rdram_break;
 835         writememb[addr >> 16] = write_rdramb_break;
 836         writememh[addr >> 16] = write_rdramh_break;
 837         writememd[addr >> 16] = write_rdramd_break;
 838     }
 839     else if(writefunc == write_rdramFB) {
 840         writemem[addr >> 16]  = write_rdramFB_break;
 841         writememb[addr >> 16] = write_rdramFBb_break;
 842         writememh[addr >> 16] = write_rdramFBh_break;
 843         writememd[addr >> 16] = write_rdramFBd_break;
 844     }
 845     else if(writefunc == write_rdramreg) {
 846         writemem[addr >> 16]  = write_rdramreg_break;
 847         writememb[addr >> 16] = write_rdramregb_break;
 848         writememh[addr >> 16] = write_rdramregh_break;
 849         writememd[addr >> 16] = write_rdramregd_break;
 850     }
 851     else if(writefunc == write_rsp_mem) {
 852         writemem[addr >> 16]  = write_rsp_mem_break;
 853         writememb[addr >> 16] = write_rsp_memb_break;
 854         writememh[addr >> 16] = write_rsp_memh_break;
 855         writememd[addr >> 16] = write_rsp_memd_break;
 856     }
 857     else if(writefunc == write_rsp_reg) {
 858         writemem[addr >> 16] = write_rsp_reg_break;
 859         writememb[addr >> 16] = write_rsp_regh_break;
 860         writememh[addr >> 16] = write_rsp_regb_break;
 861         writememd[addr >> 16] = write_rsp_regd_break;
 862     }
 863     else if(writefunc == write_rsp) {
 864         writemem[addr >> 16] = write_rsp_break;
 865         writememb[addr >> 16] = write_rsph_break;
 866         writememh[addr >> 16] = write_rspb_break;
 867         writememd[addr >> 16] = write_rspd_break;
 868     }
 869     else if(writefunc == write_dp) {
 870         writemem[addr >> 16] = write_dp_break;
 871         writememb[addr >> 16] = write_dpb_break;
 872         writememh[addr >> 16] = write_dph_break;
 873         writememd[addr >> 16] = write_dpd_break;
 874     }
 875     else if(writefunc == write_dps) {
 876         writemem[addr >> 16] = write_dps_break;
 877         writememb[addr >> 16] = write_dpsb_break;
 878         writememh[addr >> 16] = write_dpsh_break;
 879         writememd[addr >> 16] = write_dpsd_break;
 880     }
 881     else if(writefunc == write_mi) {
 882         writemem[addr >> 16] = write_mi_break;
 883         writememb[addr >> 16] = write_mib_break;
 884         writememh[addr >> 16] = write_mih_break;
 885         writememd[addr >> 16] = write_mid_break;
 886     }
 887     else if(writefunc == write_vi) {
 888         writemem[addr >> 16] = write_vi_break;
 889         writememb[addr >> 16] = write_vib_break;
 890         writememh[addr >> 16] = write_vih_break;
 891         writememd[addr >> 16] = write_vid_break;
 892     }
 893     else if(writefunc == write_ai) {
 894         writemem[addr >> 16] = write_ai_break;
 895         writememb[addr >> 16] = write_aib_break;
 896         writememh[addr >> 16] = write_aih_break;
 897         writememd[addr >> 16] = write_aid_break;
 898     }
 899     else if(writefunc == write_pi) {
 900         writemem[addr >> 16] = write_pi_break;
 901         writememb[addr >> 16] = write_pib_break;
 902         writememh[addr >> 16] = write_pih_break;
 903         writememd[addr >> 16] = write_pid_break;
 904     }
 905     else if(writefunc == write_ri) {
 906         writemem[addr >> 16] = write_ri_break;
 907         writememb[addr >> 16] = write_rib_break;
 908         writememh[addr >> 16] = write_rih_break;
 909         writememd[addr >> 16] = write_rid_break;
 910     }
 911     else if(writefunc == write_si) {
 912         writemem[addr >> 16] = write_si_break;
 913         writememb[addr >> 16] = write_sib_break;
 914         writememh[addr >> 16] = write_sih_break;
 915         writememd[addr >> 16] = write_sid_break;
 916     }
 917     else if(writefunc == write_pif) {
 918         writemem[addr >> 16] = write_pif_break;
 919         writememb[addr >> 16] = write_pifb_break;
 920         writememh[addr >> 16] = write_pifh_break;
 921         writememd[addr >> 16] = write_pifd_break;
 922     }
 923     else if(writefunc == write_flashram_dummy) {
 924         writemem[addr >> 16] = write_flashram_dummy_break;
 925         writememb[addr >> 16] = write_flashram_dummyb_break;
 926         writememh[addr >> 16] = write_flashram_dummyh_break;
 927         writememd[addr >> 16] = write_flashram_dummyd_break;
 928     }
 929     else if(writefunc == write_flashram_command) {
 930         writemem[addr >> 16] = write_flashram_command_break;
 931         writememb[addr >> 16] = write_flashram_commandb_break;
 932         writememh[addr >> 16] = write_flashram_commandh_break;
 933         writememd[addr >> 16] = write_flashram_commandd_break;
 934     }
 935     else if(writefunc == write_rom) {
 936         writemem[addr >> 16] = write_rom_break;
 937         writememb[addr >> 16] = write_nothingb_break;
 938         writememh[addr >> 16] = write_nothingh_break;
 939         writememd[addr >> 16] = write_nothingd_break;
 940    }
 941    else
 942         DebugMessage(M64MSG_ERROR, "Unknown memory type in debugger activate_memory_break_write(): %p", writefunc);
 943 }
 944
 945 void deactivate_memory_break_write(uint32 addr) {
 946     void (*writefunc)() = writemem[addr >> 16];
 947
 948     if(writefunc == write_nomem_break) {
 949         writemem[addr >> 16]  = write_nomem;
 950         writememb[addr >> 16] = write_nomemb;
 951         writememh[addr >> 16] = write_nomemh;
 952         writememd[addr >> 16] = write_nomemd;
 953     }
 954     else if(writefunc == write_nothing_break) {
 955         writemem[addr >> 16]  = write_nothing;
 956         writememb[addr >> 16] = write_nothingb;
 957         writememh[addr >> 16] = write_nothingh;
 958         writememd[addr >> 16] = write_nothingd;
 959     }
 960     else if(writefunc == write_rdram_break) {
 961         writemem[addr >> 16]  = write_rdram;
 962         writememb[addr >> 16] = write_rdramb;
 963         writememh[addr >> 16] = write_rdramh;
 964         writememd[addr >> 16] = write_rdramd;
 965     }
 966     else if(writefunc == write_rdramFB_break) {
 967         writemem[addr >> 16]  = write_rdramFB;
 968         writememb[addr >> 16] = write_rdramFBb;
 969         writememh[addr >> 16] = write_rdramFBh;
 970         writememd[addr >> 16] = write_rdramFBd;
 971     }
 972     else if(writefunc == write_rdramreg_break) {
 973         writemem[addr >> 16]  = write_rdramreg;
 974         writememb[addr >> 16] = write_rdramregb;
 975         writememh[addr >> 16] = write_rdramregh;
 976         writememd[addr >> 16] = write_rdramregd;
 977     }
 978     else if(writefunc == write_rsp_mem_break) {
 979         writemem[addr >> 16]  = write_rsp_mem;
 980         writememb[addr >> 16] = write_rsp_memb;
 981         writememh[addr >> 16] = write_rsp_memh;
 982         writememd[addr >> 16] = write_rsp_memd;
 983     }
 984     else if(writefunc == write_rsp_reg_break) {
 985         writemem[addr >> 16] = write_rsp_reg;
 986         writememb[addr >> 16] = write_rsp_regh;
 987         writememh[addr >> 16] = write_rsp_regb;
 988         writememd[addr >> 16] = write_rsp_regd;
 989     }
 990     else if(writefunc == write_rsp_break) {
 991         writemem[addr >> 16] = write_rsp;
 992         writememb[addr >> 16] = write_rsph;
 993         writememh[addr >> 16] = write_rspb;
 994         writememd[addr >> 16] = write_rspd;
 995     }
 996     else if(writefunc == write_dp_break) {
 997         writemem[addr >> 16] = write_dp;
 998         writememb[addr >> 16] = write_dpb;
 999         writememh[addr >> 16] = write_dph;
1000         writememd[addr >> 16] = write_dpd;
1001     }
1002     else if(writefunc == write_dps_break) {
1003         writemem[addr >> 16] = write_dps;
1004         writememb[addr >> 16] = write_dpsb;
1005         writememh[addr >> 16] = write_dpsh;
1006         writememd[addr >> 16] = write_dpsd;
1007     }
1008     else if(writefunc == write_mi_break) {
1009         writemem[addr >> 16] = write_mi;
1010         writememb[addr >> 16] = write_mib;
1011         writememh[addr >> 16] = write_mih;
1012         writememd[addr >> 16] = write_mid;
1013     }
1014     else if(writefunc == write_vi_break) {
1015         writemem[addr >> 16] = write_vi;
1016         writememb[addr >> 16] = write_vib;
1017         writememh[addr >> 16] = write_vih;
1018         writememd[addr >> 16] = write_vid;
1019     }
1020     else if(writefunc == write_ai_break) {
1021         writemem[addr >> 16] = write_ai;
1022         writememb[addr >> 16] = write_aib;
1023         writememh[addr >> 16] = write_aih;
1024         writememd[addr >> 16] = write_aid;
1025     }
1026     else if(writefunc == write_pi_break) {
1027         writemem[addr >> 16] = write_pi;
1028         writememb[addr >> 16] = write_pib;
1029         writememh[addr >> 16] = write_pih;
1030         writememd[addr >> 16] = write_pid;
1031     }
1032     else if(writefunc == write_ri_break) {
1033         writemem[addr >> 16] = write_ri;
1034         writememb[addr >> 16] = write_rib;
1035         writememh[addr >> 16] = write_rih;
1036         writememd[addr >> 16] = write_rid;
1037     }
1038     else if(writefunc == write_si_break) {
1039         writemem[addr >> 16] = write_si;
1040         writememb[addr >> 16] = write_sib;
1041         writememh[addr >> 16] = write_sih;
1042         writememd[addr >> 16] = write_sid;
1043     }
1044     else if(writefunc == write_pif_break) {
1045         writemem[addr >> 16] = write_pif;
1046         writememb[addr >> 16] = write_pifb;
1047         writememh[addr >> 16] = write_pifh;
1048         writememd[addr >> 16] = write_pifd;
1049     }
1050     else if(writefunc == write_flashram_dummy_break) {
1051         writemem[addr >> 16] = write_flashram_dummy;
1052         writememb[addr >> 16] = write_flashram_dummyb;
1053         writememh[addr >> 16] = write_flashram_dummyh;
1054         writememd[addr >> 16] = write_flashram_dummyd;
1055     }
1056     else if(writefunc == write_flashram_command_break) {
1057         writemem[addr >> 16] = write_flashram_command;
1058         writememb[addr >> 16] = write_flashram_commandb;
1059         writememh[addr >> 16] = write_flashram_commandh;
1060         writememd[addr >> 16] = write_flashram_commandd;
1061     }
1062     else if(writefunc == write_rom_break) {
1063         writemem[addr >> 16] = write_rom;
1064         writememb[addr >> 16] = write_nothingb;
1065         writememh[addr >> 16] = write_nothingh;
1066         writememd[addr >> 16] = write_nothingd;
1067     }
1068     else
1069         DebugMessage(M64MSG_ERROR, "Unknown memory type in debugger deactivate_memory_break_write(): %p", writefunc);
1070 }