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__))
81 static int lines_recompiled;
82 static uint32 addr_recompiled;
83 static int num_decoded;
85 static char opcode_recompiled[564][MAX_DISASSEMBLY];
86 static char args_recompiled[564][MAX_DISASSEMBLY*4];
87 static void *opaddr_recompiled[564];
89 static disassemble_info dis_info;
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;
95 static void process_opcode_out(void *strm, const char *fmt, ...){
103 if(strcmp(fmt,"%s")==0)
105 arg = va_arg(ap, char*);
106 strcpy(opcode_recompiled[lines_recompiled],arg);
109 strcpy(opcode_recompiled[lines_recompiled],"OPCODE-X");
111 *(args_recompiled[lines_recompiled])=0;
115 vsprintf(buff, fmt, ap);
116 sprintf(args_recompiled[lines_recompiled],"%s%s",
117 args_recompiled[lines_recompiled],buff);
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;
129 while (length-- != 0) {
135 void init_host_disassembler(void){
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;
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;
148 static void decode_recompiled(uint32 addr)
150 unsigned char *assemb, *end_addr;
154 if(blocks[addr>>12] == NULL)
157 if(blocks[addr>>12]->block[(addr&0xFFF)/4].ops == current_instruction_table.NOTCOMPILED)
158 // recompile_block((int *) SP_DMEM, blocks[addr>>12], addr);
160 strcpy(opcode_recompiled[0],"INVLD");
161 strcpy(args_recompiled[0],"NOTCOMPILED");
162 opaddr_recompiled[0] = (void *) 0;
168 assemb = (blocks[addr>>12]->code) +
169 (blocks[addr>>12]->block[(addr&0xFFF)/4].local_addr);
171 end_addr = blocks[addr>>12]->code;
173 if( (addr & 0xFFF) >= 0xFFC)
174 end_addr += blocks[addr>>12]->code_length;
176 end_addr += blocks[addr>>12]->block[(addr&0xFFF)/4+1].local_addr;
178 while(assemb < end_addr)
180 opaddr_recompiled[lines_recompiled] = assemb;
183 assemb += print_insn_i386((bfd_vma)(long) assemb, &dis_info);
188 addr_recompiled = addr;
191 char* get_recompiled_opcode(uint32 addr, int index)
193 if(addr != addr_recompiled)
194 decode_recompiled(addr);
196 if(index < lines_recompiled)
197 return opcode_recompiled[index];
202 char* get_recompiled_args(uint32 addr, int index)
204 if(addr != addr_recompiled)
205 decode_recompiled(addr);
207 if(index < lines_recompiled)
208 return args_recompiled[index];
213 void * get_recompiled_addr(uint32 addr, int index)
215 if(addr != addr_recompiled)
216 decode_recompiled(addr);
218 if(index < lines_recompiled)
219 return opaddr_recompiled[index];
224 int get_num_recompiled(uint32 addr)
226 if(addr != addr_recompiled)
227 decode_recompiled(addr);
229 return lines_recompiled;
232 int get_has_recompiled(uint32 addr)
234 unsigned char *assemb, *end_addr;
236 if(r4300emu != CORE_DYNAREC || blocks[addr>>12] == NULL)
239 assemb = (blocks[addr>>12]->code) +
240 (blocks[addr>>12]->block[(addr&0xFFF)/4].local_addr);
242 end_addr = blocks[addr>>12]->code;
244 if( (addr & 0xFFF) >= 0xFFC)
245 end_addr += blocks[addr>>12]->code_length;
247 end_addr += blocks[addr>>12]->block[(addr&0xFFF)/4+1].local_addr;
256 #define CHECK_MEM(address)
258 int get_num_recompiled(uint32 addr)
263 char* get_recompiled_opcode(uint32 addr, int index)
268 char* get_recompiled_args(uint32 addr, int index)
273 void * get_recompiled_addr(uint32 addr, int index)
278 int get_has_recompiled(uint32 addr)
283 void init_host_disassembler(void)
290 uint64 read_memory_64(uint32 addr)
292 return ((uint64)read_memory_32(addr) << 32) | (uint64)read_memory_32(addr + 4);
295 uint64 read_memory_64_unaligned(uint32 addr)
299 w[0] = read_memory_32_unaligned(addr);
300 w[1] = read_memory_32_unaligned(addr + 4);
301 return (w[0] << 32) | w[1];
304 void write_memory_64(uint32 addr, uint64 value)
306 write_memory_32(addr, (uint32) (value >> 32));
307 write_memory_32(addr + 4, (uint32) (value & 0xFFFFFFFF));
310 void write_memory_64_unaligned(uint32 addr, uint64 value)
312 write_memory_32_unaligned(addr, (uint32) (value >> 32));
313 write_memory_32_unaligned(addr + 4, (uint32) (value & 0xFFFFFFFF));
316 uint32 read_memory_32(uint32 addr){
317 const uint32 addrlow = (addr & 0xFFFF);
319 switch(get_memory_type(addr))
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;
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)));
333 return M64P_MEM_INVALID;
335 return *((uint32 *)(rom + (addr & 0x03FFFFFF)));
336 case M64P_MEM_RDRAMREG:
338 return *(readrdramreg[addrlow&0xfffc]);
340 case M64P_MEM_RSPREG:
342 return *(readrspreg[addrlow&0xfffc]);
346 return *(readrsp[addrlow&0xfffc]);
350 return *(readdp[addrlow&0xfffc]);
354 return *(readdps[addrlow&0xfffc]);
358 return *(readvi[addrlow&0xfffc]);
362 return *(readai[addrlow&0xfffc]);
366 return *(readpi[addrlow&0xfffc]);
370 return *(readri[addrlow&0xfffc]);
374 return *(readsi[addrlow&0xfffc]);
377 if (addrlow >= 0x7C0 && addrlow <= 0x7FF)
378 return sl(*((unsigned int *)(PIF_RAMb + (addrlow & 0x7FF) - 0x7C0)));
382 return *(readmi[addrlow&0xfffc]);
387 return M64P_MEM_INVALID;
390 uint32 read_memory_32_unaligned(uint32 addr)
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];
398 void write_memory_32(uint32 addr, uint32 value){
399 switch(get_memory_type(addr))
402 *((uint32 *)(rdramb + (addr & 0xFFFFFF))) = value;
408 void write_memory_32_unaligned(uint32 addr, uint32 value)
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);
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)
420 return ((uint16)read_memory_8(addr) << 8) | (uint16)read_memory_8(addr+1); //cough cough hack hack
423 void write_memory_16(uint32 addr, uint16 value)
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
429 uint8 read_memory_8(uint32 addr)
433 word = read_memory_32(addr & ~3);
434 return (word >> ((3 - (addr & 3)) * 8)) & 0xFF;
437 void write_memory_8(uint32 addr, uint8 value)
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);
447 uint32 get_memory_flags(uint32 addr)
449 int type=get_memory_type(addr);
450 const uint32 addrlow = (addr & 0xFFFF);
456 if(tlb_LUT_r[addr>>12])
457 flags = M64P_MEM_FLAG_READABLE | M64P_MEM_FLAG_WRITABLE_EMUONLY;
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
464 flags = M64P_MEM_FLAG_WRITABLE;
466 flags |= M64P_MEM_FLAG_READABLE;
468 case M64P_MEM_RDRAMREG:
470 flags = M64P_MEM_FLAG_READABLE | M64P_MEM_FLAG_WRITABLE_EMUONLY;
472 case M64P_MEM_RSPMEM:
473 if (addrlow < 0x2000)
474 flags = M64P_MEM_FLAG_READABLE | M64P_MEM_FLAG_WRITABLE_EMUONLY;
476 case M64P_MEM_RSPREG:
478 flags = M64P_MEM_FLAG_READABLE | M64P_MEM_FLAG_WRITABLE_EMUONLY;
482 flags = M64P_MEM_FLAG_READABLE | M64P_MEM_FLAG_WRITABLE_EMUONLY;
486 flags = M64P_MEM_FLAG_READABLE | M64P_MEM_FLAG_WRITABLE_EMUONLY;
490 flags = M64P_MEM_FLAG_READABLE | M64P_MEM_FLAG_WRITABLE_EMUONLY;
494 flags = M64P_MEM_FLAG_READABLE | M64P_MEM_FLAG_WRITABLE_EMUONLY;
498 flags = M64P_MEM_FLAG_READABLE | M64P_MEM_FLAG_WRITABLE_EMUONLY;
502 flags = M64P_MEM_FLAG_READABLE | M64P_MEM_FLAG_WRITABLE_EMUONLY;
506 flags = M64P_MEM_FLAG_READABLE | M64P_MEM_FLAG_WRITABLE_EMUONLY;
510 flags = M64P_MEM_FLAG_READABLE | M64P_MEM_FLAG_WRITABLE_EMUONLY;
512 case M64P_MEM_FLASHRAMSTAT:
514 flags = M64P_MEM_FLAG_READABLE_EMUONLY;
517 if (addrlow >= 0x7C0 && addrlow <= 0x7FF)
518 flags = M64P_MEM_FLAG_READABLE | M64P_MEM_FLAG_WRITABLE_EMUONLY;
522 flags = M64P_MEM_FLAG_READABLE | M64P_MEM_FLAG_WRITABLE_EMUONLY;
531 int get_memory_type(uint32 addr){
532 void (*readfunc)() = readmem[addr >> 16];
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))
548 else if((readfunc == read_dp) || (readfunc == read_dp_break))
550 else if((readfunc == read_dps) || (readfunc == read_dps_break))
552 else if((readfunc == read_vi) || (readfunc == read_vi_break))
554 else if((readfunc == read_ai) || (readfunc == read_ai_break))
556 else if((readfunc == read_pi) || (readfunc == read_pi_break))
558 else if((readfunc == read_ri) || (readfunc == read_ri_break))
560 else if((readfunc == read_si) || (readfunc == read_si_break))
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))
567 else if((readfunc == read_pif) || (readfunc == read_pif_break))
569 else if((readfunc == read_mi) || (readfunc == read_mi_break))
572 DebugMessage(M64MSG_ERROR, "Unknown memory type in debugger get_memory_type(): %p", readfunc);
573 return M64P_MEM_NOMEM;
576 void activate_memory_break_read(uint32 addr) {
577 void (*readfunc)() = readmem[addr >> 16];
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
694 DebugMessage(M64MSG_ERROR, "Unknown memory type in debugger activate_memory_break_read(): %p", readfunc);
697 void deactivate_memory_break_read(uint32 addr) {
698 void (*readfunc)() = readmem[addr >> 16];
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
815 DebugMessage(M64MSG_ERROR, "Unknown memory type in debugger deactivate_memory_break_read(): %p", readfunc);
818 void activate_memory_break_write(uint32 addr) {
819 void (*writefunc)() = writemem[addr >> 16];
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
942 DebugMessage(M64MSG_ERROR, "Unknown memory type in debugger activate_memory_break_write(): %p", writefunc);
945 void deactivate_memory_break_write(uint32 addr) {
946 void (*writefunc)() = writemem[addr >> 16];
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
1069 DebugMessage(M64MSG_ERROR, "Unknown memory type in debugger deactivate_memory_break_write(): %p", writefunc);