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 *
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. *
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. *
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 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
25 #include "dbg_types.h"
26 #include "dbg_memory.h"
27 #include "dbg_breakpoints.h"
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"
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);
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);
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);
69 static MEMBREAKREAD(read_rom, 4);
70 static MEMBREAKREAD(read_romb, 1);
71 static MEMBREAKREAD(read_romh, 2);
72 static MEMBREAKREAD(read_romd, 8);
74 static MEMBREAKWRITE(write_rom, 8);
76 #if !defined(NO_ASM) && (defined(__i386__) || defined(__x86_64__))
78 /* we must define PACKAGE so that bfd.h (which is included from dis-asm.h) doesn't throw an error */
79 #define PACKAGE "mupen64plus-core"
83 static int lines_recompiled;
84 static uint32 addr_recompiled;
85 static int num_decoded;
87 static char opcode_recompiled[564][MAX_DISASSEMBLY];
88 static char args_recompiled[564][MAX_DISASSEMBLY*4];
89 static void *opaddr_recompiled[564];
91 static disassemble_info dis_info;
93 #define CHECK_MEM(address) \
94 if (!invalid_code[(address) >> 12] && blocks[(address) >> 12]->block[((address) & 0xFFF) / 4].ops != current_instruction_table.NOTCOMPILED) \
95 invalid_code[(address) >> 12] = 1;
97 static void process_opcode_out(void *strm, const char *fmt, ...){
105 if(strcmp(fmt,"%s")==0)
107 arg = va_arg(ap, char*);
108 strcpy(opcode_recompiled[lines_recompiled],arg);
111 strcpy(opcode_recompiled[lines_recompiled],"OPCODE-X");
113 *(args_recompiled[lines_recompiled])=0;
117 vsprintf(buff, fmt, ap);
118 sprintf(args_recompiled[lines_recompiled],"%s%s",
119 args_recompiled[lines_recompiled],buff);
124 // Callback function that will be called by libopcodes to read the
125 // bytes to disassemble ('read_memory_func' member of 'disassemble_info').
126 static int read_memory_func(bfd_vma memaddr, bfd_byte *myaddr,
127 unsigned int length, disassemble_info *info) {
128 char* from = (char*)(long)(memaddr);
129 char* to = (char*)myaddr;
131 while (length-- != 0) {
137 void init_host_disassembler(void){
140 INIT_DISASSEMBLE_INFO(dis_info, stderr, process_opcode_out);
141 dis_info.fprintf_func = (fprintf_ftype) process_opcode_out;
142 dis_info.stream = stderr;
143 dis_info.bytes_per_line=1;
145 dis_info.mach = bfd_mach_i386_i8086;
146 dis_info.disassembler_options = (char*) "i386,suffix";
147 dis_info.read_memory_func = read_memory_func;
150 static void decode_recompiled(uint32 addr)
152 unsigned char *assemb, *end_addr;
156 if(blocks[addr>>12] == NULL)
159 if(blocks[addr>>12]->block[(addr&0xFFF)/4].ops == current_instruction_table.NOTCOMPILED)
160 // recompile_block((int *) SP_DMEM, blocks[addr>>12], addr);
162 strcpy(opcode_recompiled[0],"INVLD");
163 strcpy(args_recompiled[0],"NOTCOMPILED");
164 opaddr_recompiled[0] = (void *) 0;
170 assemb = (blocks[addr>>12]->code) +
171 (blocks[addr>>12]->block[(addr&0xFFF)/4].local_addr);
173 end_addr = blocks[addr>>12]->code;
175 if( (addr & 0xFFF) >= 0xFFC)
176 end_addr += blocks[addr>>12]->code_length;
178 end_addr += blocks[addr>>12]->block[(addr&0xFFF)/4+1].local_addr;
180 while(assemb < end_addr)
182 opaddr_recompiled[lines_recompiled] = assemb;
185 assemb += print_insn_i386((bfd_vma)(long) assemb, &dis_info);
190 addr_recompiled = addr;
193 char* get_recompiled_opcode(uint32 addr, int index)
195 if(addr != addr_recompiled)
196 decode_recompiled(addr);
198 if(index < lines_recompiled)
199 return opcode_recompiled[index];
204 char* get_recompiled_args(uint32 addr, int index)
206 if(addr != addr_recompiled)
207 decode_recompiled(addr);
209 if(index < lines_recompiled)
210 return args_recompiled[index];
215 void * get_recompiled_addr(uint32 addr, int index)
217 if(addr != addr_recompiled)
218 decode_recompiled(addr);
220 if(index < lines_recompiled)
221 return opaddr_recompiled[index];
226 int get_num_recompiled(uint32 addr)
228 if(addr != addr_recompiled)
229 decode_recompiled(addr);
231 return lines_recompiled;
234 int get_has_recompiled(uint32 addr)
236 unsigned char *assemb, *end_addr;
238 if(r4300emu != CORE_DYNAREC || blocks[addr>>12] == NULL)
241 assemb = (blocks[addr>>12]->code) +
242 (blocks[addr>>12]->block[(addr&0xFFF)/4].local_addr);
244 end_addr = blocks[addr>>12]->code;
246 if( (addr & 0xFFF) >= 0xFFC)
247 end_addr += blocks[addr>>12]->code_length;
249 end_addr += blocks[addr>>12]->block[(addr&0xFFF)/4+1].local_addr;
258 #define CHECK_MEM(address)
260 int get_num_recompiled(uint32 addr)
265 char* get_recompiled_opcode(uint32 addr, int index)
270 char* get_recompiled_args(uint32 addr, int index)
275 void * get_recompiled_addr(uint32 addr, int index)
280 int get_has_recompiled(uint32 addr)
285 void init_host_disassembler(void)
292 uint64 read_memory_64(uint32 addr)
294 return ((uint64)read_memory_32(addr) << 32) | (uint64)read_memory_32(addr + 4);
297 uint64 read_memory_64_unaligned(uint32 addr)
301 w[0] = read_memory_32_unaligned(addr);
302 w[1] = read_memory_32_unaligned(addr + 4);
303 return (w[0] << 32) | w[1];
306 void write_memory_64(uint32 addr, uint64 value)
308 write_memory_32(addr, (uint32) (value >> 32));
309 write_memory_32(addr + 4, (uint32) (value & 0xFFFFFFFF));
312 void write_memory_64_unaligned(uint32 addr, uint64 value)
314 write_memory_32_unaligned(addr, (uint32) (value >> 32));
315 write_memory_32_unaligned(addr + 4, (uint32) (value & 0xFFFFFFFF));
318 uint32 read_memory_32(uint32 addr){
319 const uint32 addrlow = (addr & 0xFFFF);
321 switch(get_memory_type(addr))
324 if(tlb_LUT_r[addr>>12])
325 return read_memory_32((tlb_LUT_r[addr>>12]&0xFFFFF000)|(addr&0xFFF));
326 return M64P_MEM_INVALID;
328 return *((uint32 *)(rdramb + (addr & 0xFFFFFF)));
329 case M64P_MEM_RSPMEM:
330 if ((addr & 0xFFFF) < 0x1000)
331 return *((uint32 *)(SP_DMEMb + (addr&0xFFF)));
332 else if ((addr&0xFFFF) < 0x2000)
333 return *((uint32 *)(SP_IMEMb + (addr&0xFFF)));
335 return M64P_MEM_INVALID;
337 return *((uint32 *)(rom + (addr & 0x03FFFFFF)));
338 case M64P_MEM_RDRAMREG:
340 return *(readrdramreg[addrlow&0xfffc]);
342 case M64P_MEM_RSPREG:
344 return *(readrspreg[addrlow&0xfffc]);
348 return *(readrsp[addrlow&0xfffc]);
352 return *(readdp[addrlow&0xfffc]);
356 return *(readdps[addrlow&0xfffc]);
360 return *(readvi[addrlow&0xfffc]);
364 return *(readai[addrlow&0xfffc]);
368 return *(readpi[addrlow&0xfffc]);
372 return *(readri[addrlow&0xfffc]);
376 return *(readsi[addrlow&0xfffc]);
379 if (addrlow >= 0x7C0 && addrlow <= 0x7FF)
380 return sl(*((unsigned int *)(PIF_RAMb + (addrlow & 0x7FF) - 0x7C0)));
384 return *(readmi[addrlow&0xfffc]);
389 return M64P_MEM_INVALID;
392 uint32 read_memory_32_unaligned(uint32 addr)
396 for(i=0; i<4; i++) b[i] = read_memory_8(addr + i);
397 return (b[0] << 24) | (b[1] << 16) | (b[2] << 8) | b[3];
400 void write_memory_32(uint32 addr, uint32 value){
401 switch(get_memory_type(addr))
404 *((uint32 *)(rdramb + (addr & 0xFFFFFF))) = value;
410 void write_memory_32_unaligned(uint32 addr, uint32 value)
412 write_memory_8(addr + 0, value >> 24);
413 write_memory_8(addr + 1, (value >> 16) & 0xFF);
414 write_memory_8(addr + 2, (value >> 8) & 0xFF);
415 write_memory_8(addr + 3, value & 0xFF);
418 //read_memory_16_unaligned and write_memory_16_unaligned don't exist because
419 //read_memory_16 and write_memory_16 work unaligned already.
420 uint16 read_memory_16(uint32 addr)
422 return ((uint16)read_memory_8(addr) << 8) | (uint16)read_memory_8(addr+1); //cough cough hack hack
425 void write_memory_16(uint32 addr, uint16 value)
427 write_memory_8(addr, value >> 8); //this isn't much better
428 write_memory_8(addr + 1, value & 0xFF); //then again, it works unaligned
431 uint8 read_memory_8(uint32 addr)
435 word = read_memory_32(addr & ~3);
436 return (word >> ((3 - (addr & 3)) * 8)) & 0xFF;
439 void write_memory_8(uint32 addr, uint8 value)
443 word = read_memory_32(addr & ~3);
444 mask = 0xFF << ((3 - (addr & 3)) * 8);
445 word = (word & ~mask) | (value << ((3 - (addr & 3)) * 8));
446 write_memory_32(addr & ~3, word);
449 uint32 get_memory_flags(uint32 addr)
451 int type=get_memory_type(addr);
452 const uint32 addrlow = (addr & 0xFFFF);
458 if(tlb_LUT_r[addr>>12])
459 flags = M64P_MEM_FLAG_READABLE | M64P_MEM_FLAG_WRITABLE_EMUONLY;
461 case M64P_MEM_NOTHING:
462 if (((addr >> 16) == 0x8801 || (addr >> 16 == 0xA801)) && addrlow == 0)
463 flags = M64P_MEM_FLAG_WRITABLE_EMUONLY; // for flashram command
466 flags = M64P_MEM_FLAG_WRITABLE;
468 flags |= M64P_MEM_FLAG_READABLE;
470 case M64P_MEM_RDRAMREG:
472 flags = M64P_MEM_FLAG_READABLE | M64P_MEM_FLAG_WRITABLE_EMUONLY;
474 case M64P_MEM_RSPMEM:
475 if (addrlow < 0x2000)
476 flags = M64P_MEM_FLAG_READABLE | M64P_MEM_FLAG_WRITABLE_EMUONLY;
478 case M64P_MEM_RSPREG:
480 flags = M64P_MEM_FLAG_READABLE | M64P_MEM_FLAG_WRITABLE_EMUONLY;
484 flags = M64P_MEM_FLAG_READABLE | M64P_MEM_FLAG_WRITABLE_EMUONLY;
488 flags = M64P_MEM_FLAG_READABLE | M64P_MEM_FLAG_WRITABLE_EMUONLY;
492 flags = M64P_MEM_FLAG_READABLE | M64P_MEM_FLAG_WRITABLE_EMUONLY;
496 flags = M64P_MEM_FLAG_READABLE | M64P_MEM_FLAG_WRITABLE_EMUONLY;
500 flags = M64P_MEM_FLAG_READABLE | M64P_MEM_FLAG_WRITABLE_EMUONLY;
504 flags = M64P_MEM_FLAG_READABLE | M64P_MEM_FLAG_WRITABLE_EMUONLY;
508 flags = M64P_MEM_FLAG_READABLE | M64P_MEM_FLAG_WRITABLE_EMUONLY;
512 flags = M64P_MEM_FLAG_READABLE | M64P_MEM_FLAG_WRITABLE_EMUONLY;
514 case M64P_MEM_FLASHRAMSTAT:
516 flags = M64P_MEM_FLAG_READABLE_EMUONLY;
519 if (addrlow >= 0x7C0 && addrlow <= 0x7FF)
520 flags = M64P_MEM_FLAG_READABLE | M64P_MEM_FLAG_WRITABLE_EMUONLY;
524 flags = M64P_MEM_FLAG_READABLE | M64P_MEM_FLAG_WRITABLE_EMUONLY;
533 int get_memory_type(uint32 addr){
534 void (*readfunc)() = readmem[addr >> 16];
536 if((readfunc == read_nomem) || (readfunc == read_nomem_break))
537 return M64P_MEM_NOMEM;
538 else if((readfunc == read_nothing) || (readfunc == read_nothing_break))
539 return M64P_MEM_NOTHING;
540 else if((readfunc == read_rdram) || (readfunc == read_rdram_break))
541 return M64P_MEM_RDRAM;
542 else if((readfunc == read_rdramreg) || (readfunc == read_rdramreg_break))
543 return M64P_MEM_RDRAMREG;
544 else if((readfunc == read_rsp_mem) || (readfunc == read_rsp_mem_break))
545 return M64P_MEM_RSPMEM;
546 else if((readfunc == read_rsp_reg) || (readfunc == read_rsp_reg_break))
547 return M64P_MEM_RSPREG;
548 else if((readfunc == read_rsp) || (readfunc == read_rsp_break))
550 else if((readfunc == read_dp) || (readfunc == read_dp_break))
552 else if((readfunc == read_dps) || (readfunc == read_dps_break))
554 else if((readfunc == read_vi) || (readfunc == read_vi_break))
556 else if((readfunc == read_ai) || (readfunc == read_ai_break))
558 else if((readfunc == read_pi) || (readfunc == read_pi_break))
560 else if((readfunc == read_ri) || (readfunc == read_ri_break))
562 else if((readfunc == read_si) || (readfunc == read_si_break))
564 else if((readfunc == read_flashram_status) ||
565 (readfunc == read_flashram_status_break))
566 return M64P_MEM_FLASHRAMSTAT;
567 else if((readfunc == read_rom) || (readfunc == read_rom_break))
569 else if((readfunc == read_pif) || (readfunc == read_pif_break))
571 else if((readfunc == read_mi) || (readfunc == read_mi_break))
574 DebugMessage(M64MSG_ERROR, "Unknown memory type in debugger get_memory_type(): %p", readfunc);
575 return M64P_MEM_NOMEM;
578 void activate_memory_break_read(uint32 addr) {
579 void (*readfunc)() = readmem[addr >> 16];
581 if(readfunc == read_nomem) {
582 readmem[addr >> 16] = read_nomem_break;
583 readmemb[addr >> 16] = read_nomemb_break;
584 readmemh[addr >> 16] = read_nomemh_break;
585 readmemd[addr >> 16] = read_nomemd_break;
587 else if(readfunc == read_nothing) {
588 readmem[addr >> 16] = read_nothing_break;
589 readmemb[addr >> 16] = read_nothingb_break;
590 readmemh[addr >> 16] = read_nothingh_break;
591 readmemd[addr >> 16] = read_nothingd_break;
593 else if(readfunc == read_rdram) {
594 readmem[addr >> 16] = read_rdram_break;
595 readmemb[addr >> 16] = read_rdramb_break;
596 readmemh[addr >> 16] = read_rdramh_break;
597 readmemd[addr >> 16] = read_rdramd_break;
599 else if(readfunc == read_rdramFB) {
600 readmem[addr >> 16] = read_rdramFB_break;
601 readmemb[addr >> 16] = read_rdramFBb_break;
602 readmemh[addr >> 16] = read_rdramFBh_break;
603 readmemd[addr >> 16] = read_rdramFBd_break;
605 else if(readfunc == read_rdramreg) {
606 readmem[addr >> 16] = read_rdramreg_break;
607 readmemb[addr >> 16] = read_rdramregb_break;
608 readmemh[addr >> 16] = read_rdramregh_break;
609 readmemd[addr >> 16] = read_rdramregd_break;
611 else if(readfunc == read_rsp_mem) {
612 readmem[addr >> 16] = read_rsp_mem_break;
613 readmemb[addr >> 16] = read_rsp_memb_break;
614 readmemh[addr >> 16] = read_rsp_memh_break;
615 readmemd[addr >> 16] = read_rsp_memd_break;
617 else if(readfunc == read_rsp_reg) {
618 readmem[addr >> 16] = read_rsp_reg_break;
619 readmemb[addr >> 16] = read_rsp_regh_break;
620 readmemh[addr >> 16] = read_rsp_regb_break;
621 readmemd[addr >> 16] = read_rsp_regd_break;
623 else if(readfunc == read_rsp) {
624 readmem[addr >> 16] = read_rsp_break;
625 readmemb[addr >> 16] = read_rsph_break;
626 readmemh[addr >> 16] = read_rspb_break;
627 readmemd[addr >> 16] = read_rspd_break;
629 else if(readfunc == read_dp) {
630 readmem[addr >> 16] = read_dp_break;
631 readmemb[addr >> 16] = read_dpb_break;
632 readmemh[addr >> 16] = read_dph_break;
633 readmemd[addr >> 16] = read_dpd_break;
635 else if(readfunc == read_dps) {
636 readmem[addr >> 16] = read_dps_break;
637 readmemb[addr >> 16] = read_dpsb_break;
638 readmemh[addr >> 16] = read_dpsh_break;
639 readmemd[addr >> 16] = read_dpsd_break;
641 else if(readfunc == read_mi) {
642 readmem[addr >> 16] = read_mi_break;
643 readmemb[addr >> 16] = read_mib_break;
644 readmemh[addr >> 16] = read_mih_break;
645 readmemd[addr >> 16] = read_mid_break;
647 else if(readfunc == read_vi) {
648 readmem[addr >> 16] = read_vi_break;
649 readmemb[addr >> 16] = read_vib_break;
650 readmemh[addr >> 16] = read_vih_break;
651 readmemd[addr >> 16] = read_vid_break;
653 else if(readfunc == read_ai) {
654 readmem[addr >> 16] = read_ai_break;
655 readmemb[addr >> 16] = read_aib_break;
656 readmemh[addr >> 16] = read_aih_break;
657 readmemd[addr >> 16] = read_aid_break;
659 else if(readfunc == read_pi) {
660 readmem[addr >> 16] = read_pi_break;
661 readmemb[addr >> 16] = read_pib_break;
662 readmemh[addr >> 16] = read_pih_break;
663 readmemd[addr >> 16] = read_pid_break;
665 else if(readfunc == read_ri) {
666 readmem[addr >> 16] = read_ri_break;
667 readmemb[addr >> 16] = read_rib_break;
668 readmemh[addr >> 16] = read_rih_break;
669 readmemd[addr >> 16] = read_rid_break;
671 else if(readfunc == read_si) {
672 readmem[addr >> 16] = read_si_break;
673 readmemb[addr >> 16] = read_sib_break;
674 readmemh[addr >> 16] = read_sih_break;
675 readmemd[addr >> 16] = read_sid_break;
677 else if(readfunc == read_pif) {
678 readmem[addr >> 16] = read_pif_break;
679 readmemb[addr >> 16] = read_pifb_break;
680 readmemh[addr >> 16] = read_pifh_break;
681 readmemd[addr >> 16] = read_pifd_break;
683 else if(readfunc == read_flashram_status) {
684 readmem[addr >> 16] = read_flashram_status_break;
685 readmemb[addr >> 16] = read_flashram_statusb_break;
686 readmemh[addr >> 16] = read_flashram_statush_break;
687 readmemd[addr >> 16] = read_flashram_statusd_break;
689 else if(readfunc == read_rom) {
690 readmem[addr >> 16] = read_rom_break;
691 readmemb[addr >> 16] = read_romb_break;
692 readmemh[addr >> 16] = read_romh_break;
693 readmemd[addr >> 16] = read_romd_break;
696 DebugMessage(M64MSG_ERROR, "Unknown memory type in debugger activate_memory_break_read(): %p", readfunc);
699 void deactivate_memory_break_read(uint32 addr) {
700 void (*readfunc)() = readmem[addr >> 16];
702 if(readfunc == read_nomem_break) {
703 readmem[addr >> 16] = read_nomem;
704 readmemb[addr >> 16] = read_nomemb;
705 readmemh[addr >> 16] = read_nomemh;
706 readmemd[addr >> 16] = read_nomemd;
708 else if(readfunc == read_nothing_break) {
709 readmem[addr >> 16] = read_nothing;
710 readmemb[addr >> 16] = read_nothingb;
711 readmemh[addr >> 16] = read_nothingh;
712 readmemd[addr >> 16] = read_nothingd;
714 else if(readfunc == read_rdram_break) {
715 readmem[addr >> 16] = read_rdram;
716 readmemb[addr >> 16] = read_rdramb;
717 readmemh[addr >> 16] = read_rdramh;
718 readmemd[addr >> 16] = read_rdramd;
720 else if(readfunc == read_rdramFB_break) {
721 readmem[addr >> 16] = read_rdramFB;
722 readmemb[addr >> 16] = read_rdramFBb;
723 readmemh[addr >> 16] = read_rdramFBh;
724 readmemd[addr >> 16] = read_rdramFBd;
726 else if(readfunc == read_rdramreg_break) {
727 readmem[addr >> 16] = read_rdramreg;
728 readmemb[addr >> 16] = read_rdramregb;
729 readmemh[addr >> 16] = read_rdramregh;
730 readmemd[addr >> 16] = read_rdramregd;
732 else if(readfunc == read_rsp_mem_break) {
733 readmem[addr >> 16] = read_rsp_mem;
734 readmemb[addr >> 16] = read_rsp_memb;
735 readmemh[addr >> 16] = read_rsp_memh;
736 readmemd[addr >> 16] = read_rsp_memd;
738 else if(readfunc == read_rsp_reg_break) {
739 readmem[addr >> 16] = read_rsp_reg;
740 readmemb[addr >> 16] = read_rsp_regh;
741 readmemh[addr >> 16] = read_rsp_regb;
742 readmemd[addr >> 16] = read_rsp_regd;
744 else if(readfunc == read_rsp_break) {
745 readmem[addr >> 16] = read_rsp;
746 readmemb[addr >> 16] = read_rsph;
747 readmemh[addr >> 16] = read_rspb;
748 readmemd[addr >> 16] = read_rspd;
750 else if(readfunc == read_dp_break) {
751 readmem[addr >> 16] = read_dp;
752 readmemb[addr >> 16] = read_dpb;
753 readmemh[addr >> 16] = read_dph;
754 readmemd[addr >> 16] = read_dpd;
756 else if(readfunc == read_dps_break) {
757 readmem[addr >> 16] = read_dps;
758 readmemb[addr >> 16] = read_dpsb;
759 readmemh[addr >> 16] = read_dpsh;
760 readmemd[addr >> 16] = read_dpsd;
762 else if(readfunc == read_mi_break) {
763 readmem[addr >> 16] = read_mi;
764 readmemb[addr >> 16] = read_mib;
765 readmemh[addr >> 16] = read_mih;
766 readmemd[addr >> 16] = read_mid;
768 else if(readfunc == read_vi_break) {
769 readmem[addr >> 16] = read_vi;
770 readmemb[addr >> 16] = read_vib;
771 readmemh[addr >> 16] = read_vih;
772 readmemd[addr >> 16] = read_vid;
774 else if(readfunc == read_ai_break) {
775 readmem[addr >> 16] = read_ai;
776 readmemb[addr >> 16] = read_aib;
777 readmemh[addr >> 16] = read_aih;
778 readmemd[addr >> 16] = read_aid;
780 else if(readfunc == read_pi_break) {
781 readmem[addr >> 16] = read_pi;
782 readmemb[addr >> 16] = read_pib;
783 readmemh[addr >> 16] = read_pih;
784 readmemd[addr >> 16] = read_pid;
786 else if(readfunc == read_ri_break) {
787 readmem[addr >> 16] = read_ri;
788 readmemb[addr >> 16] = read_rib;
789 readmemh[addr >> 16] = read_rih;
790 readmemd[addr >> 16] = read_rid;
792 else if(readfunc == read_si_break) {
793 readmem[addr >> 16] = read_si;
794 readmemb[addr >> 16] = read_sib;
795 readmemh[addr >> 16] = read_sih;
796 readmemd[addr >> 16] = read_sid;
798 else if(readfunc == read_pif_break) {
799 readmem[addr >> 16] = read_pif;
800 readmemb[addr >> 16] = read_pifb;
801 readmemh[addr >> 16] = read_pifh;
802 readmemd[addr >> 16] = read_pifd;
804 else if(readfunc == read_flashram_status_break) {
805 readmem[addr >> 16] = read_flashram_status;
806 readmemb[addr >> 16] = read_flashram_statusb;
807 readmemh[addr >> 16] = read_flashram_statush;
808 readmemd[addr >> 16] = read_flashram_statusd;
810 else if(readfunc == read_rom_break) {
811 readmem[addr >> 16] = read_rom;
812 readmemb[addr >> 16] = read_romb;
813 readmemh[addr >> 16] = read_romh;
814 readmemd[addr >> 16] = read_romd;
817 DebugMessage(M64MSG_ERROR, "Unknown memory type in debugger deactivate_memory_break_read(): %p", readfunc);
820 void activate_memory_break_write(uint32 addr) {
821 void (*writefunc)() = writemem[addr >> 16];
823 if(writefunc == write_nomem) {
824 writemem[addr >> 16] = write_nomem_break;
825 writememb[addr >> 16] = write_nomemb_break;
826 writememh[addr >> 16] = write_nomemh_break;
827 writememd[addr >> 16] = write_nomemd_break;
829 else if(writefunc == write_nothing) {
830 writemem[addr >> 16] = write_nothing_break;
831 writememb[addr >> 16] = write_nothingb_break;
832 writememh[addr >> 16] = write_nothingh_break;
833 writememd[addr >> 16] = write_nothingd_break;
835 else if(writefunc == write_rdram) {
836 writemem[addr >> 16] = write_rdram_break;
837 writememb[addr >> 16] = write_rdramb_break;
838 writememh[addr >> 16] = write_rdramh_break;
839 writememd[addr >> 16] = write_rdramd_break;
841 else if(writefunc == write_rdramFB) {
842 writemem[addr >> 16] = write_rdramFB_break;
843 writememb[addr >> 16] = write_rdramFBb_break;
844 writememh[addr >> 16] = write_rdramFBh_break;
845 writememd[addr >> 16] = write_rdramFBd_break;
847 else if(writefunc == write_rdramreg) {
848 writemem[addr >> 16] = write_rdramreg_break;
849 writememb[addr >> 16] = write_rdramregb_break;
850 writememh[addr >> 16] = write_rdramregh_break;
851 writememd[addr >> 16] = write_rdramregd_break;
853 else if(writefunc == write_rsp_mem) {
854 writemem[addr >> 16] = write_rsp_mem_break;
855 writememb[addr >> 16] = write_rsp_memb_break;
856 writememh[addr >> 16] = write_rsp_memh_break;
857 writememd[addr >> 16] = write_rsp_memd_break;
859 else if(writefunc == write_rsp_reg) {
860 writemem[addr >> 16] = write_rsp_reg_break;
861 writememb[addr >> 16] = write_rsp_regh_break;
862 writememh[addr >> 16] = write_rsp_regb_break;
863 writememd[addr >> 16] = write_rsp_regd_break;
865 else if(writefunc == write_rsp) {
866 writemem[addr >> 16] = write_rsp_break;
867 writememb[addr >> 16] = write_rsph_break;
868 writememh[addr >> 16] = write_rspb_break;
869 writememd[addr >> 16] = write_rspd_break;
871 else if(writefunc == write_dp) {
872 writemem[addr >> 16] = write_dp_break;
873 writememb[addr >> 16] = write_dpb_break;
874 writememh[addr >> 16] = write_dph_break;
875 writememd[addr >> 16] = write_dpd_break;
877 else if(writefunc == write_dps) {
878 writemem[addr >> 16] = write_dps_break;
879 writememb[addr >> 16] = write_dpsb_break;
880 writememh[addr >> 16] = write_dpsh_break;
881 writememd[addr >> 16] = write_dpsd_break;
883 else if(writefunc == write_mi) {
884 writemem[addr >> 16] = write_mi_break;
885 writememb[addr >> 16] = write_mib_break;
886 writememh[addr >> 16] = write_mih_break;
887 writememd[addr >> 16] = write_mid_break;
889 else if(writefunc == write_vi) {
890 writemem[addr >> 16] = write_vi_break;
891 writememb[addr >> 16] = write_vib_break;
892 writememh[addr >> 16] = write_vih_break;
893 writememd[addr >> 16] = write_vid_break;
895 else if(writefunc == write_ai) {
896 writemem[addr >> 16] = write_ai_break;
897 writememb[addr >> 16] = write_aib_break;
898 writememh[addr >> 16] = write_aih_break;
899 writememd[addr >> 16] = write_aid_break;
901 else if(writefunc == write_pi) {
902 writemem[addr >> 16] = write_pi_break;
903 writememb[addr >> 16] = write_pib_break;
904 writememh[addr >> 16] = write_pih_break;
905 writememd[addr >> 16] = write_pid_break;
907 else if(writefunc == write_ri) {
908 writemem[addr >> 16] = write_ri_break;
909 writememb[addr >> 16] = write_rib_break;
910 writememh[addr >> 16] = write_rih_break;
911 writememd[addr >> 16] = write_rid_break;
913 else if(writefunc == write_si) {
914 writemem[addr >> 16] = write_si_break;
915 writememb[addr >> 16] = write_sib_break;
916 writememh[addr >> 16] = write_sih_break;
917 writememd[addr >> 16] = write_sid_break;
919 else if(writefunc == write_pif) {
920 writemem[addr >> 16] = write_pif_break;
921 writememb[addr >> 16] = write_pifb_break;
922 writememh[addr >> 16] = write_pifh_break;
923 writememd[addr >> 16] = write_pifd_break;
925 else if(writefunc == write_flashram_dummy) {
926 writemem[addr >> 16] = write_flashram_dummy_break;
927 writememb[addr >> 16] = write_flashram_dummyb_break;
928 writememh[addr >> 16] = write_flashram_dummyh_break;
929 writememd[addr >> 16] = write_flashram_dummyd_break;
931 else if(writefunc == write_flashram_command) {
932 writemem[addr >> 16] = write_flashram_command_break;
933 writememb[addr >> 16] = write_flashram_commandb_break;
934 writememh[addr >> 16] = write_flashram_commandh_break;
935 writememd[addr >> 16] = write_flashram_commandd_break;
937 else if(writefunc == write_rom) {
938 writemem[addr >> 16] = write_rom_break;
939 writememb[addr >> 16] = write_nothingb_break;
940 writememh[addr >> 16] = write_nothingh_break;
941 writememd[addr >> 16] = write_nothingd_break;
944 DebugMessage(M64MSG_ERROR, "Unknown memory type in debugger activate_memory_break_write(): %p", writefunc);
947 void deactivate_memory_break_write(uint32 addr) {
948 void (*writefunc)() = writemem[addr >> 16];
950 if(writefunc == write_nomem_break) {
951 writemem[addr >> 16] = write_nomem;
952 writememb[addr >> 16] = write_nomemb;
953 writememh[addr >> 16] = write_nomemh;
954 writememd[addr >> 16] = write_nomemd;
956 else if(writefunc == write_nothing_break) {
957 writemem[addr >> 16] = write_nothing;
958 writememb[addr >> 16] = write_nothingb;
959 writememh[addr >> 16] = write_nothingh;
960 writememd[addr >> 16] = write_nothingd;
962 else if(writefunc == write_rdram_break) {
963 writemem[addr >> 16] = write_rdram;
964 writememb[addr >> 16] = write_rdramb;
965 writememh[addr >> 16] = write_rdramh;
966 writememd[addr >> 16] = write_rdramd;
968 else if(writefunc == write_rdramFB_break) {
969 writemem[addr >> 16] = write_rdramFB;
970 writememb[addr >> 16] = write_rdramFBb;
971 writememh[addr >> 16] = write_rdramFBh;
972 writememd[addr >> 16] = write_rdramFBd;
974 else if(writefunc == write_rdramreg_break) {
975 writemem[addr >> 16] = write_rdramreg;
976 writememb[addr >> 16] = write_rdramregb;
977 writememh[addr >> 16] = write_rdramregh;
978 writememd[addr >> 16] = write_rdramregd;
980 else if(writefunc == write_rsp_mem_break) {
981 writemem[addr >> 16] = write_rsp_mem;
982 writememb[addr >> 16] = write_rsp_memb;
983 writememh[addr >> 16] = write_rsp_memh;
984 writememd[addr >> 16] = write_rsp_memd;
986 else if(writefunc == write_rsp_reg_break) {
987 writemem[addr >> 16] = write_rsp_reg;
988 writememb[addr >> 16] = write_rsp_regh;
989 writememh[addr >> 16] = write_rsp_regb;
990 writememd[addr >> 16] = write_rsp_regd;
992 else if(writefunc == write_rsp_break) {
993 writemem[addr >> 16] = write_rsp;
994 writememb[addr >> 16] = write_rsph;
995 writememh[addr >> 16] = write_rspb;
996 writememd[addr >> 16] = write_rspd;
998 else if(writefunc == write_dp_break) {
999 writemem[addr >> 16] = write_dp;
1000 writememb[addr >> 16] = write_dpb;
1001 writememh[addr >> 16] = write_dph;
1002 writememd[addr >> 16] = write_dpd;
1004 else if(writefunc == write_dps_break) {
1005 writemem[addr >> 16] = write_dps;
1006 writememb[addr >> 16] = write_dpsb;
1007 writememh[addr >> 16] = write_dpsh;
1008 writememd[addr >> 16] = write_dpsd;
1010 else if(writefunc == write_mi_break) {
1011 writemem[addr >> 16] = write_mi;
1012 writememb[addr >> 16] = write_mib;
1013 writememh[addr >> 16] = write_mih;
1014 writememd[addr >> 16] = write_mid;
1016 else if(writefunc == write_vi_break) {
1017 writemem[addr >> 16] = write_vi;
1018 writememb[addr >> 16] = write_vib;
1019 writememh[addr >> 16] = write_vih;
1020 writememd[addr >> 16] = write_vid;
1022 else if(writefunc == write_ai_break) {
1023 writemem[addr >> 16] = write_ai;
1024 writememb[addr >> 16] = write_aib;
1025 writememh[addr >> 16] = write_aih;
1026 writememd[addr >> 16] = write_aid;
1028 else if(writefunc == write_pi_break) {
1029 writemem[addr >> 16] = write_pi;
1030 writememb[addr >> 16] = write_pib;
1031 writememh[addr >> 16] = write_pih;
1032 writememd[addr >> 16] = write_pid;
1034 else if(writefunc == write_ri_break) {
1035 writemem[addr >> 16] = write_ri;
1036 writememb[addr >> 16] = write_rib;
1037 writememh[addr >> 16] = write_rih;
1038 writememd[addr >> 16] = write_rid;
1040 else if(writefunc == write_si_break) {
1041 writemem[addr >> 16] = write_si;
1042 writememb[addr >> 16] = write_sib;
1043 writememh[addr >> 16] = write_sih;
1044 writememd[addr >> 16] = write_sid;
1046 else if(writefunc == write_pif_break) {
1047 writemem[addr >> 16] = write_pif;
1048 writememb[addr >> 16] = write_pifb;
1049 writememh[addr >> 16] = write_pifh;
1050 writememd[addr >> 16] = write_pifd;
1052 else if(writefunc == write_flashram_dummy_break) {
1053 writemem[addr >> 16] = write_flashram_dummy;
1054 writememb[addr >> 16] = write_flashram_dummyb;
1055 writememh[addr >> 16] = write_flashram_dummyh;
1056 writememd[addr >> 16] = write_flashram_dummyd;
1058 else if(writefunc == write_flashram_command_break) {
1059 writemem[addr >> 16] = write_flashram_command;
1060 writememb[addr >> 16] = write_flashram_commandb;
1061 writememh[addr >> 16] = write_flashram_commandh;
1062 writememd[addr >> 16] = write_flashram_commandd;
1064 else if(writefunc == write_rom_break) {
1065 writemem[addr >> 16] = write_rom;
1066 writememb[addr >> 16] = write_nothingb;
1067 writememh[addr >> 16] = write_nothingh;
1068 writememd[addr >> 16] = write_nothingd;
1071 DebugMessage(M64MSG_ERROR, "Unknown memory type in debugger deactivate_memory_break_write(): %p", writefunc);