notaz.gp2x.de / mupen64plus-pandora.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Core commit. Compile and run on the OpenPandora
[mupen64plus-pandora.git] / source / mupen64plus-core / src / debugger / dbg_memory.c
CommitLineData
451ab91e 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.*/
38MEMBREAKALL_local(nothing);
39MEMBREAKALL_local(nomem);
40MEMBREAKALL(rdram);
41MEMBREAKALL(rdramFB);
42MEMBREAKALL_local(rdramreg);
43MEMBREAKALL_local(rsp_mem);
44MEMBREAKALL_local(rsp_reg);
45MEMBREAKALL_local(rsp);
46MEMBREAKALL_local(dp);
47MEMBREAKALL_local(dps);
48MEMBREAKALL_local(mi);
49MEMBREAKALL_local(vi);
50MEMBREAKALL_local(ai);
51MEMBREAKALL_local(pi);
52MEMBREAKALL_local(ri);
53MEMBREAKALL_local(si);
54MEMBREAKALL_local(pif);
55
56static MEMBREAKREAD(read_flashram_status, 4);
57static MEMBREAKREAD(read_flashram_statusb, 1);
58static MEMBREAKREAD(read_flashram_statush, 2);
59static MEMBREAKREAD(read_flashram_statusd, 8);
60static MEMBREAKWRITE(write_flashram_dummy, 4);
61static MEMBREAKWRITE(write_flashram_dummyb, 1);
62static MEMBREAKWRITE(write_flashram_dummyh, 2);
63static MEMBREAKWRITE(write_flashram_dummyd, 8);
64static MEMBREAKWRITE(write_flashram_command, 4);
65static MEMBREAKWRITE(write_flashram_commandb, 1);
66static MEMBREAKWRITE(write_flashram_commandh, 2);
67static MEMBREAKWRITE(write_flashram_commandd, 8);
68
69static MEMBREAKREAD(read_rom, 4);
70static MEMBREAKREAD(read_romb, 1);
71static MEMBREAKREAD(read_romh, 2);
72static MEMBREAKREAD(read_romd, 8);
73
74static 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
81static int lines_recompiled;
82static uint32 addr_recompiled;
83static int num_decoded;
84
85static char opcode_recompiled[564][MAX_DISASSEMBLY];
86static char args_recompiled[564][MAX_DISASSEMBLY*4];
87static void *opaddr_recompiled[564];
88
89static 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
95static 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').
124static 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
135void 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
148static 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
191char* 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
202char* 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
213void * 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
224int get_num_recompiled(uint32 addr)
225{
226 if(addr != addr_recompiled)
227 decode_recompiled(addr);
228
229 return lines_recompiled;
230}
231
232int 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
258int get_num_recompiled(uint32 addr)
259{
260 return 0;
261}
262
263char* get_recompiled_opcode(uint32 addr, int index)
264{
265 return NULL;
266}
267
268char* get_recompiled_args(uint32 addr, int index)
269{
270 return NULL;
271}
272
273void * get_recompiled_addr(uint32 addr, int index)
274{
275 return 0;
276}
277
278int get_has_recompiled(uint32 addr)
279{
280 return 0;
281}
282
283void init_host_disassembler(void)
284{
285
286}
287
288#endif
289
290uint64 read_memory_64(uint32 addr)
291{
292 return ((uint64)read_memory_32(addr) << 32) | (uint64)read_memory_32(addr + 4);
293}
294
295uint64 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
304void 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
310void 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
316uint32 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
390uint32 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
398void 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
408void 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.
418uint16 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
423void 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
429uint8 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
437void 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
447uint32 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
531int 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
576void 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
697void 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
818void 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
945void 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}
Unnamed repository; edit this file 'description' to name the repository.