![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to debug.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [HATARI the Atari ST Emulator] / hatari / src / cpu|
Return to debug.c CVS log | Up to [HATARI the Atari ST Emulator] / hatari / src / cpu |
1.1 root 1: /*
2: * UAE - The Un*x Amiga Emulator
3: *
4: * Debugger
5: *
6: * (c) 1995 Bernd Schmidt
7: * (c) 2006 Toni Wilen
8: *
9: */
10:
11: #include "sysconfig.h"
12: #include "sysdeps.h"
13:
14: #include "main.h"
15: #include "hatari-glue.h"
16:
17: #include <ctype.h>
18: #include <signal.h>
19:
20: #include "options_cpu.h"
21: //#include "uae.h"
22: #include "memory.h"
23: #include "custom.h"
24: #include "newcpu.h"
25: #include "cpu_prefetch.h"
26: #include "debug.h"
27: //#include "cia.h"
28: //#include "xwin.h"
29: //#include "identify.h"
30: //#include "audio.h"
31: //#include "sound.h"
32: //#include "disk.h"
33: #include "savestate.h"
34: //#include "autoconf.h"
35: //#include "akiko.h"
36: //#include "inputdevice.h"
37: //#include "crc32.h"
38: //#include "rommgr.h"
39: //#include "inputrecord.h"
40: #include "cpummu.h"
41: #include "cpummu030.h"
42: //#include "ppc/ppcd.h"
43: //#include "uae/ppc.h"
44:
45: #ifdef WINUAE_FOR_HATARI
46: #include "stMemory.h"
47: static int debug_mmu_mode;
48:
49: #else
50: int debugger_active;
51: static uaecptr skipaddr_start, skipaddr_end;
52: static int skipaddr_doskip;
53: static uae_u32 skipins;
54: static int do_skip;
55: static int debug_rewind;
56: static int memwatch_triggered;
57: int memwatch_enabled;
58: static uae_u16 sr_bpmask, sr_bpvalue;
59: int debugging;
60: int exception_debugging;
61: int no_trace_exceptions;
62: int debug_copper = 0;
63: int debug_dma = 0;
64: int debug_sprite_mask = 0xff;
65: int debug_illegal = 0;
66: uae_u64 debug_illegal_mask;
67: static int debug_mmu_mode;
68: static bool break_if_enforcer;
69:
70: static uaecptr processptr;
71: static uae_char *processname;
72:
73: static uaecptr debug_copper_pc;
74:
75: extern int audio_channel_mask;
76: extern int inputdevice_logging;
77:
78: void deactivate_debugger (void)
79: {
80: debugger_active = 0;
81: debugging = 0;
82: exception_debugging = 0;
83: processptr = 0;
84: xfree (processname);
85: processname = NULL;
86: }
87:
88: void activate_debugger (void)
89: {
90: do_skip = 0;
91: if (debugger_active)
92: return;
93: debugger_active = 1;
94: set_special (SPCFLAG_BRK);
95: debugging = 1;
96: mmu_triggered = 0;
97: }
98:
99: bool debug_enforcer(void)
100: {
101: if (!break_if_enforcer)
102: return false;
103: activate_debugger();
104: return true;
105: }
106:
107: int firsthist = 0;
108: int lasthist = 0;
109: static struct regstruct history[MAX_HIST];
110:
111: static TCHAR help[] = {
112: _T(" HELP for UAE Debugger\n")
113: _T(" -----------------------\n\n")
114: _T(" g [<address>] Start execution at the current address or <address>.\n")
115: _T(" c Dump state of the CIA, disk drives and custom registers.\n")
116: _T(" r Dump state of the CPU.\n")
117: _T(" r <reg> <value> Modify CPU registers (Dx,Ax,USP,ISP,VBR,...).\n")
118: _T(" m <address> [<lines>] Memory dump starting at <address>.\n")
119: _T(" d <address> [<lines>] Disassembly starting at <address>.\n")
120: _T(" t [instructions] Step one or more instructions.\n")
121: _T(" z Step through one instruction - useful for JSR, DBRA etc.\n")
122: _T(" f Step forward until PC in RAM (\"boot block finder\").\n")
123: _T(" f <address> Add/remove breakpoint.\n")
124: _T(" fa <address> [<start>] [<end>]\n")
125: _T(" Find effective address <address>.\n")
126: _T(" fi Step forward until PC points to RTS, RTD or RTE.\n")
127: _T(" fi <opcode> Step forward until PC points to <opcode>.\n")
128: _T(" fp \"<name>\"/<addr> Step forward until process <name> or <addr> is active.\n")
129: _T(" fl List breakpoints.\n")
130: _T(" fd Remove all breakpoints.\n")
131: _T(" fs <lines to wait> | <vpos> <hpos> Wait n scanlines/position.\n")
132: _T(" fc <CCKs to wait> Wait n color clocks.\n")
133: _T(" fS <val> <mask> Break when (SR & mask) = val.\n")
134: _T(" f <addr1> <addr2> Step forward until <addr1> <= PC <= <addr2>.\n")
135: _T(" e Dump contents of all custom registers, ea = AGA colors.\n")
136: _T(" i [<addr>] Dump contents of interrupt and trap vectors.\n")
137: _T(" il [<mask>] Exception breakpoint.\n")
138: _T(" o <0-2|addr> [<lines>]View memory as Copper instructions.\n")
139: _T(" od Enable/disable Copper vpos/hpos tracing.\n")
140: _T(" ot Copper single step trace.\n")
141: _T(" ob <addr> Copper breakpoint.\n")
142: _T(" H[H] <cnt> Show PC history (HH=full CPU info) <cnt> instructions.\n")
143: _T(" C <value> Search for values like energy or lifes in games.\n")
144: _T(" Cl List currently found trainer addresses.\n")
145: _T(" D[idxzs <[max diff]>] Deep trainer. i=new value must be larger, d=smaller,\n")
146: _T(" x = must be same, z = must be different, s = restart.\n")
147: _T(" W <address> <values[.x] separated by space> Write into Amiga memory.\n")
148: _T(" W <address> 'string' Write into Amiga memory.\n")
149: _T(" w <num> <address> <length> <R/W/I/F/C> [<value>[.x]] (read/write/opcode/freeze/mustchange).\n")
150: _T(" Add/remove memory watchpoints.\n")
151: _T(" wd [<0-1>] Enable illegal access logger. 1 = enable break.\n")
152: _T(" S <file> <addr> <n> Save a block of Amiga memory.\n")
153: _T(" s \"<string>\"/<values> [<addr>] [<length>]\n")
154: _T(" Search for string/bytes.\n")
155: _T(" T or Tt Show exec tasks and their PCs.\n")
156: _T(" Td,Tl,Tr,Tp,Ts,TS,Ti,TO,TM Show devs, libs, resources, ports, semaphores,\n")
157: _T(" residents, interrupts, doslist and memorylist.\n")
158: _T(" b Step to previous state capture position.\n")
159: _T(" M<a/b/s> <val> Enable or disable audio channels, bitplanes or sprites.\n")
160: _T(" sp <addr> [<addr2][<size>] Dump sprite information.\n")
161: _T(" di <mode> [<track>] Break on disk access. R=DMA read,W=write,RW=both,P=PIO.\n")
162: _T(" Also enables level 1 disk logging.\n")
163: _T(" did <log level> Enable disk logging.\n")
164: _T(" dj [<level bitmask>] Enable joystick/mouse input debugging.\n")
165: _T(" smc [<0-1>] Enable self-modifying code detector. 1 = enable break.\n")
166: _T(" dm Dump current address space map.\n")
167: _T(" v <vpos> [<hpos>] Show DMA data (accurate only in cycle-exact mode).\n")
168: _T(" v [-1 to -4] = enable visual DMA debugger.\n")
169: _T(" ?<value> Hex ($ and 0x)/Bin (%)/Dec (!) converter.\n")
170: #ifdef _WIN32
171: _T(" x Close debugger.\n")
172: _T(" xx Switch between console and GUI debugger.\n")
173: _T(" mg <address> Memory dump starting at <address> in GUI.\n")
174: _T(" dg <address> Disassembly starting at <address> in GUI.\n")
175: #endif
176: _T(" q Quit the emulator. You don't want to use this command.\n\n")
177: };
178:
179: void debug_help (void)
180: {
181: console_out (help);
182: }
183:
184: static int debug_linecounter;
185: #define MAX_LINECOUNTER 1000
186:
187: static int debug_out (const TCHAR *format, ...)
188: {
189: va_list parms;
190: TCHAR buffer[4000];
191:
192: va_start (parms, format);
193: _vsntprintf (buffer, 4000 - 1, format, parms);
194: va_end (parms);
195:
196: console_out (buffer);
197: if (debug_linecounter < MAX_LINECOUNTER)
198: debug_linecounter++;
199: if (debug_linecounter >= MAX_LINECOUNTER)
200: return 0;
201: return 1;
202: }
203:
204: #endif /* ! WINUAE_FOR_HATARI */
205:
206: uae_u32 get_byte_debug (uaecptr addr)
207: {
208: uae_u32 v = 0xff;
209: if (debug_mmu_mode) {
210: flagtype olds = regs.s;
211: regs.s = (debug_mmu_mode & 4) != 0;
212: TRY(p) {
213: if (currprefs.mmu_model == 68030) {
214: v = mmu030_get_generic (addr, debug_mmu_mode, sz_byte, sz_byte, 0);
215: } else {
216: v = mmu_get_user_byte (addr, regs.s != 0, (debug_mmu_mode & 1) ? true : false, false, sz_byte);
217: }
218: } CATCH(p) {
219: } ENDTRY
220: regs.s = olds;
221: } else {
222: #ifndef WINUAE_FOR_HATARI
223: v = get_byte (addr);
224: #else
225: v = STMemory_ReadByte ( addr );
226: #endif
227: }
228: return v;
229: }
230: uae_u32 get_word_debug (uaecptr addr)
231: {
232: uae_u32 v = 0xffff;
233: if (debug_mmu_mode) {
234: flagtype olds = regs.s;
235: regs.s = (debug_mmu_mode & 4) != 0;
236: TRY(p) {
237: if (currprefs.mmu_model == 68030) {
238: v = mmu030_get_generic (addr, debug_mmu_mode, sz_word, sz_word, 0);
239: } else {
240: v = mmu_get_user_word (addr, regs.s != 0, (debug_mmu_mode & 1) ? true : false, false, sz_word);
241: }
242: } CATCH(p) {
243: } ENDTRY
244: regs.s = olds;
245: } else {
246: #ifndef WINUAE_FOR_HATARI
247: v = get_word (addr);
248: #else
249: v = STMemory_ReadWord ( addr );
250: #endif
251: }
252: return v;
253: }
254: uae_u32 get_long_debug (uaecptr addr)
255: {
256: uae_u32 v = 0xffffffff;
257: if (debug_mmu_mode) {
258: flagtype olds = regs.s;
259: regs.s = (debug_mmu_mode & 4) != 0;
260: TRY(p) {
261: if (currprefs.mmu_model == 68030) {
262: v = mmu030_get_generic (addr, debug_mmu_mode, sz_long, sz_long, 0);
263: } else {
264: v = mmu_get_user_long (addr, regs.s != 0, (debug_mmu_mode & 1) ? true : false, false, sz_long);
265: }
266: } CATCH(p) {
267: } ENDTRY
268: regs.s = olds;
269: } else {
270: #ifndef WINUAE_FOR_HATARI
271: v = get_long (addr);
272: #else
273: v = STMemory_ReadLong ( addr );
274: #endif
275: }
276: return v;
277: }
278: uae_u32 get_iword_debug (uaecptr addr)
279: {
280: if (debug_mmu_mode) {
281: return get_word_debug (addr);
282: } else {
283: #ifndef WINUAE_FOR_HATARI
284: if (valid_address (addr, 2))
285: return get_word (addr);
286: return 0xffff;
287: #else
288: return get_word_debug (addr);
289: #endif
290: }
291: }
292: uae_u32 get_ilong_debug (uaecptr addr)
293: {
294: if (debug_mmu_mode) {
295: return get_long_debug (addr);
296: } else {
297: #ifndef WINUAE_FOR_HATARI
298: if (valid_address (addr, 4))
299: return get_long (addr);
300: return 0xffffffff;
301: #else
302: return get_long_debug (addr);
303: #endif
304: }
305: }
306:
307: #ifndef WINUAE_FOR_HATARI
308: int safe_addr (uaecptr addr, int size)
309: {
310: if (debug_mmu_mode) {
311: flagtype olds = regs.s;
312: regs.s = (debug_mmu_mode & 4) != 0;
313: TRY(p) {
314: if (currprefs.mmu_model >= 68040)
315: addr = mmu_translate (addr, regs.s != 0, (debug_mmu_mode & 1), false);
316: else
317: addr = mmu030_translate (addr, regs.s != 0, (debug_mmu_mode & 1), false);
318: } CATCH(p) {
319: return 0;
320: } ENDTRY
321: regs.s = olds;
322: }
323: addrbank *ab = &get_mem_bank (addr);
324: if (!ab)
325: return 0;
326: if (ab->flags & ABFLAG_SAFE)
327: return 1;
328: if (!ab->check (addr, size))
329: return 0;
330: if (ab->flags & (ABFLAG_RAM | ABFLAG_ROM | ABFLAG_ROMIN | ABFLAG_SAFE))
331: return 1;
332: return 0;
333: }
334:
335: static bool iscancel (int counter)
336: {
337: static int cnt;
338:
339: cnt++;
340: if (cnt < counter)
341: return false;
342: cnt = 0;
343: if (!console_isch ())
344: return false;
345: console_getch ();
346: return true;
347: }
348:
349: static bool isoperator(TCHAR **cp)
350: {
351: TCHAR c = **cp;
352: return c == '+' || c == '-' || c == '/' || c == '*' || c == '(' || c == ')';
353: }
354:
355: static void ignore_ws (TCHAR **c)
356: {
357: while (**c && _istspace(**c))
358: (*c)++;
359: }
360: static TCHAR peekchar (TCHAR **c)
361: {
362: return **c;
363: }
364: static TCHAR readchar (TCHAR **c)
365: {
366: TCHAR cc = **c;
367: (*c)++;
368: return cc;
369: }
370: static TCHAR next_char (TCHAR **c)
371: {
372: ignore_ws (c);
373: return *(*c)++;
374: }
375: static TCHAR peek_next_char (TCHAR **c)
376: {
377: TCHAR *pc = *c;
378: return pc[1];
379: }
380: static int more_params (TCHAR **c)
381: {
382: ignore_ws (c);
383: return (**c) != 0;
384: }
385:
386: static uae_u32 readint (TCHAR **c);
387: static uae_u32 readbin (TCHAR **c);
388: static uae_u32 readhex (TCHAR **c);
389:
390: static int readregx (TCHAR **c, uae_u32 *valp)
391: {
392: int i;
393: uae_u32 addr;
394: TCHAR *p = *c;
395: TCHAR tmp[10];
396: int extra = 0;
397:
398: addr = 0;
399: i = 0;
400: while (p[i]) {
401: tmp[i] = _totupper (p[i]);
402: if (i >= sizeof (tmp) / sizeof (TCHAR) - 1)
403: break;
404: i++;
405: }
406: tmp[i] = 0;
407: if (_totupper (tmp[0]) == 'R') {
408: memmove (tmp, tmp + 1, sizeof (tmp) - sizeof (TCHAR));
409: extra = 1;
410: }
411: if (!_tcsncmp (tmp, _T("USP"), 3)) {
412: addr = regs.usp;
413: (*c) += 3;
414: } else if (!_tcsncmp (tmp, _T("VBR"), 3)) {
415: addr = regs.vbr;
416: (*c) += 3;
417: } else if (!_tcsncmp (tmp, _T("MSP"), 3)) {
418: addr = regs.msp;
419: (*c) += 3;
420: } else if (!_tcsncmp (tmp, _T("ISP"), 3)) {
421: addr = regs.isp;
422: (*c) += 3;
423: } else if (!_tcsncmp (tmp, _T("PC"), 2)) {
424: addr = regs.pc;
425: (*c) += 2;
426: } else if (tmp[0] == 'A' || tmp[0] == 'D') {
427: int reg = 0;
428: if (tmp[0] == 'A')
429: reg += 8;
430: reg += tmp[1] - '0';
431: if (reg < 0 || reg > 15)
432: return 0;
433: addr = regs.regs[reg];
434: (*c) += 2;
435: } else {
436: return 0;
437: }
438: *valp = addr;
439: (*c) += extra;
440: return 1;
441: }
442:
443: static bool readbinx (TCHAR **c, uae_u32 *valp)
444: {
445: uae_u32 val = 0;
446: bool first = true;
447:
448: ignore_ws (c);
449: for (;;) {
450: TCHAR nc = **c;
451: if (nc != '1' && nc != '0') {
452: if (first)
453: return false;
454: break;
455: }
456: first = false;
457: (*c)++;
458: val <<= 1;
459: if (nc == '1')
460: val |= 1;
461: }
462: *valp = val;
463: return true;
464: }
465:
466: static bool readhexx (TCHAR **c, uae_u32 *valp)
467: {
468: uae_u32 val = 0;
469: TCHAR nc;
470:
471: ignore_ws (c);
472: if (!isxdigit (peekchar (c)))
473: return false;
474: while (isxdigit (nc = **c)) {
475: (*c)++;
476: val *= 16;
477: nc = _totupper (nc);
478: if (isdigit (nc)) {
479: val += nc - '0';
480: } else {
481: val += nc - 'A' + 10;
482: }
483: }
484: *valp = val;
485: return true;
486: }
487:
488: static bool readintx (TCHAR **c, uae_u32 *valp)
489: {
490: uae_u32 val = 0;
491: TCHAR nc;
492: int negative = 0;
493:
494: ignore_ws (c);
495: if (**c == '-')
496: negative = 1, (*c)++;
497: if (!isdigit (peekchar (c)))
498: return false;
499: while (isdigit (nc = **c)) {
500: (*c)++;
501: val *= 10;
502: val += nc - '0';
503: }
504: *valp = val * (negative ? -1 : 1);
505: return true;
506: }
507:
508:
509: static int checkvaltype2 (TCHAR **c, uae_u32 *val, TCHAR def)
510: {
511: TCHAR nc;
512:
513: ignore_ws (c);
514: nc = _totupper (**c);
515: if (nc == '!') {
516: (*c)++;
517: return readintx (c, val) ? 1 : 0;
518: }
519: if (nc == '$') {
520: (*c)++;
521: return readhexx (c, val) ? 1 : 0;
522: }
523: if (nc == '0' && _totupper ((*c)[1]) == 'X') {
524: (*c)+= 2;
525: return readhexx (c, val) ? 1 : 0;
526: }
527: if (nc == '%') {
528: (*c)++;
529: return readbinx (c, val) ? 1: 0;
530: }
531: if (nc >= 'A' && nc <= 'Z' && nc != 'A' && nc != 'D') {
532: if (readregx (c, val))
533: return 1;
534: }
535: if (def == '!') {
536: return readintx (c, val) ? -1 : 0;
537: return -1;
538: } else if (def == '$') {
539: return readhexx (c, val) ? -1 : 0;
540: } else if (def == '%') {
541: return readbinx (c, val) ? -1 : 0;
542: }
543: return 0;
544: }
545:
546: static int readsize (int val, TCHAR **c)
547: {
548: TCHAR cc = _totupper (readchar(c));
549: if (cc == 'B')
550: return 1;
551: if (cc == 'W')
552: return 2;
553: if (cc == '3')
554: return 3;
555: if (cc == 'L')
556: return 4;
557: return 0;
558: }
559:
560: static int checkvaltype (TCHAR **cp, uae_u32 *val, int *size, TCHAR def)
561: {
562: TCHAR form[256], *p;
563: bool gotop = false;
564: double out;
565:
566: form[0] = 0;
567: *size = 0;
568: p = form;
569: for (;;) {
570: uae_u32 v;
571: if (!checkvaltype2 (cp, &v, def))
572: return 0;
573: *val = v;
574: // stupid but works!
575: _stprintf(p, _T("%u"), v);
576: p += _tcslen (p);
577: if (peekchar (cp) == '.') {
578: readchar (cp);
579: *size = readsize (v, cp);
580: }
581: if (!isoperator (cp))
582: break;
583: gotop = true;
584: *p++= readchar (cp);
585: *p = 0;
586: }
587: if (!gotop) {
588: if (*size == 0) {
589: uae_s32 v = (uae_s32)(*val);
590: if (v > 255 || v < -127) {
591: *size = 2;
592: } else if (v > 65535 || v < -32767) {
593: *size = 4;
594: } else {
595: *size = 1;
596: }
597: }
598: return 1;
599: }
600: if (calc (form, &out)) {
601: *val = (uae_u32)out;
602: if (*size == 0) {
603: uae_s32 v = (uae_s32)(*val);
604: if (v > 255 || v < -127) {
605: *size = 2;
606: } else if (v > 65535 || v < -32767) {
607: *size = 4;
608: } else {
609: *size = 1;
610: }
611: }
612: return 1;
613: }
614: return 0;
615: }
616:
617:
618: static uae_u32 readnum (TCHAR **c, int *size, TCHAR def)
619: {
620: uae_u32 val;
621: if (checkvaltype (c, &val, size, def))
622: return val;
623: return 0;
624: }
625:
626: static uae_u32 readint (TCHAR **c)
627: {
628: int size;
629: return readnum (c, &size, '!');
630: }
631: static uae_u32 readhex (TCHAR **c)
632: {
633: int size;
634: return readnum (c, &size, '$');
635: }
636: static uae_u32 readbin (TCHAR **c)
637: {
638: int size;
639: return readnum (c, &size, '%');
640: }
641: static uae_u32 readint (TCHAR **c, int *size)
642: {
643: return readnum (c, size, '!');
644: }
645: static uae_u32 readhex (TCHAR **c, int *size)
646: {
647: return readnum (c, size, '$');
648: }
649:
650: static int next_string (TCHAR **c, TCHAR *out, int max, int forceupper)
651: {
652: TCHAR *p = out;
653: int startmarker = 0;
654:
655: if (**c == '\"') {
656: startmarker = 1;
657: (*c)++;
658: }
659: *p = 0;
660: while (**c != 0) {
661: if (**c == '\"' && startmarker)
662: break;
663: if (**c == 32 && !startmarker) {
664: ignore_ws (c);
665: break;
666: }
667: *p = next_char (c);
668: if (forceupper)
669: *p = _totupper(*p);
670: *++p = 0;
671: max--;
672: if (max <= 1)
673: break;
674: }
675: return _tcslen (out);
676: }
677:
678: static void converter (TCHAR **c)
679: {
680: uae_u32 v = readint (c);
681: TCHAR s[100];
682: TCHAR *p = s;
683: int i;
684:
685: for (i = 0; i < 32; i++)
686: s[i] = (v & (1 << (31 - i))) ? '1' : '0';
687: s[i] = 0;
688: console_out_f (_T("0x%08X = %%%s = %u = %d\n"), v, s, v, (uae_s32)v);
689: }
690:
691: int notinrom (void)
692: {
693: uaecptr pc = munge24 (m68k_getpc ());
694: if (pc < 0x00e00000 || pc > 0x00ffffff)
695: return 1;
696: return 0;
697: }
698:
699: static uae_u32 lastaddr (void)
700: {
701: if (currprefs.z3fastmem2_size)
702: return z3fastmem2_bank.start + currprefs.z3fastmem2_size;
703: if (currprefs.z3fastmem_size)
704: return z3fastmem_bank.start + currprefs.z3fastmem_size;
705: if (currprefs.z3chipmem_size)
706: return z3chipmem_bank.start + currprefs.z3chipmem_size;
707: if (currprefs.mbresmem_high_size)
708: return a3000hmem_bank.start + currprefs.mbresmem_high_size;
709: if (currprefs.mbresmem_low_size)
710: return a3000lmem_bank.start + currprefs.mbresmem_low_size;
711: if (currprefs.bogomem_size)
712: return bogomem_bank.start + currprefs.bogomem_size;
713: if (currprefs.fastmem_size)
714: return fastmem_bank.start + currprefs.fastmem_size;
715: return currprefs.chipmem_size;
716: }
717:
718: static uaecptr nextaddr2 (uaecptr addr, int *next)
719: {
720: uaecptr prev, prevx;
721: int size, sizex;
722:
723: if (addr >= lastaddr ()) {
724: *next = -1;
725: return 0xffffffff;
726: }
727: prev = currprefs.z3autoconfig_start + currprefs.z3fastmem_size;
728: size = currprefs.z3fastmem2_size;
729:
730: if (currprefs.z3fastmem_size) {
731: prevx = prev;
732: sizex = size;
733: size = currprefs.z3fastmem_size;
734: prev = z3fastmem_bank.start;
735: if (addr == prev + size) {
736: *next = prevx + sizex;
737: return prevx;
738: }
739: }
740: if (currprefs.z3chipmem_size) {
741: prevx = prev;
742: sizex = size;
743: size = currprefs.z3chipmem_size;
744: prev = z3chipmem_bank.start;
745: if (addr == prev + size) {
746: *next = prevx + sizex;
747: return prevx;
748: }
749: }
750: if (currprefs.mbresmem_high_size) {
751: sizex = size;
752: prevx = prev;
753: size = currprefs.mbresmem_high_size;
754: prev = a3000hmem_bank.start;
755: if (addr == prev + size) {
756: *next = prevx + sizex;
757: return prevx;
758: }
759: }
760: if (currprefs.mbresmem_low_size) {
761: prevx = prev;
762: sizex = size;
763: size = currprefs.mbresmem_low_size;
764: prev = a3000lmem_bank.start;
765: if (addr == prev + size) {
766: *next = prevx + sizex;
767: return prevx;
768: }
769: }
770: if (currprefs.bogomem_size) {
771: sizex = size;
772: prevx = prev;
773: size = currprefs.bogomem_size;
774: prev = bogomem_bank.start;
775: if (addr == prev + size) {
776: *next = prevx + sizex;
777: return prevx;
778: }
779: }
780: if (currprefs.fastmem_size) {
781: sizex = size;
782: prevx = prev;
783: size = currprefs.fastmem_size;
784: prev = fastmem_bank.start;
785: if (addr == prev + size) {
786: *next = prevx + sizex;
787: return prevx;
788: }
789: }
790: sizex = size;
791: prevx = prev;
792: size = currprefs.chipmem_size;
793: if (addr == size) {
794: *next = prevx + sizex;
795: return prevx;
796: }
797: if (addr == 1)
798: *next = size;
799: return addr;
800: }
801:
802: static uaecptr nextaddr (uaecptr addr, uaecptr last, uaecptr *end)
803: {
804: static uaecptr old;
805: uaecptr paddr = addr;
806: int next = last;
807: if (last && 0) {
808: if (addr >= last)
809: return 0xffffffff;
810: return addr + 1;
811: }
812: if (addr == 0xffffffff) {
813: if (end)
814: *end = currprefs.chipmem_size;
815: return 0;
816: }
817: if (end)
818: next = *end;
819: addr = nextaddr2 (addr + 1, &next);
820: if (end)
821: *end = next;
822: if (old != next) {
823: if (addr != 0xffffffff)
824: console_out_f (_T("Scanning.. %08x - %08x (%s)\n"), addr & 0xffffff00, next, get_mem_bank (addr).name);
825: old = next;
826: }
827: #if 0
828: if (next && addr != 0xffffffff) {
829: uaecptr xa = addr;
830: if (xa == 1)
831: xa = 0;
832: console_out_f ("%08X -> %08X (%08X)...\n", xa, xa + next - 1, next);
833: }
834: #endif
835: return addr;
836: }
837:
838: uaecptr dumpmem2 (uaecptr addr, TCHAR *out, int osize)
839: {
840: int i, cols = 8;
841: int nonsafe = 0;
842:
843: if (osize <= (9 + cols * 5 + 1 + 2 * cols))
844: return addr;
845: _stprintf (out, _T("%08X "), addr);
846: for (i = 0; i < cols; i++) {
847: uae_u8 b1, b2;
848: b1 = b2 = 0;
849: if (safe_addr (addr, 1)) {
850: b1 = get_byte_debug (addr + 0);
851: b2 = get_byte_debug (addr + 1);
852: _stprintf (out + 9 + i * 5, _T("%02X%02X "), b1, b2);
853: out[9 + cols * 5 + 1 + i * 2 + 0] = b1 >= 32 && b1 < 127 ? b1 : '.';
854: out[9 + cols * 5 + 1 + i * 2 + 1] = b2 >= 32 && b2 < 127 ? b2 : '.';
855: } else {
856: nonsafe++;
857: _tcscpy (out + 9 + i * 5, _T("**** "));
858: out[9 + cols * 5 + 1 + i * 2 + 0] = '*';
859: out[9 + cols * 5 + 1 + i * 2 + 1] = '*';
860: }
861: addr += 2;
862: }
863: out[9 + cols * 5] = ' ';
864: out[9 + cols * 5 + 1 + 2 * cols] = 0;
865: if (nonsafe == cols) {
866: addrbank *ab = &get_mem_bank (addr);
867: if (ab->name)
868: memcpy (out + (9 + 4 + 1) * sizeof (TCHAR), ab->name, _tcslen (ab->name) * sizeof (TCHAR));
869: }
870: return addr;
871: }
872:
873: static void dumpmem (uaecptr addr, uaecptr *nxmem, int lines)
874: {
875: TCHAR line[MAX_LINEWIDTH + 1];
876: for (;lines--;) {
877: addr = dumpmem2 (addr, line, sizeof(line));
878: debug_out (_T("%s"), line);
879: if (!debug_out (_T("\n")))
880: break;
881: }
882: *nxmem = addr;
883: }
884:
885: static void dump_custom_regs (int aga)
886: {
887: int len, i, j, end;
888: uae_u8 *p1, *p2, *p3, *p4;
889:
890: if (aga) {
891: dump_aga_custom();
892: return;
893: }
894:
895: p1 = p2 = save_custom (&len, 0, 1);
896: p1 += 4; // skip chipset type
897: for (i = 0; i < 4; i++) {
898: p4 = p1 + 0xa0 + i * 16;
899: p3 = save_audio (i, &len, 0);
900: p4[0] = p3[12];
901: p4[1] = p3[13];
902: p4[2] = p3[14];
903: p4[3] = p3[15];
904: p4[4] = p3[4];
905: p4[5] = p3[5];
906: p4[6] = p3[8];
907: p4[7] = p3[9];
908: p4[8] = 0;
909: p4[9] = p3[1];
910: p4[10] = p3[10];
911: p4[11] = p3[11];
912: free (p3);
913: }
914: end = 0;
915: while (custd[end].name)
916: end++;
917: end++;
918: end /= 2;
919: for (i = 0; i < end; i++) {
920: uae_u16 v1, v2;
921: int addr1, addr2;
922: j = end + i;
923: addr1 = custd[i].adr & 0x1ff;
924: addr2 = custd[j].adr & 0x1ff;
925: v1 = (p1[addr1 + 0] << 8) | p1[addr1 + 1];
926: v2 = (p1[addr2 + 0] << 8) | p1[addr2 + 1];
927: console_out_f (_T("%03X %s\t%04X\t%03X %s\t%04X\n"),
928: addr1, custd[i].name, v1,
929: addr2, custd[j].name, v2);
930: }
931: free (p2);
932: }
933:
934: static void dump_vectors (uaecptr addr)
935: {
936: int i = 0, j = 0;
937:
938: if (addr == 0xffffffff)
939: addr = regs.vbr;
940:
941: while (int_labels[i].name || trap_labels[j].name) {
942: if (int_labels[i].name) {
943: console_out_f (_T("$%08X %02d: %12s $%08X "), int_labels[i].adr + addr, int_labels[i].adr / 4,
944: int_labels[i].name, get_long_debug (int_labels[i].adr + addr));
945: i++;
946: }
947: if (trap_labels[j].name) {
948: console_out_f (_T("$%08X %02d: %12s $%08X"), trap_labels[j].adr + addr, trap_labels[j].adr / 4,
949: trap_labels[j].name, get_long_debug (trap_labels[j].adr + addr));
950: j++;
951: }
952: console_out (_T("\n"));
953: }
954: }
955:
956: static void disassemble_wait (FILE *file, unsigned long insn)
957: {
958: int vp, hp, ve, he, bfd, v_mask, h_mask;
959: int doout = 0;
960:
961: vp = (insn & 0xff000000) >> 24;
962: hp = (insn & 0x00fe0000) >> 16;
963: ve = (insn & 0x00007f00) >> 8;
964: he = (insn & 0x000000fe);
965: bfd = (insn & 0x00008000) >> 15;
966:
967: /* bit15 can never be masked out*/
968: v_mask = vp & (ve | 0x80);
969: h_mask = hp & he;
970: if (v_mask > 0) {
971: doout = 1;
972: console_out (_T("vpos "));
973: if (ve != 0x7f) {
974: console_out_f (_T("& 0x%02x "), ve);
975: }
976: console_out_f (_T(">= 0x%02x"), v_mask);
977: }
978: if (he > 0) {
979: if (v_mask > 0) {
980: console_out (_T(" and"));
981: }
982: console_out (_T(" hpos "));
983: if (he != 0xfe) {
984: console_out_f (_T("& 0x%02x "), he);
985: }
986: console_out_f (_T(">= 0x%02x"), h_mask);
987: } else {
988: if (doout)
989: console_out (_T(", "));
990: console_out (_T(", ignore horizontal"));
991: }
992:
993: console_out_f (_T("\n \t; VP %02x, VE %02x; HP %02x, HE %02x; BFD %d\n"),
994: vp, ve, hp, he, bfd);
995: }
996:
997: #define NR_COPPER_RECORDS 100000
998: /* Record copper activity for the debugger. */
999: struct cop_rec
1000: {
1001: uae_u16 w1, w2;
1002: int hpos, vpos;
1003: int bhpos, bvpos;
1004: uaecptr addr;
1005: };
1006: static struct cop_rec *cop_record[2];
1007: static int nr_cop_records[2], curr_cop_set;
1008:
1009: #define NR_DMA_REC_HPOS 256
1010: #define NR_DMA_REC_VPOS 1000
1011: static struct dma_rec *dma_record[2];
1012: static int dma_record_toggle;
1013:
1014: void record_dma_reset (void)
1015: {
1016: int v, h;
1017: struct dma_rec *dr, *dr2;
1018:
1019: if (!dma_record[0])
1020: return;
1021: dma_record_toggle ^= 1;
1022: dr = dma_record[dma_record_toggle];
1023: for (v = 0; v < NR_DMA_REC_VPOS; v++) {
1024: for (h = 0; h < NR_DMA_REC_HPOS; h++) {
1025: dr2 = &dr[v * NR_DMA_REC_HPOS + h];
1026: memset (dr2, 0, sizeof (struct dma_rec));
1027: dr2->reg = 0xffff;
1028: dr2->addr = 0xffffffff;
1029: }
1030: }
1031: }
1032:
1033: void record_copper_reset (void)
1034: {
1035: /* Start a new set of copper records. */
1036: curr_cop_set ^= 1;
1037: nr_cop_records[curr_cop_set] = 0;
1038: }
1039:
1040: STATIC_INLINE uae_u32 ledcolor (uae_u32 c, uae_u32 *rc, uae_u32 *gc, uae_u32 *bc, uae_u32 *a)
1041: {
1042: uae_u32 v = rc[(c >> 16) & 0xff] | gc[(c >> 8) & 0xff] | bc[(c >> 0) & 0xff];
1043: if (a)
1044: v |= a[255 - ((c >> 24) & 0xff)];
1045: return v;
1046: }
1047:
1048: STATIC_INLINE void putpixel (uae_u8 *buf, int bpp, int x, xcolnr c8)
1049: {
1050: if (x <= 0)
1051: return;
1052:
1053: switch (bpp) {
1054: case 1:
1055: buf[x] = (uae_u8)c8;
1056: break;
1057: case 2:
1058: {
1059: uae_u16 *p = (uae_u16*)buf + x;
1060: *p = (uae_u16)c8;
1061: break;
1062: }
1063: case 3:
1064: /* no 24 bit yet */
1065: break;
1066: case 4:
1067: {
1068: uae_u32 *p = (uae_u32*)buf + x;
1069: *p = c8;
1070: break;
1071: }
1072: }
1073: }
1074:
1075: #define lc(x) ledcolor (x, xredcolors, xgreencolors, xbluecolors, NULL)
1076:
1077: static uae_u32 intlevc[] = { 0x000000, 0x444444, 0x008800, 0xffff00, 0x000088, 0x880000, 0xff0000, 0xffffff };
1078:
1079: void debug_draw_cycles (uae_u8 *buf, int bpp, int line, int width, int height, uae_u32 *xredcolors, uae_u32 *xgreencolors, uae_u32 *xbluescolors)
1080: {
1081: int y, x, xx, dx, xplus, yplus;
1082: struct dma_rec *dr;
1083: int t;
1084: uae_u32 cc[DMARECORD_MAX];
1085:
1086: if (debug_dma >= 4)
1087: yplus = 2;
1088: else
1089: yplus = 1;
1090: if (debug_dma >= 3)
1091: xplus = 2;
1092: else
1093: xplus = 1;
1094:
1095: t = dma_record_toggle ^ 1;
1096: y = line / yplus - 8;
1097:
1098: if (y < 0)
1099: return;
1100: if (y > maxvpos)
1101: return;
1102: if (y >= height)
1103: return;
1104:
1105: dx = width - xplus * ((maxhpos + 1) & ~1) - 16;
1106:
1107: cc[0] = lc(0x222222);
1108: cc[DMARECORD_REFRESH] = lc(0x444444);
1109: cc[DMARECORD_CPU] = lc(0x888888);
1110: cc[DMARECORD_COPPER] = lc(0xeeee00);
1111: cc[DMARECORD_AUDIO] = lc(0xff0000);
1112: cc[DMARECORD_BLITTER] = lc(0x008888);
1113: cc[DMARECORD_BLITTER_FILL] = lc(0x0088ff);
1114: cc[DMARECORD_BLITTER_LINE] = lc(0x00ff00);
1115: cc[DMARECORD_BITPLANE] = lc(0x0000ff);
1116: cc[DMARECORD_SPRITE] = lc(0xff00ff);
1117: cc[DMARECORD_DISK] = lc(0xffffff);
1118:
1119: uae_s8 intlev = 0;
1120: for (x = 0; x < maxhpos; x++) {
1121: uae_u32 c = cc[0];
1122: xx = x * xplus + dx;
1123: dr = &dma_record[t][y * NR_DMA_REC_HPOS + x];
1124: if (dr->reg != 0xffff) {
1125: c = cc[dr->type];
1126: }
1127: if (dr->intlev > intlev)
1128: intlev = dr->intlev;
1129: putpixel (buf, bpp, xx + 4, c);
1130: if (xplus)
1131: putpixel (buf, bpp, xx + 4 + 1, c);
1132: }
1133: putpixel (buf, bpp, dx + 0, 0);
1134: putpixel (buf, bpp, dx + 1, lc(intlevc[intlev]));
1135: putpixel (buf, bpp, dx + 2, lc(intlevc[intlev]));
1136: putpixel (buf, bpp, dx + 3, 0);
1137: }
1138:
1139: #define HEATMAP_COUNT 50
1140: static struct memory_heatmap *heatmap;
1141: struct memory_heatmap
1142: {
1143: uae_u16 cnt;
1144: uae_u16 type;
1145: };
1146:
1147: static void memwatch_heatmap (uaecptr addr, int rwi, int size)
1148: {
1149: }
1150:
1151: static void record_dma_heatmap (uaecptr addr, int type)
1152: {
1153: if (addr >= 0x01000000 || !heatmap)
1154: return;
1155: struct memory_heatmap *hp = &heatmap[addr / 2];
1156: hp->cnt = HEATMAP_COUNT;
1157: hp->type = type;
1158: }
1159:
1160: void record_dma_event (int evt, int hpos, int vpos)
1161: {
1162: struct dma_rec *dr;
1163:
1164: if (!dma_record[0])
1165: return;
1166: if (hpos >= NR_DMA_REC_HPOS || vpos >= NR_DMA_REC_VPOS)
1167: return;
1168: dr = &dma_record[dma_record_toggle][vpos * NR_DMA_REC_HPOS + hpos];
1169: dr->evt |= evt;
1170: }
1171:
1172: struct dma_rec *record_dma (uae_u16 reg, uae_u16 dat, uae_u32 addr, int hpos, int vpos, int type)
1173: {
1174: struct dma_rec *dr;
1175:
1176: if (!heatmap)
1177: heatmap = xcalloc (struct memory_heatmap, 16 * 1024 * 1024 / 2);
1178: if (!dma_record[0]) {
1179: dma_record[0] = xmalloc (struct dma_rec, NR_DMA_REC_HPOS * NR_DMA_REC_VPOS);
1180: dma_record[1] = xmalloc (struct dma_rec, NR_DMA_REC_HPOS * NR_DMA_REC_VPOS);
1181: dma_record_toggle = 0;
1182: record_dma_reset ();
1183: }
1184: if (hpos >= NR_DMA_REC_HPOS || vpos >= NR_DMA_REC_VPOS)
1185: return NULL;
1186:
1187: record_dma_heatmap (addr, type);
1188:
1189: dr = &dma_record[dma_record_toggle][vpos * NR_DMA_REC_HPOS + hpos];
1190: if (dr->reg != 0xffff) {
1191: write_log (_T("DMA conflict: v=%d h=%d OREG=%04X NREG=%04X\n"), vpos, hpos, dr->reg, reg);
1192: return dr;
1193: }
1194: dr->reg = reg;
1195: dr->dat = dat;
1196: dr->addr = addr;
1197: dr->type = type;
1198: dr->intlev = regs.intmask;
1199: return dr;
1200: }
1201:
1202: static void decode_dma_record (int hpos, int vpos, int toggle, bool logfile)
1203: {
1204: struct dma_rec *dr;
1205: int h, i, maxh, cnt;
1206: uae_u32 cycles;
1207:
1208: if (!dma_record[0])
1209: return;
1210: dr = &dma_record[dma_record_toggle ^ toggle][vpos * NR_DMA_REC_HPOS];
1211: if (logfile)
1212: write_dlog (_T("Line: %02X %3d HPOS %02X %3d:\n"), vpos, vpos, hpos, hpos);
1213: else
1214: console_out_f (_T("Line: %02X %3d HPOS %02X %3d:\n"), vpos, vpos, hpos, hpos);
1215: h = hpos;
1216: dr += hpos;
1217: maxh = hpos + 80;
1218: if (maxh > maxhpos)
1219: maxh = maxhpos;
1220: cycles = vsync_cycles;
1221: if (toggle)
1222: cycles -= maxvpos * maxhpos * CYCLE_UNIT;
1223: cnt = 0;
1224: while (h < maxh) {
1225: int col = 9;
1226: int cols = 8;
1227: TCHAR l1[81];
1228: TCHAR l2[81];
1229: TCHAR l3[81];
1230: TCHAR l4[81];
1231: TCHAR l5[81];
1232: for (i = 0; i < cols && h < maxh; i++, h++, dr++) {
1233: int cl = i * col, cl2;
1234: int r = dr->reg;
1235: bool longsize = false;
1236: TCHAR *sr;
1237:
1238: sr = _T(" ");
1239: if (dr->type == DMARECORD_COPPER)
1240: sr = _T("COP ");
1241: else if (dr->type == DMARECORD_BLITTER)
1242: sr = _T("BLT ");
1243: else if (dr->type == DMARECORD_BLITTER_LINE)
1244: sr = _T("BLL ");
1245: else if (dr->type == DMARECORD_REFRESH)
1246: sr = _T("RFS ");
1247: else if (dr->type == DMARECORD_AUDIO)
1248: sr = _T("AUD ");
1249: else if (dr->type == DMARECORD_DISK)
1250: sr = _T("DSK ");
1251: else if (dr->type == DMARECORD_SPRITE)
1252: sr = _T("SPR ");
1253: _stprintf (l1 + cl, _T("[%02X %3d]"), h, h);
1254: _tcscpy (l4 + cl, _T(" "));
1255: if (r != 0xffff) {
1256: if (r & 0x1000) {
1257: if ((r & 0x0100) == 0x0000)
1258: _tcscpy (l2 + cl, _T(" CPU-R "));
1259: else if ((r & 0x0100) == 0x0100)
1260: _tcscpy (l2 + cl, _T(" CPU-W "));
1261: if ((r & 0xff) == 4) {
1262: l2[cl + 7] = 'L';
1263: longsize = true;
1264: }
1265: if ((r & 0xff) == 2)
1266: l2[cl + 7] = 'W';
1267: if ((r & 0xff) == 1)
1268: l2[cl + 7] = 'B';
1269: } else {
1270: _stprintf (l2 + cl, _T("%4s %03X"), sr, r);
1271: }
1272: _stprintf (l3 + cl, longsize ? _T("%08X") : _T(" %04X"), dr->dat);
1273: if (dr->addr != 0xffffffff)
1274: _stprintf (l4 + cl, _T("%08X"), dr->addr & 0x00ffffff);
1275: } else {
1276: _tcscpy (l2 + cl, _T(" "));
1277: _tcscpy (l3 + cl, _T(" "));
1278: }
1279: cl2 = cl;
1280: if (dr->evt & DMA_EVENT_BLITNASTY)
1281: l3[cl2++] = 'N';
1282: if (dr->evt & DMA_EVENT_BLITSTARTFINISH)
1283: l3[cl2++] = 'B';
1284: if (dr->evt & DMA_EVENT_BLITIRQ)
1285: l3[cl2++] = 'b';
1286: if (dr->evt & DMA_EVENT_BPLFETCHUPDATE)
1287: l3[cl2++] = 'p';
1288: if (dr->evt & DMA_EVENT_COPPERWAKE)
1289: l3[cl2++] = 'W';
1290: if (dr->evt & DMA_EVENT_COPPERWANTED)
1291: l3[cl2++] = 'c';
1292: if (dr->evt & DMA_EVENT_CPUIRQ)
1293: l3[cl2++] = 'I';
1294: if (dr->evt & DMA_EVENT_INTREQ)
1295: l3[cl2++] = 'i';
1296: _stprintf (l5 + cl, _T("%08X"), cycles + (vpos * maxhpos + (hpos + cnt)) * CYCLE_UNIT);
1297: if (i < cols - 1 && h < maxh - 1) {
1298: l1[cl + col - 1] = 32;
1299: l2[cl + col - 1] = 32;
1300: l3[cl + col - 1] = 32;
1301: l4[cl + col - 1] = 32;
1302: l5[cl + col - 1] = 32;
1303: }
1304: cnt++;
1305: }
1306: if (logfile) {
1307: write_dlog (_T("%s\n"), l1);
1308: write_dlog (_T("%s\n"), l2);
1309: write_dlog (_T("%s\n"), l3);
1310: write_dlog (_T("%s\n"), l4);
1311: write_dlog (_T("%s\n"), l5);
1312: write_dlog (_T("\n"));
1313: } else {
1314: console_out_f (_T("%s\n"), l1);
1315: console_out_f (_T("%s\n"), l2);
1316: console_out_f (_T("%s\n"), l3);
1317: console_out_f (_T("%s\n"), l4);
1318: console_out_f (_T("%s\n"), l5);
1319: console_out_f (_T("\n"));
1320: }
1321: }
1322: }
1323: void log_dma_record (void)
1324: {
1325: if (!input_record && !input_play)
1326: return;
1327: if (!debug_dma)
1328: debug_dma = 1;
1329: decode_dma_record (0, 0, 0, true);
1330: }
1331:
1332: static void init_record_copper(void)
1333: {
1334: if (!cop_record[0]) {
1335: cop_record[0] = xmalloc(struct cop_rec, NR_COPPER_RECORDS);
1336: cop_record[1] = xmalloc(struct cop_rec, NR_COPPER_RECORDS);
1337: }
1338: }
1339:
1340: void record_copper_blitwait (uaecptr addr, int hpos, int vpos)
1341: {
1342: int t = nr_cop_records[curr_cop_set];
1343: init_record_copper();
1344: cop_record[curr_cop_set][t].bhpos = hpos;
1345: cop_record[curr_cop_set][t].bvpos = vpos;
1346: }
1347:
1348: void record_copper (uaecptr addr, uae_u16 word1, uae_u16 word2, int hpos, int vpos)
1349: {
1350: int t = nr_cop_records[curr_cop_set];
1351: init_record_copper();
1352: if (t < NR_COPPER_RECORDS) {
1353: cop_record[curr_cop_set][t].addr = addr;
1354: cop_record[curr_cop_set][t].w1 = word1;
1355: cop_record[curr_cop_set][t].w2 = word2;
1356: cop_record[curr_cop_set][t].hpos = hpos;
1357: cop_record[curr_cop_set][t].vpos = vpos;
1358: cop_record[curr_cop_set][t].bvpos = -1;
1359: nr_cop_records[curr_cop_set] = t + 1;
1360: }
1361: if (debug_copper & 2) { /* trace */
1362: debug_copper &= ~2;
1363: activate_debugger ();
1364: }
1365: if ((debug_copper & 4) && addr >= debug_copper_pc && addr <= debug_copper_pc + 3) {
1366: debug_copper &= ~4;
1367: activate_debugger ();
1368: }
1369: }
1370:
1371: static struct cop_rec *find_copper_records (uaecptr addr)
1372: {
1373: int s = curr_cop_set ^ 1;
1374: int t = nr_cop_records[s];
1375: int i;
1376: for (i = 0; i < t; i++) {
1377: if (cop_record[s][i].addr == addr)
1378: return &cop_record[s][i];
1379: }
1380: return 0;
1381: }
1382:
1383: /* simple decode copper by Mark Cox */
1384: static void decode_copper_insn (FILE* file, uae_u16 mword1, uae_u16 mword2, unsigned long addr)
1385: {
1386: struct cop_rec *cr = NULL;
1387: uae_u32 insn_type, insn;
1388: TCHAR here = ' ';
1389: TCHAR record[] = _T(" ");
1390:
1391: if ((cr = find_copper_records (addr))) {
1392: _stprintf (record, _T(" [%03x %03x]"), cr->vpos, cr->hpos);
1393: insn = (cr->w1 << 16) | cr->w2;
1394: } else {
1395: insn = (mword1 << 16) | mword2;
1396: }
1397:
1398: insn_type = insn & 0x00010001;
1399:
1400: if (get_copper_address (-1) >= addr && get_copper_address(-1) <= addr + 3)
1401: here = '*';
1402:
1403: console_out_f (_T("%c%08x: %04x %04x%s\t;%c "), here, addr, insn >> 16, insn & 0xFFFF, record, insn != ((mword1 << 16) | mword2) ? '!' : ' ');
1404:
1405: switch (insn_type) {
1406: case 0x00010000: /* WAIT insn */
1407: console_out (_T("Wait for "));
1408: disassemble_wait (file, insn);
1409:
1410: if (insn == 0xfffffffe)
1411: console_out (_T(" \t; End of Copperlist\n"));
1412:
1413: break;
1414:
1415: case 0x00010001: /* SKIP insn */
1416: console_out (_T("Skip if "));
1417: disassemble_wait (file, insn);
1418: break;
1419:
1420: case 0x00000000:
1421: case 0x00000001: /* MOVE insn */
1422: {
1423: int addr = (insn >> 16) & 0x1fe;
1424: int i = 0;
1425: while (custd[i].name) {
1426: if (custd[i].adr == addr + 0xdff000)
1427: break;
1428: i++;
1429: }
1430: if (custd[i].name)
1431: console_out_f (_T("%s := 0x%04x\n"), custd[i].name, insn & 0xffff);
1432: else
1433: console_out_f (_T("%04x := 0x%04x\n"), addr, insn & 0xffff);
1434: }
1435: break;
1436:
1437: default:
1438: abort ();
1439: }
1440:
1441: if (cr && cr->bvpos >= 0) {
1442: console_out_f (_T(" BLT [%03x %03x]\n"), cr->bvpos, cr->bhpos);
1443: }
1444: }
1445:
1446: static uaecptr decode_copperlist (FILE* file, uaecptr address, int nolines)
1447: {
1448: while (nolines-- > 0) {
1449: decode_copper_insn (file, chipmem_wget_indirect (address), chipmem_wget_indirect (address + 2), address);
1450: address += 4;
1451: }
1452: return address;
1453: /* You may wonder why I don't stop this at the end of the copperlist?
1454: * Well, often nice things are hidden at the end and it is debatable the actual
1455: * values that mean the end of the copperlist */
1456: }
1457:
1458: static int copper_debugger (TCHAR **c)
1459: {
1460: static uaecptr nxcopper;
1461: uae_u32 maddr;
1462: int lines;
1463:
1464: if (**c == 'd') {
1465: next_char (c);
1466: if (debug_copper)
1467: debug_copper = 0;
1468: else
1469: debug_copper = 1;
1470: console_out_f (_T("Copper debugger %s.\n"), debug_copper ? _T("enabled") : _T("disabled"));
1471: } else if (**c == 't') {
1472: debug_copper = 1|2;
1473: return 1;
1474: } else if (**c == 'b') {
1475: (*c)++;
1476: debug_copper = 1|4;
1477: if (more_params (c)) {
1478: debug_copper_pc = readhex (c);
1479: console_out_f (_T("Copper breakpoint @0x%08x\n"), debug_copper_pc);
1480: } else {
1481: debug_copper &= ~4;
1482: }
1483: } else {
1484: if (more_params (c)) {
1485: maddr = readhex (c);
1486: if (maddr == 1 || maddr == 2)
1487: maddr = get_copper_address (maddr);
1488: else if (maddr == 0)
1489: maddr = get_copper_address (-1);
1490: } else
1491: maddr = nxcopper;
1492:
1493: if (more_params (c))
1494: lines = readhex (c);
1495: else
1496: lines = 20;
1497:
1498: nxcopper = decode_copperlist (stdout, maddr, lines);
1499: }
1500: return 0;
1501: }
1502:
1503: #define MAX_CHEAT_VIEW 100
1504: struct trainerstruct {
1505: uaecptr addr;
1506: int size;
1507: };
1508:
1509: static struct trainerstruct *trainerdata;
1510: static int totaltrainers;
1511:
1512: static void clearcheater(void)
1513: {
1514: if (!trainerdata)
1515: trainerdata = xmalloc(struct trainerstruct, MAX_CHEAT_VIEW);
1516: memset(trainerdata, 0, sizeof (struct trainerstruct) * MAX_CHEAT_VIEW);
1517: totaltrainers = 0;
1518: }
1519: static int addcheater(uaecptr addr, int size)
1520: {
1521: if (totaltrainers >= MAX_CHEAT_VIEW)
1522: return 0;
1523: trainerdata[totaltrainers].addr = addr;
1524: trainerdata[totaltrainers].size = size;
1525: totaltrainers++;
1526: return 1;
1527: }
1528: static void listcheater(int mode, int size)
1529: {
1530: int i, skip;
1531:
1532: if (!trainerdata)
1533: return;
1534: if (mode)
1535: skip = 6;
1536: else
1537: skip = 8;
1538: for(i = 0; i < totaltrainers; i++) {
1539: struct trainerstruct *ts = &trainerdata[i];
1540: uae_u16 b;
1541:
1542: if (size) {
1543: b = get_byte_debug (ts->addr);
1544: } else {
1545: b = get_word_debug (ts->addr);
1546: }
1547: if (mode)
1548: console_out_f (_T("%08X=%04X "), ts->addr, b);
1549: else
1550: console_out_f (_T("%08X "), ts->addr);
1551: if ((i % skip) == skip)
1552: console_out (_T("\n"));
1553: }
1554: }
1555:
1556: static void deepcheatsearch (TCHAR **c)
1557: {
1558: static int first = 1;
1559: static uae_u8 *memtmp;
1560: static int memsize, memsize2;
1561: uae_u8 *p1, *p2;
1562: uaecptr addr, end;
1563: int i, wasmodified, nonmodified;
1564: static int size;
1565: static int inconly, deconly, maxdiff;
1566: int addrcnt, cnt;
1567: TCHAR v;
1568:
1569: v = _totupper (**c);
1570:
1571: if(!memtmp || v == 'S') {
1572: maxdiff = 0x10000;
1573: inconly = 0;
1574: deconly = 0;
1575: size = 1;
1576: }
1577:
1578: if (**c)
1579: (*c)++;
1580: ignore_ws (c);
1581: if ((**c) == '1' || (**c) == '2') {
1582: size = **c - '0';
1583: (*c)++;
1584: }
1585: if (more_params (c))
1586: maxdiff = readint (c);
1587:
1588: if (!memtmp || v == 'S') {
1589: first = 1;
1590: xfree (memtmp);
1591: memsize = 0;
1592: addr = 0xffffffff;
1593: while ((addr = nextaddr (addr, 0, &end)) != 0xffffffff) {
1594: memsize += end - addr;
1595: addr = end - 1;
1596: }
1597: memsize2 = (memsize + 7) / 8;
1598: memtmp = xmalloc (uae_u8, memsize + memsize2);
1599: if (!memtmp)
1600: return;
1601: memset (memtmp + memsize, 0xff, memsize2);
1602: p1 = memtmp;
1603: addr = 0xffffffff;
1604: while ((addr = nextaddr (addr, 0, &end)) != 0xffffffff) {
1605: for (i = addr; i < end; i++)
1606: *p1++ = get_byte_debug (i);
1607: addr = end - 1;
1608: }
1609: console_out (_T("Deep trainer first pass complete.\n"));
1610: return;
1611: }
1612: inconly = deconly = 0;
1613: wasmodified = v == 'X' ? 0 : 1;
1614: nonmodified = v == 'Z' ? 1 : 0;
1615: if (v == 'I')
1616: inconly = 1;
1617: if (v == 'D')
1618: deconly = 1;
1619: p1 = memtmp;
1620: p2 = memtmp + memsize;
1621: addrcnt = 0;
1622: cnt = 0;
1623: addr = 0xffffffff;
1624: while ((addr = nextaddr (addr, 0, NULL)) != 0xffffffff) {
1625: uae_s32 b, b2;
1626: int doremove = 0;
1627: int addroff = addrcnt >> 3;
1628: int addrmask ;
1629:
1630: if (size == 1) {
1631: b = (uae_s8)get_byte_debug (addr);
1632: b2 = (uae_s8)p1[addrcnt];
1633: addrmask = 1 << (addrcnt & 7);
1634: } else {
1635: b = (uae_s16)get_word_debug (addr);
1636: b2 = (uae_s16)((p1[addrcnt] << 8) | p1[addrcnt + 1]);
1637: addrmask = 3 << (addrcnt & 7);
1638: }
1639:
1640: if (p2[addroff] & addrmask) {
1641: if (wasmodified && !nonmodified) {
1642: int diff = b - b2;
1643: if (b == b2)
1644: doremove = 1;
1645: if (abs(diff) > maxdiff)
1646: doremove = 1;
1647: if (inconly && diff < 0)
1648: doremove = 1;
1649: if (deconly && diff > 0)
1650: doremove = 1;
1651: } else if (nonmodified && b == b2) {
1652: doremove = 1;
1653: } else if (!wasmodified && b != b2) {
1654: doremove = 1;
1655: }
1656: if (doremove)
1657: p2[addroff] &= ~addrmask;
1658: else
1659: cnt++;
1660: }
1661: if (size == 1) {
1662: p1[addrcnt] = b;
1663: addrcnt++;
1664: } else {
1665: p1[addrcnt] = b >> 8;
1666: p1[addrcnt + 1] = b >> 0;
1667: addr = nextaddr (addr, 0, NULL);
1668: if (addr == 0xffffffff)
1669: break;
1670: addrcnt += 2;
1671: }
1672: if (iscancel (65536)) {
1673: console_out_f (_T("Aborted at %08X\n"), addr);
1674: break;
1675: }
1676: }
1677:
1678: console_out_f (_T("%d addresses found\n"), cnt);
1679: if (cnt <= MAX_CHEAT_VIEW) {
1680: clearcheater ();
1681: cnt = 0;
1682: addrcnt = 0;
1683: addr = 0xffffffff;
1684: while ((addr = nextaddr(addr, 0, NULL)) != 0xffffffff) {
1685: int addroff = addrcnt >> 3;
1686: int addrmask = (size == 1 ? 1 : 3) << (addrcnt & 7);
1687: if (p2[addroff] & addrmask)
1688: addcheater (addr, size);
1689: addrcnt += size;
1690: cnt++;
1691: }
1692: if (cnt > 0)
1693: console_out (_T("\n"));
1694: listcheater (1, size);
1695: } else {
1696: console_out (_T("Now continue with 'g' and use 'D' again after you have lost another life\n"));
1697: }
1698: }
1699:
1700: /* cheat-search by Toni Wilen (originally by Holger Jakob) */
1701: static void cheatsearch (TCHAR **c)
1702: {
1703: static uae_u8 *vlist;
1704: static int listsize;
1705: static int first = 1;
1706: static int size = 1;
1707: uae_u32 val, memcnt, prevmemcnt;
1708: int i, count, vcnt, memsize;
1709: uaecptr addr, end;
1710:
1711: memsize = 0;
1712: addr = 0xffffffff;
1713: while ((addr = nextaddr (addr, 0, &end)) != 0xffffffff) {
1714: memsize += end - addr;
1715: addr = end - 1;
1716: }
1717:
1718: if (_totupper (**c) == 'L') {
1719: listcheater (1, size);
1720: return;
1721: }
1722: ignore_ws (c);
1723: if (!more_params (c)) {
1724: first = 1;
1725: console_out (_T("Search reset\n"));
1726: xfree (vlist);
1727: listsize = memsize;
1728: vlist = xcalloc (uae_u8, listsize >> 3);
1729: return;
1730: }
1731: if (first)
1732: val = readint (c, &size);
1733: else
1734: val = readint (c);
1735:
1736: if (vlist == NULL) {
1737: listsize = memsize;
1738: vlist = xcalloc (uae_u8, listsize >> 3);
1739: }
1740:
1741: count = 0;
1742: vcnt = 0;
1743:
1744: clearcheater ();
1745: addr = 0xffffffff;
1746: prevmemcnt = memcnt = 0;
1747: while ((addr = nextaddr (addr, 0, &end)) != 0xffffffff) {
1748: if (addr + size < end) {
1749: for (i = 0; i < size; i++) {
1750: int shift = (size - i - 1) * 8;
1751: if (get_byte_debug (addr + i) != ((val >> shift) & 0xff))
1752: break;
1753: }
1754: if (i == size) {
1755: int voffset = memcnt >> 3;
1756: int vmask = 1 << (memcnt & 7);
1757: if (!first) {
1758: while (prevmemcnt < memcnt) {
1759: vlist[prevmemcnt >> 3] &= ~(1 << (prevmemcnt & 7));
1760: prevmemcnt++;
1761: }
1762: if (vlist[voffset] & vmask) {
1763: count++;
1764: addcheater(addr, size);
1765: } else {
1766: vlist[voffset] &= ~vmask;
1767: }
1768: prevmemcnt = memcnt + 1;
1769: } else {
1770: vlist[voffset] |= vmask;
1771: count++;
1772: }
1773: }
1774: }
1775: memcnt++;
1776: if (iscancel (65536)) {
1777: console_out_f (_T("Aborted at %08X\n"), addr);
1778: break;
1779: }
1780: }
1781: if (!first) {
1782: while (prevmemcnt < memcnt) {
1783: vlist[prevmemcnt >> 3] &= ~(1 << (prevmemcnt & 7));
1784: prevmemcnt++;
1785: }
1786: listcheater (0, size);
1787: }
1788: console_out_f (_T("Found %d possible addresses with 0x%X (%u) (%d bytes)\n"), count, val, val, size);
1789: if (count > 0)
1790: console_out (_T("Now continue with 'g' and use 'C' with a different value\n"));
1791: first = 0;
1792: }
1793:
1794: struct breakpoint_node bpnodes[BREAKPOINT_TOTAL];
1795: static addrbank **debug_mem_banks;
1796: static addrbank *debug_mem_area;
1797: struct memwatch_node mwnodes[MEMWATCH_TOTAL];
1798: static struct memwatch_node mwhit;
1799: static int addressspaceheatmap;
1800:
1801: static uae_u8 *illgdebug, *illghdebug;
1802: static int illgdebug_break;
1803:
1804: static void illg_free (void)
1805: {
1806: xfree (illgdebug);
1807: illgdebug = NULL;
1808: xfree (illghdebug);
1809: illghdebug = NULL;
1810: }
1811:
1812: static void illg_init (void)
1813: {
1814: int i;
1815: uae_u8 c = 3;
1816: uaecptr addr, end;
1817:
1818: illgdebug = xcalloc (uae_u8, 0x01000000);
1819: illghdebug = xcalloc (uae_u8, 65536);
1820: if (!illgdebug || !illghdebug) {
1821: illg_free();
1822: return;
1823: }
1824: addr = 0xffffffff;
1825: while ((addr = nextaddr (addr, 0, &end)) != 0xffffffff) {
1826: if (end < 0x01000000) {
1827: memset (illgdebug + addr, c, end - addr);
1828: } else {
1829: uae_u32 s = addr >> 16;
1830: uae_u32 e = end >> 16;
1831: memset (illghdebug + s, c, e - s);
1832: }
1833: addr = end - 1;
1834: }
1835: if (currprefs.rtgmem_size)
1836: memset (illghdebug + (gfxmem_bank.start >> 16), 3, currprefs.rtgmem_size >> 16);
1837:
1838: i = 0;
1839: while (custd[i].name) {
1840: int rw = custd[i].rw;
1841: illgdebug[custd[i].adr] = rw;
1842: illgdebug[custd[i].adr + 1] = rw;
1843: i++;
1844: }
1845: for (i = 0; i < 16; i++) { /* CIAs */
1846: if (i == 11)
1847: continue;
1848: illgdebug[0xbfe001 + i * 0x100] = c;
1849: illgdebug[0xbfd000 + i * 0x100] = c;
1850: }
1851: memset (illgdebug + 0xf80000, 1, 512 * 1024); /* KS ROM */
1852: memset (illgdebug + 0xdc0000, c, 0x3f); /* clock */
1853: #ifdef CDTV
1854: if (currprefs.cs_cdtvram) {
1855: memset (illgdebug + 0xdc8000, c, 4096); /* CDTV batt RAM */
1856: memset (illgdebug + 0xf00000, 1, 256 * 1024); /* CDTV ext ROM */
1857: }
1858: #endif
1859: #ifdef CD32
1860: if (currprefs.cs_cd32cd) {
1861: memset (illgdebug + AKIKO_BASE, c, AKIKO_BASE_END - AKIKO_BASE);
1862: memset (illgdebug + 0xe00000, 1, 512 * 1024); /* CD32 ext ROM */
1863: }
1864: #endif
1865: if (currprefs.cs_ksmirror_e0)
1866: memset (illgdebug + 0xe00000, 1, 512 * 1024);
1867: if (currprefs.cs_ksmirror_a8)
1868: memset (illgdebug + 0xa80000, 1, 2 * 512 * 1024);
1869: #ifdef FILESYS
1870: if (uae_boot_rom_type) /* filesys "rom" */
1871: memset (illgdebug + rtarea_base, 1, 0x10000);
1872: #endif
1873: if (currprefs.cs_ide > 0)
1874: memset (illgdebug + 0xdd0000, 3, 65536);
1875: }
1876:
1877: /* add special custom register check here */
1878: static void illg_debug_check (uaecptr addr, int rwi, int size, uae_u32 val)
1879: {
1880: return;
1881: }
1882:
1883: static void illg_debug_do (uaecptr addr, int rwi, int size, uae_u32 val)
1884: {
1885: uae_u8 mask;
1886: uae_u32 pc = m68k_getpc ();
1887: int i;
1888:
1889: for (i = size - 1; i >= 0; i--) {
1890: uae_u8 v = val >> (i * 8);
1891: uae_u32 ad = addr + i;
1892: if (ad >= 0x01000000)
1893: mask = illghdebug[ad >> 16];
1894: else
1895: mask = illgdebug[ad];
1896: if ((mask & 3) == 3)
1897: return;
1898: if (mask & 0x80) {
1899: illg_debug_check (ad, rwi, size, val);
1900: } else if ((mask & 3) == 0) {
1901: if (rwi & 2)
1902: console_out_f (_T("W: %08X=%02X PC=%08X\n"), ad, v, pc);
1903: else if (rwi & 1)
1904: console_out_f (_T("R: %08X PC=%08X\n"), ad, pc);
1905: if (illgdebug_break)
1906: activate_debugger ();
1907: } else if (!(mask & 1) && (rwi & 1)) {
1908: console_out_f (_T("RO: %08X=%02X PC=%08X\n"), ad, v, pc);
1909: if (illgdebug_break)
1910: activate_debugger ();
1911: } else if (!(mask & 2) && (rwi & 2)) {
1912: console_out_f (_T("WO: %08X PC=%08X\n"), ad, pc);
1913: if (illgdebug_break)
1914: activate_debugger ();
1915: }
1916: }
1917: }
1918:
1919: static int debug_mem_off (uaecptr *addrp)
1920: {
1921: uaecptr addr = *addrp;
1922: addrbank *ba;
1923: int offset = munge24 (addr) >> 16;
1924: if (!debug_mem_banks)
1925: return offset;
1926: ba = debug_mem_banks[offset];
1927: if (!ba)
1928: return offset;
1929: if (ba->mask || ba->startmask)
1930: addr = (addr & ba->mask) | ba->startmask;
1931: *addrp = addr;
1932: return offset;
1933: }
1934:
1935: struct smc_item {
1936: uae_u32 addr;
1937: uae_u8 cnt;
1938: };
1939:
1940: static int smc_size, smc_mode;
1941: static struct smc_item *smc_table;
1942:
1943: static void smc_free (void)
1944: {
1945: if (smc_table)
1946: console_out (_T("SMCD disabled\n"));
1947: xfree(smc_table);
1948: smc_mode = 0;
1949: smc_table = NULL;
1950: }
1951:
1952: static void initialize_memwatch (int mode);
1953: static void smc_detect_init (TCHAR **c)
1954: {
1955: int v, i;
1956:
1957: ignore_ws (c);
1958: v = readint (c);
1959: smc_free ();
1960: smc_size = 1 << 24;
1961: if (currprefs.z3fastmem_size)
1962: smc_size = currprefs.z3autoconfig_start + currprefs.z3fastmem_size;
1963: smc_size += 4;
1964: smc_table = xmalloc (struct smc_item, smc_size);
1965: if (!smc_table)
1966: return;
1967: for (i = 0; i < smc_size; i++) {
1968: smc_table[i].addr = 0xffffffff;
1969: smc_table[i].cnt = 0;
1970: }
1971: if (!memwatch_enabled)
1972: initialize_memwatch (0);
1973: if (v)
1974: smc_mode = 1;
1975: console_out_f (_T("SMCD enabled. Break=%d\n"), smc_mode);
1976: }
1977:
1978: #define SMC_MAXHITS 8
1979: static void smc_detector (uaecptr addr, int rwi, int size, uae_u32 *valp)
1980: {
1981: int i, hitcnt;
1982: uaecptr hitaddr, hitpc;
1983:
1984: if (!smc_table)
1985: return;
1986: if (addr >= smc_size)
1987: return;
1988: if (rwi == 2) {
1989: for (i = 0; i < size; i++) {
1990: if (smc_table[addr + i].cnt < SMC_MAXHITS) {
1991: smc_table[addr + i].addr = m68k_getpc ();
1992: }
1993: }
1994: return;
1995: }
1996: hitpc = smc_table[addr].addr;
1997: if (hitpc == 0xffffffff)
1998: return;
1999: hitaddr = addr;
2000: hitcnt = 0;
2001: while (addr < smc_size && smc_table[addr].addr != 0xffffffff) {
2002: smc_table[addr++].addr = 0xffffffff;
2003: hitcnt++;
2004: }
2005: if ((hitpc & 0xFFF80000) == 0xF80000)
2006: return;
2007: if (currprefs.cpu_model == 68000 && currprefs.cpu_compatible) {
2008: /* ignore single-word unconditional jump instructions
2009: * (instruction prefetch from PC+2 can cause false positives) */
2010: if (regs.irc == 0x4e75 || regs.irc == 4e74 || regs.irc == 0x4e72 || regs.irc == 0x4e77)
2011: return; /* RTS, RTD, RTE, RTR */
2012: if ((regs.irc & 0xff00) == 0x6000 && (regs.irc & 0x00ff) != 0 && (regs.irc & 0x00ff) != 0xff)
2013: return; /* BRA.B */
2014: }
2015: if (hitcnt < 100) {
2016: smc_table[hitaddr].cnt++;
2017: console_out_f (_T("SMC at %08X - %08X (%d) from %08X\n"),
2018: hitaddr, hitaddr + hitcnt, hitcnt, hitpc);
2019: if (smc_mode)
2020: activate_debugger ();
2021: if (smc_table[hitaddr].cnt >= SMC_MAXHITS)
2022: console_out_f (_T("* hit count >= %d, future hits ignored\n"), SMC_MAXHITS);
2023: }
2024: }
2025:
2026: uae_u8 *save_debug_memwatch (int *len, uae_u8 *dstptr)
2027: {
2028: uae_u8 *dstbak, *dst;
2029: int total;
2030:
2031: total = 0;
2032: for (int i = 0; i < MEMWATCH_TOTAL; i++) {
2033: if (mwnodes[i].size > 0)
2034: total++;
2035: }
2036: if (!total)
2037: return NULL;
2038:
2039: if (dstptr)
2040: dstbak = dst = dstptr;
2041: else
2042: dstbak = dst = xmalloc (uae_u8, 1000);
2043: save_u32 (1);
2044: save_u8 (total);
2045: for (int i = 0; i < MEMWATCH_TOTAL; i++) {
2046: struct memwatch_node *m = &mwnodes[i];
2047: if (m->size <= 0)
2048: continue;
2049: save_store_pos ();
2050: save_u8 (i);
2051: save_u8 (m->modval_written);
2052: save_u8 (m->mustchange);
2053: save_u8 (m->frozen);
2054: save_u8 (m->val_enabled);
2055: save_u8 (m->rwi);
2056: save_u32 (m->addr);
2057: save_u32 (m->size);
2058: save_u32 (m->modval);
2059: save_u32 (m->val_mask);
2060: save_u32 (m->val_size);
2061: save_u32 (m->val);
2062: save_u32 (m->pc);
2063: save_u32 (m->access_mask);
2064: save_u32 (m->reg);
2065: save_store_size ();
2066: }
2067: *len = dst - dstbak;
2068: return dstbak;
2069: }
2070:
2071: uae_u8 *restore_debug_memwatch (uae_u8 *src)
2072: {
2073: if (restore_u32 () != 1)
2074: return src;
2075: int total = restore_u8 ();
2076: for (int i = 0; i < total; i++) {
2077: restore_store_pos ();
2078: int idx = restore_u8 ();
2079: struct memwatch_node *m = &mwnodes[idx];
2080: m->modval_written = restore_u8 ();
2081: m->mustchange = restore_u8 ();
2082: m->frozen = restore_u8 ();
2083: m->val_enabled = restore_u8 ();
2084: m->rwi = restore_u8 ();
2085: m->addr = restore_u32 ();
2086: m->size = restore_u32 ();
2087: m->modval = restore_u32 ();
2088: m->val_mask = restore_u32 ();
2089: m->val_size = restore_u32 ();
2090: m->val = restore_u32 ();
2091: m->pc = restore_u32 ();
2092: m->access_mask = restore_u32();
2093: m->reg = restore_u32();
2094: restore_store_size ();
2095: }
2096: return src;
2097: }
2098:
2099: void restore_debug_memwatch_finish (void)
2100: {
2101: for (int i = 0; i < MEMWATCH_TOTAL; i++) {
2102: struct memwatch_node *m = &mwnodes[i];
2103: if (m->size) {
2104: if (!memwatch_enabled)
2105: initialize_memwatch (0);
2106: return;
2107: }
2108: }
2109: }
2110:
2111: static int memwatch_func (uaecptr addr, int rwi, int size, uae_u32 *valp, uae_u32 accessmask, uae_u32 reg)
2112: {
2113: int i, brk;
2114: uae_u32 val = *valp;
2115:
2116: if (illgdebug)
2117: illg_debug_do (addr, rwi, size, val);
2118:
2119: if (addressspaceheatmap)
2120: memwatch_heatmap (addr, rwi, size);
2121:
2122: addr = munge24 (addr);
2123: if (smc_table && (rwi >= 2))
2124: smc_detector (addr, rwi, size, valp);
2125: for (i = 0; i < MEMWATCH_TOTAL; i++) {
2126: struct memwatch_node *m = &mwnodes[i];
2127: uaecptr addr2 = m->addr;
2128: uaecptr addr3 = addr2 + m->size;
2129: int rwi2 = m->rwi;
2130: uae_u32 oldval = 0;
2131: int isoldval = 0;
2132:
2133: brk = 0;
2134: if (m->size == 0)
2135: continue;
2136: if (!(rwi & rwi2))
2137: continue;
2138: if (!(m->access_mask & accessmask))
2139: continue;
2140:
2141: if (addr >= addr2 && addr < addr3)
2142: brk = 1;
2143: if (!brk && size == 2 && (addr + 1 >= addr2 && addr + 1 < addr3))
2144: brk = 1;
2145: if (!brk && size == 4 && ((addr + 2 >= addr2 && addr + 2 < addr3) || (addr + 3 >= addr2 && addr + 3 < addr3)))
2146: brk = 1;
2147:
2148: if (!brk)
2149: continue;
2150: if (mem_banks[addr >> 16]->check (addr, size)) {
2151: uae_u8 *p = mem_banks[addr >> 16]->xlateaddr (addr);
2152: if (size == 1)
2153: oldval = p[0];
2154: else if (size == 2)
2155: oldval = (p[0] << 8) | p[1];
2156: else
2157: oldval = (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | (p[3] << 0);
2158: isoldval = 1;
2159: }
2160:
2161: if (!m->frozen && m->val_enabled) {
2162: int trigger = 0;
2163: uae_u32 mask = m->size == 4 ? 0xffffffff : (1 << (m->size * 8)) - 1;
2164: uae_u32 mval = m->val;
2165: int scnt = size;
2166: for (;;) {
2167: if (((mval & mask) & m->val_mask) == ((val & mask) & m->val_mask))
2168: trigger = 1;
2169: if (mask & 0x80000000)
2170: break;
2171: if (m->size == 1) {
2172: mask <<= 8;
2173: mval <<= 8;
2174: scnt--;
2175: } else if (m->size == 2) {
2176: mask <<= 16;
2177: scnt -= 2;
2178: mval <<= 16;
2179: } else {
2180: scnt -= 4;
2181: }
2182: if (scnt <= 0)
2183: break;
2184: }
2185: if (!trigger)
2186: continue;
2187: }
2188:
2189: if (m->mustchange && rwi == 2 && isoldval) {
2190: if (oldval == *valp)
2191: continue;
2192: }
2193:
2194: if (m->modval_written) {
2195: if (!rwi) {
2196: brk = 0;
2197: } else if (m->modval_written == 1) {
2198: m->modval_written = 2;
2199: m->modval = val;
2200: brk = 0;
2201: } else if (m->modval == val) {
2202: brk = 0;
2203: }
2204: }
2205: if (m->frozen) {
2206: if (m->val_enabled) {
2207: int shift = (addr + size - 1) - (m->addr + m->val_size - 1);
2208: uae_u32 sval;
2209: uae_u32 mask;
2210:
2211: if (m->val_size == 4)
2212: mask = 0xffffffff;
2213: else if (m->val_size == 2)
2214: mask = 0x0000ffff;
2215: else
2216: mask = 0x000000ff;
2217:
2218: sval = m->val;
2219: if (shift < 0) {
2220: shift = -8 * shift;
2221: sval >>= shift;
2222: mask >>= shift;
2223: } else {
2224: shift = 8 * shift;
2225: sval <<= shift;
2226: mask <<= shift;
2227: }
2228: *valp = (sval & mask) | ((*valp) & ~mask);
2229: write_log (_T("%p %p %08x %08x %d\n"), addr, m->addr, *valp, mask, shift);
2230: return 1;
2231: }
2232: return 0;
2233: }
2234: // if (!notinrom ())
2235: // return 1;
2236: mwhit.pc = M68K_GETPC;
2237: mwhit.addr = addr;
2238: mwhit.rwi = rwi;
2239: mwhit.size = size;
2240: mwhit.val = 0;
2241: mwhit.access_mask = accessmask;
2242: mwhit.reg = reg;
2243: if (mwhit.rwi & 2)
2244: mwhit.val = val;
2245: memwatch_triggered = i + 1;
2246: debugging = 1;
2247: set_special (SPCFLAG_BRK);
2248: return 1;
2249: }
2250: return 1;
2251: }
2252:
2253: #endif /* WINUAE_FOR_HATARI */
2254: #if 0
2255:
2256: static int mmu_hit (uaecptr addr, int size, int rwi, uae_u32 *v);
2257:
2258: static uae_u32 REGPARAM2 mmu_lget (uaecptr addr)
2259: {
2260: int off = debug_mem_off (&addr);
2261: uae_u32 v = 0;
2262: if (!mmu_hit (addr, 4, 0, &v))
2263: v = debug_mem_banks[off]->lget (addr);
2264: return v;
2265: }
2266: static uae_u32 REGPARAM2 mmu_wget (uaecptr addr)
2267: {
2268: int off = debug_mem_off (&addr);
2269: uae_u32 v = 0;
2270: if (!mmu_hit (addr, 2, 0, &v))
2271: v = debug_mem_banks[off]->wget (addr);
2272: return v;
2273: }
2274: static uae_u32 REGPARAM2 mmu_bget (uaecptr addr)
2275: {
2276: int off = debug_mem_off (&addr);
2277: uae_u32 v = 0;
2278: if (!mmu_hit(addr, 1, 0, &v))
2279: v = debug_mem_banks[off]->bget (addr);
2280: return v;
2281: }
2282: static void REGPARAM2 mmu_lput (uaecptr addr, uae_u32 v)
2283: {
2284: int off = debug_mem_off (&addr);
2285: if (!mmu_hit (addr, 4, 1, &v))
2286: debug_mem_banks[off]->lput (addr, v);
2287: }
2288: static void REGPARAM2 mmu_wput (uaecptr addr, uae_u32 v)
2289: {
2290: int off = debug_mem_off (&addr);
2291: if (!mmu_hit (addr, 2, 1, &v))
2292: debug_mem_banks[off]->wput (addr, v);
2293: }
2294: static void REGPARAM2 mmu_bput (uaecptr addr, uae_u32 v)
2295: {
2296: int off = debug_mem_off (&addr);
2297: if (!mmu_hit (addr, 1, 1, &v))
2298: debug_mem_banks[off]->bput (addr, v);
2299: }
2300:
2301: static uae_u32 REGPARAM2 debug_lget (uaecptr addr)
2302: {
2303: uae_u32 off = debug_mem_off (&addr);
2304: uae_u32 v;
2305: v = debug_mem_banks[off]->lget (addr);
2306: memwatch_func (addr, 1, 4, &v, MW_MASK_CPU, 0);
2307: return v;
2308: }
2309: static uae_u32 REGPARAM2 mmu_lgeti (uaecptr addr)
2310: {
2311: int off = debug_mem_off (&addr);
2312: uae_u32 v = 0;
2313: if (!mmu_hit (addr, 4, 4, &v))
2314: v = debug_mem_banks[off]->lgeti (addr);
2315: return v;
2316: }
2317: static uae_u32 REGPARAM2 mmu_wgeti (uaecptr addr)
2318: {
2319: int off = debug_mem_off (&addr);
2320: uae_u32 v = 0;
2321: if (!mmu_hit (addr, 2, 4, &v))
2322: v = debug_mem_banks[off]->wgeti (addr);
2323: return v;
2324: }
2325:
2326: static uae_u32 REGPARAM2 debug_wget (uaecptr addr)
2327: {
2328: int off = debug_mem_off (&addr);
2329: uae_u32 v;
2330: v = debug_mem_banks[off]->wget (addr);
2331: memwatch_func (addr, 1, 2, &v, MW_MASK_CPU, 0);
2332: return v;
2333: }
2334: static uae_u32 REGPARAM2 debug_bget (uaecptr addr)
2335: {
2336: int off = debug_mem_off (&addr);
2337: uae_u32 v;
2338: v = debug_mem_banks[off]->bget (addr);
2339: memwatch_func (addr, 1, 1, &v, MW_MASK_CPU, 0);
2340: return v;
2341: }
2342: static uae_u32 REGPARAM2 debug_lgeti (uaecptr addr)
2343: {
2344: int off = debug_mem_off (&addr);
2345: uae_u32 v;
2346: v = debug_mem_banks[off]->lgeti (addr);
2347: memwatch_func (addr, 4, 4, &v, MW_MASK_CPU, 0);
2348: return v;
2349: }
2350: static uae_u32 REGPARAM2 debug_wgeti (uaecptr addr)
2351: {
2352: int off = debug_mem_off (&addr);
2353: uae_u32 v;
2354: v = debug_mem_banks[off]->wgeti (addr);
2355: memwatch_func (addr, 4, 2, &v, MW_MASK_CPU, 0);
2356: return v;
2357: }
2358: static void REGPARAM2 debug_lput (uaecptr addr, uae_u32 v)
2359: {
2360: int off = debug_mem_off (&addr);
2361: if (memwatch_func (addr, 2, 4, &v, MW_MASK_CPU, 0))
2362: debug_mem_banks[off]->lput (addr, v);
2363: }
2364: static void REGPARAM2 debug_wput (uaecptr addr, uae_u32 v)
2365: {
2366: int off = debug_mem_off (&addr);
2367: if (memwatch_func (addr, 2, 2, &v, MW_MASK_CPU, 0))
2368: debug_mem_banks[off]->wput (addr, v);
2369: }
2370: static void REGPARAM2 debug_bput (uaecptr addr, uae_u32 v)
2371: {
2372: int off = debug_mem_off (&addr);
2373: if (memwatch_func (addr, 2, 1, &v, MW_MASK_CPU, 0))
2374: debug_mem_banks[off]->bput (addr, v);
2375: }
2376: static int REGPARAM2 debug_check (uaecptr addr, uae_u32 size)
2377: {
2378: return debug_mem_banks[munge24 (addr) >> 16]->check (addr, size);
2379: }
2380: static uae_u8 *REGPARAM2 debug_xlate (uaecptr addr)
2381: {
2382: return debug_mem_banks[munge24 (addr) >> 16]->xlateaddr (addr);
2383: }
2384:
2385: uae_u16 debug_wputpeekdma_chipset (uaecptr addr, uae_u32 v, uae_u32 mask, int reg)
2386: {
2387: if (!memwatch_enabled)
2388: return v;
2389: addr &= 0x1fe;
2390: addr += 0xdff000;
2391: memwatch_func (addr, 2, 2, &v, mask, reg);
2392: return v;
2393: }
2394: uae_u16 debug_wputpeekdma_chipram (uaecptr addr, uae_u32 v, uae_u32 mask, int reg)
2395: {
2396: if (!memwatch_enabled)
2397: return v;
2398: if (debug_mem_banks[addr >> 16] == NULL)
2399: return v;
2400: if (!currprefs.z3chipmem_size)
2401: addr &= chipmem_bank.mask;
2402: memwatch_func (addr & chipmem_bank.mask, 2, 2, &v, mask, reg);
2403: return v;
2404: }
2405: uae_u16 debug_wgetpeekdma_chipram (uaecptr addr, uae_u32 v, uae_u32 mask, int reg)
2406: {
2407: uae_u32 vv = v;
2408: if (!memwatch_enabled)
2409: return v;
2410: if (debug_mem_banks[addr >> 16] == NULL)
2411: return v;
2412: if (!currprefs.z3chipmem_size)
2413: addr &= chipmem_bank.mask;
2414: memwatch_func (addr, 1, 2, &vv, mask, reg);
2415: return vv;
2416: }
2417:
2418: void debug_putlpeek (uaecptr addr, uae_u32 v)
2419: {
2420: if (!memwatch_enabled)
2421: return;
2422: memwatch_func (addr, 2, 4, &v, MW_MASK_CPU, 0);
2423: }
2424: void debug_wputpeek (uaecptr addr, uae_u32 v)
2425: {
2426: if (!memwatch_enabled)
2427: return;
2428: memwatch_func (addr, 2, 2, &v, MW_MASK_CPU, 0);
2429: }
2430: void debug_bputpeek (uaecptr addr, uae_u32 v)
2431: {
2432: if (!memwatch_enabled)
2433: return;
2434: memwatch_func (addr, 2, 1, &v, MW_MASK_CPU, 0);
2435: }
2436: void debug_bgetpeek (uaecptr addr, uae_u32 v)
2437: {
2438: uae_u32 vv = v;
2439: if (!memwatch_enabled)
2440: return;
2441: memwatch_func (addr, 1, 1, &vv, MW_MASK_CPU, 0);
2442: }
2443: void debug_wgetpeek (uaecptr addr, uae_u32 v)
2444: {
2445: uae_u32 vv = v;
2446: if (!memwatch_enabled)
2447: return;
2448: memwatch_func (addr, 1, 2, &vv, MW_MASK_CPU, 0);
2449: }
2450: void debug_lgetpeek (uaecptr addr, uae_u32 v)
2451: {
2452: uae_u32 vv = v;
2453: if (!memwatch_enabled)
2454: return;
2455: memwatch_func (addr, 1, 4, &vv, MW_MASK_CPU, 0);
2456: }
2457:
2458: #ifndef WINUAE_FOR_HATARI
2459:
2460: struct membank_store
2461: {
2462: addrbank *addr;
2463: addrbank newbank;
2464: int banknr;
2465: };
2466:
2467: static struct membank_store *membank_stores;
2468: static int membank_total;
2469: #define MEMWATCH_STORE_SLOTS 32
2470:
2471: static void memwatch_reset (void)
2472: {
2473: for (int i = 0; i < membank_total; i++) {
2474: addrbank *ab = debug_mem_banks[i];
2475: if (!ab)
2476: continue;
2477: map_banks_quick (ab, i, 1, 1);
2478: }
2479: for (int i = 0; membank_stores[i].addr; i++) {
2480: struct membank_store *ms = &membank_stores[i];
2481: xfree ((char*)ms->newbank.name);
2482: memset (ms, 0, sizeof (struct membank_store));
2483: ms->addr = NULL;
2484: }
2485: memset (debug_mem_banks, 0, membank_total * sizeof (addrbank*));
2486: }
2487:
2488: static void memwatch_remap (uaecptr addr)
2489: {
2490: int mode = 0;
2491: int i;
2492: int banknr;
2493: struct membank_store *ms;
2494: addrbank *bank;
2495: addrbank *newbank = NULL;
2496:
2497: addr &= ~65535;
2498: banknr = addr >> 16;
2499: if (debug_mem_banks[banknr])
2500: return;
2501: bank = mem_banks[banknr];
2502: for (i = 0 ; i < MEMWATCH_STORE_SLOTS; i++) {
2503: ms = &membank_stores[i];
2504: if (ms->addr == NULL)
2505: break;
2506: if (ms->addr == bank) {
2507: newbank = &ms->newbank;
2508: break;
2509: }
2510: }
2511: if (i >= MEMWATCH_STORE_SLOTS)
2512: return;
2513: if (!newbank) {
2514: TCHAR tmp[200];
2515: _stprintf (tmp, _T("%s [D]"), bank->name);
2516: ms->addr = bank;
2517: ms->banknr = banknr;
2518: newbank = &ms->newbank;
2519: memcpy (newbank, bank, sizeof addrbank);
2520: newbank->bget = mode ? mmu_bget : debug_bget;
2521: newbank->wget = mode ? mmu_wget : debug_wget;
2522: newbank->lget = mode ? mmu_lget : debug_lget;
2523: newbank->bput = mode ? mmu_bput : debug_bput;
2524: newbank->wput = mode ? mmu_wput : debug_wput;
2525: newbank->lput = mode ? mmu_lput : debug_lput;
2526: newbank->check = debug_check;
2527: newbank->xlateaddr = debug_xlate;
2528: newbank->wgeti = mode ? mmu_wgeti : debug_wgeti;
2529: newbank->lgeti = mode ? mmu_lgeti : debug_lgeti;
2530: newbank->name = my_strdup (tmp);
2531: if (!newbank->mask)
2532: newbank->mask = -1;
2533: }
2534: debug_mem_banks[banknr] = bank;
2535: map_banks_quick (newbank, banknr, 1, 1);
2536: // map aliases
2537: for (i = 0; i < membank_total; i++) {
2538: uaecptr addr2 = i << 16;
2539: addrbank *ab = &get_mem_bank(addr2);
2540: if (ab != ms->addr)
2541: continue;
2542: if ((addr2 & ab->mask) == (addr & bank->mask)) {
2543: debug_mem_banks[i] = ms->addr;
2544: map_banks_quick (newbank, i, 1, 1);
2545: }
2546: }
2547: }
2548:
2549: static void memwatch_setup (void)
2550: {
2551: memwatch_reset ();
2552: for (int i = 0; i < MEMWATCH_TOTAL; i++) {
2553: struct memwatch_node *m = &mwnodes[i];
2554: uae_u32 size = 0;
2555: if (!m->size)
2556: continue;
2557: while (size < m->size) {
2558: memwatch_remap (m->addr + size);
2559: size += 65536;
2560: }
2561: }
2562: }
2563:
2564: static int deinitialize_memwatch (void)
2565: {
2566: int oldmode;
2567:
2568: if (!memwatch_enabled && !mmu_enabled)
2569: return -1;
2570: memwatch_reset ();
2571: oldmode = mmu_enabled ? 1 : 0;
2572: xfree (debug_mem_banks);
2573: debug_mem_banks = NULL;
2574: xfree (debug_mem_area);
2575: debug_mem_area = NULL;
2576: xfree (membank_stores);
2577: membank_stores = NULL;
2578: memwatch_enabled = 0;
2579: mmu_enabled = 0;
2580: xfree (illgdebug);
2581: illgdebug = 0;
2582: return oldmode;
2583: }
2584:
2585: static void initialize_memwatch (int mode)
2586: {
2587: membank_total = currprefs.address_space_24 ? 256 : 65536;
2588: deinitialize_memwatch ();
2589: debug_mem_banks = xcalloc (addrbank*, membank_total);
2590: debug_mem_area = xcalloc (addrbank, membank_total);
2591: membank_stores = xcalloc (struct membank_store, MEMWATCH_STORE_SLOTS);
2592: #if 0
2593: int i, j, as;
2594: addrbank *a1, *a2, *oa;
2595: oa = NULL;
2596: for (i = 0; i < as; i++) {
2597: a1 = debug_mem_banks[i] = debug_mem_area + i;
2598: a2 = mem_banks[i];
2599: if (a2 != oa) {
2600: for (j = 0; membank_stores[j].addr; j++) {
2601: if (membank_stores[j].addr == a2)
2602: break;
2603: }
2604: if (membank_stores[j].addr == NULL) {
2605: membank_stores[j].addr = a2;
2606: memcpy (&membank_stores[j].store, a2, sizeof (addrbank));
2607: }
2608: }
2609: memcpy (a1, a2, sizeof (addrbank));
2610: }
2611: for (i = 0; i < as; i++) {
2612: a2 = mem_banks[i];
2613: a2->bget = mode ? mmu_bget : debug_bget;
2614: a2->wget = mode ? mmu_wget : debug_wget;
2615: a2->lget = mode ? mmu_lget : debug_lget;
2616: a2->bput = mode ? mmu_bput : debug_bput;
2617: a2->wput = mode ? mmu_wput : debug_wput;
2618: a2->lput = mode ? mmu_lput : debug_lput;
2619: a2->check = debug_check;
2620: a2->xlateaddr = debug_xlate;
2621: a2->wgeti = mode ? mmu_wgeti : debug_wgeti;
2622: a2->lgeti = mode ? mmu_lgeti : debug_lgeti;
2623: }
2624: #endif
2625: if (mode)
2626: mmu_enabled = 1;
2627: else
2628: memwatch_enabled = 1;
2629: }
2630:
2631: int debug_bankchange (int mode)
2632: {
2633: if (mode == -1) {
2634: int v = deinitialize_memwatch ();
2635: if (v < 0)
2636: return -2;
2637: return v;
2638: }
2639: if (mode >= 0) {
2640: initialize_memwatch (mode);
2641: memwatch_setup ();
2642: }
2643: return -1;
2644: }
2645:
2646: addrbank *get_mem_bank_real(uaecptr addr)
2647: {
2648: addrbank *ab = &get_mem_bank(addr);
2649: if (!memwatch_enabled)
2650: return ab;
2651: addrbank *ab2 = debug_mem_banks[addr >> 16];
2652: if (ab2)
2653: return ab2;
2654: return ab;
2655: }
2656:
2657: struct mw_acc
2658: {
2659: uae_u32 mask;
2660: const TCHAR *name;
2661: };
2662:
2663: static const struct mw_acc memwatch_access_masks[] =
2664: {
2665: { MW_MASK_ALL, _T("ALL") },
2666: { MW_MASK_ALL & ~MW_MASK_CPU, _T("DMA") },
2667: { MW_MASK_BLITTER_A | MW_MASK_BLITTER_B | MW_MASK_BLITTER_C | MW_MASK_BLITTER_D, _T("BLT") },
2668: { MW_MASK_AUDIO_0 | MW_MASK_AUDIO_1 | MW_MASK_AUDIO_2 | MW_MASK_AUDIO_3, _T("AUD") },
2669: { MW_MASK_BPL_0 | MW_MASK_BPL_1 | MW_MASK_BPL_2 | MW_MASK_BPL_3 |
2670: MW_MASK_BPL_4 | MW_MASK_BPL_5 | MW_MASK_BPL_6 | MW_MASK_BPL_7 , _T("BPL") },
2671: { MW_MASK_SPR_0 | MW_MASK_SPR_1 | MW_MASK_SPR_2 | MW_MASK_SPR_3 |
2672: MW_MASK_SPR_4 | MW_MASK_SPR_5 | MW_MASK_SPR_6 | MW_MASK_SPR_7, _T("SPR") },
2673:
2674: { MW_MASK_CPU, _T("CPU") },
2675: { MW_MASK_COPPER, _T("COP") },
2676: { MW_MASK_BLITTER_A, _T("BLTA") },
2677: { MW_MASK_BLITTER_B, _T("BLTB") },
2678: { MW_MASK_BLITTER_C, _T("BLTC") },
2679: { MW_MASK_BLITTER_D, _T("BLTD") },
2680: { MW_MASK_DISK, _T("DSK") },
2681: { MW_MASK_AUDIO_0, _T("AUD0") },
2682: { MW_MASK_AUDIO_1, _T("AUD1") },
2683: { MW_MASK_AUDIO_2, _T("AUD2") },
2684: { MW_MASK_AUDIO_3, _T("AUD3") },
2685: { MW_MASK_BPL_0, _T("BPL0") },
2686: { MW_MASK_BPL_1, _T("BPL1") },
2687: { MW_MASK_BPL_2, _T("BPL2") },
2688: { MW_MASK_BPL_3, _T("BPL3") },
2689: { MW_MASK_BPL_4, _T("BPL4") },
2690: { MW_MASK_BPL_5, _T("BPL5") },
2691: { MW_MASK_BPL_6, _T("BPL6") },
2692: { MW_MASK_BPL_7, _T("BPL7") },
2693: { MW_MASK_SPR_0, _T("SPR0") },
2694: { MW_MASK_SPR_1, _T("SPR1") },
2695: { MW_MASK_SPR_2, _T("SPR2") },
2696: { MW_MASK_SPR_3, _T("SPR3") },
2697: { MW_MASK_SPR_4, _T("SPR4") },
2698: { MW_MASK_SPR_5, _T("SPR5") },
2699: { MW_MASK_SPR_6, _T("SPR6") },
2700: { MW_MASK_SPR_7, _T("SPR7") },
2701: NULL
2702: };
2703:
2704: static TCHAR *getsizechar (int size)
2705: {
2706: if (size == 4)
2707: return _T(".l");
2708: if (size == 3)
2709: return _T(".3");
2710: if (size == 2)
2711: return _T(".w");
2712: if (size == 1)
2713: return _T(".b");
2714: return _T("");
2715: }
2716:
2717: void memwatch_dump2 (TCHAR *buf, int bufsize, int num)
2718: {
2719: int i;
2720: struct memwatch_node *mwn;
2721:
2722: if (buf)
2723: memset (buf, 0, bufsize * sizeof (TCHAR));
2724: for (i = 0; i < MEMWATCH_TOTAL; i++) {
2725: if ((num >= 0 && num == i) || (num < 0)) {
2726: uae_u32 usedmask = 0;
2727: mwn = &mwnodes[i];
2728: if (mwn->size == 0)
2729: continue;
2730: buf = buf_out (buf, &bufsize, _T("%2d: %08X - %08X (%d) %c%c%c"),
2731: i, mwn->addr, mwn->addr + (mwn->size - 1), mwn->size,
2732: (mwn->rwi & 1) ? 'R' : ' ', (mwn->rwi & 2) ? 'W' : ' ', (mwn->rwi & 4) ? 'I' : ' ');
2733: if (mwn->frozen)
2734: buf = buf_out (buf, &bufsize, _T(" F"));
2735: if (mwn->val_enabled)
2736: buf = buf_out (buf, &bufsize, _T(" =%X%s"), mwn->val, getsizechar (mwn->val_size));
2737: if (mwn->modval_written)
2738: buf = buf_out (buf, &bufsize, _T(" =M"));
2739: if (mwn->mustchange)
2740: buf = buf_out (buf, &bufsize, _T(" C"));
2741: for (int j = 0; memwatch_access_masks[j].mask; j++) {
2742: uae_u32 mask = memwatch_access_masks[j].mask;
2743: if ((mwn->access_mask & mask) == mask && (usedmask & mask) == 0) {
2744: buf = buf_out(buf, &bufsize, _T(" "));
2745: buf = buf_out(buf, &bufsize, memwatch_access_masks[j].name);
2746: usedmask |= mask;
2747: }
2748: }
2749: buf = buf_out (buf, &bufsize, _T("\n"));
2750: }
2751: }
2752: }
2753:
2754: static void memwatch_dump (int num)
2755: {
2756: TCHAR *buf;
2757: int multiplier = num < 0 ? MEMWATCH_TOTAL : 1;
2758:
2759: buf = xmalloc (TCHAR, 50 * multiplier);
2760: if (!buf)
2761: return;
2762: memwatch_dump2 (buf, 50 * multiplier, num);
2763: f_out (stdout, _T("%s"), buf);
2764: xfree (buf);
2765: }
2766:
2767: static void memwatch (TCHAR **c)
2768: {
2769: int num;
2770: struct memwatch_node *mwn;
2771: TCHAR nc, *cp;
2772:
2773: if (!memwatch_enabled) {
2774: initialize_memwatch (0);
2775: console_out (_T("Memwatch breakpoints enabled\n"));
2776: }
2777:
2778: cp = *c;
2779: ignore_ws (c);
2780: if (!more_params (c)) {
2781: memwatch_dump (-1);
2782: return;
2783: }
2784: nc = next_char (c);
2785: if (nc == '-') {
2786: deinitialize_memwatch ();
2787: console_out (_T("Memwatch breakpoints disabled\n"));
2788: return;
2789: }
2790: if (nc == 'd') {
2791: if (illgdebug) {
2792: ignore_ws (c);
2793: if (more_params (c)) {
2794: uae_u32 addr = readhex (c);
2795: uae_u32 len = 1;
2796: if (more_params (c))
2797: len = readhex (c);
2798: console_out_f (_T("Cleared logging addresses %08X - %08X\n"), addr, addr + len);
2799: while (len > 0) {
2800: addr &= 0xffffff;
2801: illgdebug[addr] = 7;
2802: addr++;
2803: len--;
2804: }
2805: } else {
2806: illg_free();
2807: console_out (_T("Illegal memory access logging disabled\n"));
2808: }
2809: } else {
2810: illg_init ();
2811: ignore_ws (c);
2812: illgdebug_break = 0;
2813: if (more_params (c))
2814: illgdebug_break = 1;
2815: console_out_f (_T("Illegal memory access logging enabled. Break=%d\n"), illgdebug_break);
2816: }
2817: return;
2818: }
2819: *c = cp;
2820: num = readint (c);
2821: if (num < 0 || num >= MEMWATCH_TOTAL)
2822: return;
2823: mwn = &mwnodes[num];
2824: mwn->size = 0;
2825: ignore_ws (c);
2826: if (!more_params (c)) {
2827: console_out_f (_T("Memwatch %d removed\n"), num);
2828: memwatch_setup ();
2829: return;
2830: }
2831: mwn->addr = readhex (c);
2832: mwn->size = 1;
2833: mwn->rwi = 7;
2834: mwn->val_enabled = 0;
2835: mwn->val_mask = 0xffffffff;
2836: mwn->val = 0;
2837: mwn->access_mask = 0;
2838: mwn->reg = 0xffffffff;
2839: mwn->frozen = 0;
2840: mwn->modval_written = 0;
2841: ignore_ws (c);
2842: if (more_params (c)) {
2843: mwn->size = readhex (c);
2844: ignore_ws (c);
2845: if (more_params (c)) {
2846: TCHAR *cs = *c;
2847: while (*cs) {
2848: for (int i = 0; memwatch_access_masks[i].mask; i++) {
2849: const TCHAR *n = memwatch_access_masks[i].name;
2850: int len = _tcslen(n);
2851: if (!_tcsnicmp(cs, n, len)) {
2852: if (cs[len] == 0 || cs[len] == 10 || cs[len] == 13) {
2853: mwn->access_mask |= memwatch_access_masks[i].mask;
2854: while (len > 0) {
2855: len--;
2856: cs[len] = ' ';
2857: }
2858: }
2859: }
2860: }
2861: cs++;
2862: }
2863: ignore_ws (c);
2864: if (more_params(c)) {
2865: for (;;) {
2866: TCHAR ncc = peek_next_char(c);
2867: TCHAR nc = _totupper (next_char (c));
2868: if (mwn->rwi == 7)
2869: mwn->rwi = 0;
2870: if (nc == 'F')
2871: mwn->frozen = 1;
2872: if (nc == 'W')
2873: mwn->rwi |= 2;
2874: if (nc == 'I')
2875: mwn->rwi |= 4;
2876: if (nc == 'R')
2877: mwn->rwi |= 1;
2878: if (ncc == ' ')
2879: break;
2880: if (!more_params(c))
2881: break;
2882: }
2883: ignore_ws (c);
2884: }
2885: if (more_params (c)) {
2886: if (_totupper (**c) == 'M') {
2887: mwn->modval_written = 1;
2888: } else if (_totupper (**c) == 'C') {
2889: mwn->mustchange = 1;
2890: } else {
2891: mwn->val = readhex (c, &mwn->val_size);
2892: mwn->val_enabled = 1;
2893: }
2894: }
2895: }
2896: }
2897: if (!mwn->access_mask)
2898: mwn->access_mask = MW_MASK_CPU;
2899: if (mwn->frozen && mwn->rwi == 0)
2900: mwn->rwi = 3;
2901: memwatch_setup ();
2902: memwatch_dump (num);
2903: }
2904:
2905: static void writeintomem (TCHAR **c)
2906: {
2907: uae_u32 addr = 0;
2908: uae_u32 val = 0;
2909: TCHAR cc;
2910: int len = 1;
2911:
2912: ignore_ws(c);
2913: addr = readhex (c);
2914:
2915: ignore_ws (c);
2916: if (!more_params (c))
2917: return;
2918: cc = peekchar (c);
2919: if (cc == '\'' || cc == '\"') {
2920: next_char (c);
2921: while (more_params (c)) {
2922: TCHAR str[2];
2923: char *astr;
2924: cc = next_char (c);
2925: if (cc == '\'' || cc == '\"')
2926: break;
2927: str[0] = cc;
2928: str[1] = 0;
2929: astr = ua (str);
2930: put_byte (addr, astr[0]);
2931: xfree (astr);
2932: addr++;
2933: }
2934: } else {
2935: for (;;) {
2936: ignore_ws (c);
2937: if (!more_params (c))
2938: break;
2939: val = readhex (c, &len);
2940:
2941: if (len == 4) {
2942: put_long (addr, val);
2943: cc = 'L';
2944: } else if (len == 2) {
2945: put_word (addr, val);
2946: cc = 'W';
2947: } else if (len == 1) {
2948: put_byte (addr, val);
2949: cc = 'B';
2950: } else {
2951: break;
2952: }
2953: console_out_f (_T("Wrote %X (%u) at %08X.%c\n"), val, val, addr, cc);
2954: addr += len;
2955: }
2956: }
2957: }
2958:
2959: static uae_u8 *dump_xlate (uae_u32 addr)
2960: {
2961: if (!mem_banks[addr >> 16]->check (addr, 1))
2962: return NULL;
2963: return mem_banks[addr >> 16]->xlateaddr (addr);
2964: }
2965:
2966: #if 0
2967: #define UAE_MEMORY_REGIONS_MAX 64
2968: #define UAE_MEMORY_REGION_NAME_LENGTH 64
2969:
2970: #define UAE_MEMORY_REGION_RAM (1 << 0)
2971: #define UAE_MEMORY_REGION_ALIAS (1 << 1)
2972: #define UAE_MEMORY_REGION_MIRROR (1 << 2)
2973:
2974: typedef struct UaeMemoryRegion {
2975: uaecptr start;
2976: int size;
2977: TCHAR name[UAE_MEMORY_REGION_NAME_LENGTH];
2978: TCHAR rom_name[UAE_MEMORY_REGION_NAME_LENGTH];
2979: uaecptr alias;
2980: int flags;
2981: } UaeMemoryRegion;
2982:
2983: typedef struct UaeMemoryMap {
2984: UaeMemoryRegion regions[UAE_MEMORY_REGIONS_MAX];
2985: int num_regions;
2986: } UaeMemoryMap;
2987: #endif
2988:
2989: static void memory_map_dump_3(UaeMemoryMap *map, int log)
2990: {
2991: bool imold;
2992: int i, j, max;
2993: addrbank *a1 = mem_banks[0];
2994: TCHAR txt[256];
2995:
2996: map->num_regions = 0;
2997: imold = currprefs.illegal_mem;
2998: currprefs.illegal_mem = false;
2999: max = currprefs.address_space_24 ? 256 : 65536;
3000: j = 0;
3001: for (i = 0; i < max + 1; i++) {
3002: addrbank *a2 = NULL;
3003: if (i < max)
3004: a2 = mem_banks[i];
3005: if (a1 != a2) {
3006: int k, mirrored, mirrored2, size, size_out;
3007: TCHAR size_ext;
3008: uae_u8 *caddr;
3009: TCHAR tmp[MAX_DPATH];
3010: const TCHAR *name = a1->name;
3011: struct addrbank_sub *sb = a1->sub_banks;
3012: int bankoffset = 0;
3013: int region_size;
3014:
3015: k = j;
3016: caddr = dump_xlate (k << 16);
3017: mirrored = caddr ? 1 : 0;
3018: k++;
3019: while (k < i && caddr) {
3020: if (dump_xlate (k << 16) == caddr)
3021: mirrored++;
3022: k++;
3023: }
3024: mirrored2 = mirrored;
3025: if (mirrored2 == 0)
3026: mirrored2 = 1;
3027:
3028: while (bankoffset < 65536) {
3029: int bankoffset2 = bankoffset;
3030: if (sb) {
3031: uaecptr daddr;
3032: if (!sb->bank)
3033: break;
3034: daddr = (j << 16) | bankoffset;
3035: a1 = get_sub_bank(&daddr);
3036: name = a1->name;
3037: for (;;) {
3038: bankoffset2 += MEMORY_MIN_SUBBANK;
3039: if (bankoffset2 >= 65536)
3040: break;
3041: daddr = (j << 16) | bankoffset2;
3042: addrbank *dab = get_sub_bank(&daddr);
3043: if (dab != a1)
3044: break;
3045: }
3046: sb++;
3047: size = (bankoffset2 - bankoffset) / 1024;
3048: region_size = size * 1024;
3049: } else {
3050: size = (i - j) << (16 - 10);
3051: region_size = ((i - j) << 16) / mirrored2;
3052: }
3053:
3054: if (name == NULL)
3055: name = _T("<none>");
3056:
3057: size_out = size;
3058: size_ext = 'K';
3059: if (j >= 256 && (size_out / mirrored2 >= 1024) && !((size_out / mirrored2) & 1023)) {
3060: size_out /= 1024;
3061: size_ext = 'M';
3062: }
3063: #if 1
3064: _stprintf (txt, _T("%08X %7d%c/%d = %7d%c %s"), (j << 16) | bankoffset, size_out, size_ext,
3065: mirrored, mirrored ? size_out / mirrored : size_out, size_ext, name);
3066: #endif
3067: tmp[0] = 0;
3068: if ((a1->flags & ABFLAG_ROM) && mirrored) {
3069: TCHAR *p = txt + _tcslen (txt);
3070: uae_u32 crc = 0xffffffff;
3071: if (a1->check(((j << 16) | bankoffset), (size * 1024) / mirrored))
3072: crc = get_crc32 (a1->xlateaddr((j << 16) | bankoffset), (size * 1024) / mirrored);
3073: struct romdata *rd = getromdatabycrc (crc);
3074: _stprintf (p, _T(" (%08X)"), crc);
3075: if (rd) {
3076: tmp[0] = '=';
3077: getromname (rd, tmp + 1);
3078: _tcscat (tmp, _T("\n"));
3079: }
3080: }
3081:
3082: if (a1 != &dummy_bank) {
3083: for (int m = 0; m < mirrored2; m++) {
3084: UaeMemoryRegion *r = &map->regions[map->num_regions];
3085: r->start = (j << 16) + bankoffset + region_size * m;
3086: r->size = region_size;
3087: r->flags = 0;
3088: r->memory = NULL;
3089: r->memory = dump_xlate((j << 16) | bankoffset);
3090: if (r->memory)
3091: r->flags |= UAE_MEMORY_REGION_RAM;
3092: /* just to make it easier to spot in debugger */
3093: r->alias = 0xffffffff;
3094: if (m >= 0) {
3095: r->alias = j << 16;
3096: r->flags |= UAE_MEMORY_REGION_ALIAS | UAE_MEMORY_REGION_MIRROR;
3097: }
3098: _stprintf(r->name, _T("%s"), name);
3099: _stprintf(r->rom_name, _T("%s"), tmp);
3100: map->num_regions += 1;
3101: }
3102: }
3103:
3104: #if 1
3105: _tcscat (txt, _T("\n"));
3106: if (log > 0)
3107: write_log (txt);
3108: else if (log == 0)
3109: console_out (txt);
3110: if (tmp[0]) {
3111: if (log > 0)
3112: write_log (tmp);
3113: else if (log == 0)
3114: console_out (tmp);
3115: }
3116: #endif
3117: if (!sb)
3118: break;
3119: bankoffset = bankoffset2;
3120: }
3121: j = i;
3122: a1 = a2;
3123: }
3124: }
3125: currprefs.illegal_mem = imold;
3126: }
3127:
3128: void uae_memory_map(UaeMemoryMap *map)
3129: {
3130: memory_map_dump_3(map, -1);
3131: }
3132:
3133: static void memory_map_dump_2 (int log)
3134: {
3135: UaeMemoryMap map;
3136: memory_map_dump_3(&map, log);
3137: #if 0
3138: for (int i = 0; i < map.num_regions; i++) {
3139: TCHAR txt[256];
3140: UaeMemoryRegion *r = &map.regions[i];
3141: int size = r->size / 1024;
3142: TCHAR size_ext = 'K';
3143: int mirrored = 1;
3144: int size_out = 0;
3145: _stprintf (txt, _T("%08X %7u%c/%d = %7u%c %s\n"), r->start, size, size_ext,
3146: r->flags & UAE_MEMORY_REGION_RAM, size, size_ext, r->name);
3147: if (log)
3148: write_log (_T("%s"), txt);
3149: else
3150: console_out (txt);
3151: if (r->rom_name[0]) {
3152: if (log)
3153: write_log (_T("%s"), r->rom_name);
3154: else
3155: console_out (r->rom_name);
3156: }
3157: }
3158: #endif
3159: }
3160:
3161: void memory_map_dump (void)
3162: {
3163: memory_map_dump_2 (1);
3164: }
3165:
3166: STATIC_INLINE uaecptr BPTR2APTR (uaecptr addr)
3167: {
3168: return addr << 2;
3169: }
3170: static TCHAR *BSTR2CSTR (uae_u8 *bstr)
3171: {
3172: TCHAR *s;
3173: char *cstr = xmalloc (char, bstr[0] + 1);
3174: if (cstr) {
3175: memcpy (cstr, bstr + 1, bstr[0]);
3176: cstr[bstr[0]] = 0;
3177: }
3178: s = au (cstr);
3179: xfree (cstr);
3180: return s;
3181: }
3182:
3183: static void print_task_info (uaecptr node, bool nonactive)
3184: {
3185: TCHAR *s;
3186: int process = get_byte_debug (node + 8) == 13 ? 1 : 0;
3187:
3188: console_out_f (_T("%08X: "), node);
3189: s = au ((char*)get_real_address (get_long_debug (node + 10)));
3190: console_out_f (process ? _T("PROCESS '%s'\n") : _T("TASK '%s'\n"), s);
3191: xfree (s);
3192: if (process) {
3193: uaecptr cli = BPTR2APTR (get_long_debug (node + 172));
3194: int tasknum = get_long_debug (node + 140);
3195: if (cli && tasknum) {
3196: uae_u8 *command_bstr = get_real_address (BPTR2APTR (get_long_debug (cli + 16)));
3197: TCHAR *command = BSTR2CSTR (command_bstr);
3198: console_out_f (_T(" [%d, '%s']\n"), tasknum, command);
3199: xfree (command);
3200: } else {
3201: console_out (_T("\n"));
3202: }
3203: }
3204: if (nonactive) {
3205: uae_u32 sigwait = get_long_debug(node + 22);
3206: if (sigwait)
3207: console_out_f(_T(" Waiting signals: %08x\n"), sigwait);
3208: uae_u32 sp = get_long_debug(node + 54) + 70;
3209: uae_u32 pc = get_long_debug(sp);
3210: console_out_f(_T(" SP: %08x PC: %08x\n"), sp, pc);
3211: }
3212: }
3213:
3214: static void show_exec_tasks (void)
3215: {
3216: uaecptr execbase = get_long_debug (4);
3217: uaecptr taskready = execbase + 406;
3218: uaecptr taskwait = execbase + 420;
3219: uaecptr node;
3220: console_out_f (_T("Execbase at 0x%08X\n"), execbase);
3221: console_out (_T("Current:\n"));
3222: node = get_long_debug (execbase + 276);
3223: print_task_info (node, false);
3224: console_out_f (_T("Ready:\n"));
3225: node = get_long_debug (taskready);
3226: while (node && get_long_debug(node)) {
3227: print_task_info (node, true);
3228: node = get_long_debug (node);
3229: }
3230: console_out (_T("Waiting:\n"));
3231: node = get_long_debug (taskwait);
3232: while (node && get_long_debug(node)) {
3233: print_task_info (node, true);
3234: node = get_long_debug (node);
3235: }
3236: }
3237:
3238: static uaecptr get_base (const uae_char *name, int offset)
3239: {
3240: uaecptr v = get_long_debug (4);
3241: addrbank *b = &get_mem_bank(v);
3242:
3243: if (!b || !b->check (v, 400) || !(b->flags & ABFLAG_RAM))
3244: return 0;
3245: v += offset;
3246: while (v = get_long_debug (v)) {
3247: uae_u32 v2;
3248: uae_u8 *p;
3249: b = &get_mem_bank (v);
3250: if (!b || !b->check (v, 32) || (!(b->flags & ABFLAG_RAM) && !(b->flags & ABFLAG_ROMIN)))
3251: goto fail;
3252: v2 = get_long_debug (v + 10); // name
3253: b = &get_mem_bank (v2);
3254: if (!b || !b->check (v2, 20))
3255: goto fail;
3256: if ((b->flags & ABFLAG_ROM) || (b->flags & ABFLAG_RAM) || (b->flags & ABFLAG_ROMIN)) {
3257: p = b->xlateaddr (v2);
3258: if (!memcmp (p, name, strlen (name) + 1))
3259: return v;
3260: }
3261: }
3262: return 0;
3263: fail:
3264: return 0xffffffff;
3265: }
3266:
3267: static TCHAR *getfrombstr(uaecptr pp)
3268: {
3269: uae_u8 *p = get_real_address ((uaecptr)(pp << 2));
3270: TCHAR *s = xmalloc (TCHAR, p[0] + 1);
3271: return au_copy (s, p[0] + 1, (char*)p + 1);
3272: }
3273:
3274: // read one byte from expansion autoconfig ROM
3275: static void copyromdata(uae_u8 bustype, uaecptr rom, int offset, uae_u8 *out, int size)
3276: {
3277: switch (bustype & 0xc0)
3278: {
3279: case 0x00: // nibble
3280: while (size-- > 0) {
3281: *out++ = (get_byte_debug(rom + offset * 4 + 0) & 0xf0) | ((get_byte_debug(rom + offset * 4 + 2) & 0xf0) >> 4);
3282: offset++;
3283: }
3284: break;
3285: case 0x40: // byte
3286: while (size-- > 0) {
3287: *out++ = get_byte_debug(rom + offset * 2);
3288: offset++;
3289: }
3290: break;
3291: case 0x80: // word
3292: default:
3293: while (size-- > 0) {
3294: *out++ = get_byte_debug(rom + offset);
3295: offset++;
3296: }
3297: break;
3298: }
3299: }
3300:
3301: static void show_exec_lists (TCHAR *t)
3302: {
3303: uaecptr execbase = get_long_debug (4);
3304: uaecptr list = 0, node;
3305: TCHAR c = t[0];
3306: TCHAR c2 = t[1];
3307:
3308: if (c == 'o' || c == 'O') { // doslist
3309: uaecptr dosbase = get_base ("dos.library", 378);
3310: if (dosbase) {
3311: uaecptr rootnode = get_long_debug (dosbase + 34);
3312: uaecptr dosinfo = get_long_debug (rootnode + 24) << 2;
3313: console_out_f (_T("ROOTNODE: %08x DOSINFO: %08x\n"), rootnode, dosinfo);
3314: uaecptr doslist = get_long_debug (dosinfo + 4) << 2;
3315: while (doslist) {
3316: int type = get_long_debug (doslist + 4);
3317: uaecptr msgport = get_long_debug (doslist + 8);
3318: TCHAR *name = getfrombstr (get_long_debug (doslist + 40));
3319: console_out_f (_T("%08x: %d %08x '%s'\n"), doslist, type, msgport, name);
3320: if (type == 0) {
3321: uaecptr fssm = get_long_debug(doslist + 28) << 2;
3322: console_out_f (_T(" - H=%08x Stack=%5d Pri=%2d Start=%08x Seg=%08x GV=%08x\n"),
3323: get_long_debug (doslist + 16) << 2, get_long_debug (doslist + 20),
3324: get_long_debug (doslist + 24), fssm,
3325: get_long_debug (doslist + 32) << 2, get_long_debug (doslist + 36));
3326: if (fssm >= 0x100 && (fssm & 3) == 0) {
3327: TCHAR *unitname = getfrombstr(get_long_debug(fssm + 4));
3328: console_out_f (_T(" %s:%d %08x\n"), unitname, get_long_debug(fssm), get_long_debug(fssm + 8));
3329: uaecptr de = get_long_debug(fssm + 8) << 2;
3330: if (de) {
3331: console_out_f (_T(" TableSize %u\n"), get_long_debug(de + 0));
3332: console_out_f (_T(" SizeBlock %u\n"), get_long_debug(de + 4));
3333: console_out_f (_T(" SecOrg %u\n"), get_long_debug(de + 8));
3334: console_out_f (_T(" Surfaces %u\n"), get_long_debug(de + 12));
3335: console_out_f (_T(" SectorPerBlock %u\n"), get_long_debug(de + 16));
3336: console_out_f (_T(" BlocksPerTrack %u\n"), get_long_debug(de + 20));
3337: console_out_f (_T(" Reserved %u\n"), get_long_debug(de + 24));
3338: console_out_f (_T(" PreAlloc %u\n"), get_long_debug(de + 28));
3339: console_out_f (_T(" Interleave %u\n"), get_long_debug(de + 32));
3340: console_out_f (_T(" LowCyl %u\n"), get_long_debug(de + 36));
3341: console_out_f (_T(" HighCyl %u (Total %u)\n"), get_long_debug(de + 40), get_long_debug(de + 40) - get_long_debug(de + 36) + 1);
3342: console_out_f (_T(" NumBuffers %u\n"), get_long_debug(de + 44));
3343: console_out_f (_T(" BufMemType 0x%08x\n"), get_long_debug(de + 48));
3344: console_out_f (_T(" MaxTransfer 0x%08x\n"), get_long_debug(de + 52));
3345: console_out_f (_T(" Mask 0x%08x\n"), get_long_debug(de + 56));
3346: console_out_f (_T(" BootPri %d\n"), get_long_debug(de + 60));
3347: console_out_f (_T(" DosType 0x%08x\n"), get_long_debug(de + 64));
3348: }
3349: xfree(unitname);
3350: }
3351: }
3352: xfree (name);
3353: doslist = get_long_debug (doslist) << 2;
3354: }
3355: } else {
3356: console_out_f (_T("can't find dos.library\n"));
3357: }
3358: return;
3359: } else if (c == 'i' || c == 'I') { // interrupts
3360: static const int it[] = { 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0 };
3361: static const int it2[] = { 1, 1, 1, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 6, 6, 7 };
3362: list = execbase + 84;
3363: for (int i = 0; i < 16; i++) {
3364: console_out_f (_T("%2d %d: %08x\n"), i + 1, it2[i], list);
3365: if (it[i]) {
3366: console_out_f (_T(" [H] %08x\n"), get_long_debug (list));
3367: node = get_long_debug (list + 8);
3368: if (node) {
3369: uae_u8 *addr = get_real_address (get_long_debug (node + 10));
3370: TCHAR *name = addr ? au ((char*)addr) : au("<null>");
3371: console_out_f (_T(" %08x (C=%08X D=%08X) '%s'\n"), node, get_long_debug (list + 4), get_long_debug (list), name);
3372: xfree (name);
3373: }
3374: } else {
3375: int cnt = 0;
3376: node = get_long_debug (list);
3377: node = get_long_debug (node);
3378: while (get_long_debug (node)) {
3379: uae_u8 *addr = get_real_address (get_long_debug (node + 10));
3380: TCHAR *name = addr ? au ((char*)addr) : au("<null>");
3381: console_out_f (_T(" [S] %08x (C=%08x D=%08X) '%s'\n"), node, get_long_debug (node + 18), get_long_debug (node + 14), name);
3382: if (i == 4 - 1 || i == 14 - 1) {
3383: if (!_tcsicmp (name, _T("cia-a")) || !_tcsicmp (name, _T("cia-b"))) {
3384: static const TCHAR *ciai[] = { _T("A"), _T("B"), _T("ALRM"), _T("SP"), _T("FLG") };
3385: uaecptr cia = node + 22;
3386: for (int j = 0; j < 5; j++) {
3387: uaecptr ciap = get_long_debug (cia);
3388: console_out_f (_T(" %5s: %08x"), ciai[j], ciap);
3389: if (ciap) {
3390: uae_u8 *addr2 = get_real_address (get_long_debug (ciap + 10));
3391: TCHAR *name2 = addr ? au ((char*)addr2) : au("<null>");
3392: console_out_f (_T(" (C=%08x D=%08X) '%s'"), get_long_debug (ciap + 18), get_long_debug (ciap + 14), name2);
3393: xfree (name2);
3394: }
3395: console_out_f (_T("\n"));
3396: cia += 4;
3397: }
3398: }
3399: }
3400: xfree (name);
3401: node = get_long_debug (node);
3402: cnt++;
3403: }
3404: if (!cnt)
3405: console_out_f (_T(" [S] <none>\n"));
3406: }
3407: list += 12;
3408: }
3409: return;
3410: } else if (c == 'e') { // expansion
3411: uaecptr expbase = get_base("expansion.library", 378);
3412: if (expbase) {
3413: list = get_long_debug(expbase + 60);
3414: while (list && get_long_debug(list)) {
3415: uae_u32 addr = get_long_debug(list + 32);
3416: uae_u16 rom_vector = get_word_debug(list + 16 + 10);
3417: uae_u8 type = get_byte_debug(list + 16 + 0);
3418: console_out_f(_T("%02x %02x %08x %08x %04x %02x %08x %04x (%u/%u)\n"),
3419: type, get_byte_debug(list + 16 + 2),
3420: addr, get_long_debug(list + 36),
3421: get_word_debug(list + 16 + 4), get_byte_debug(list + 16 + 1),
3422: get_long_debug(list + 16 + 6), rom_vector,
3423: get_word_debug(list + 16 + 4), get_byte_debug(list + 16 + 1));
3424: if ((type & 0x10)) {
3425: uae_u8 diagarea[256];
3426: uae_u16 nameoffset;
3427: uaecptr rom = addr + rom_vector;
3428: uae_u8 config = get_byte_debug(rom);
3429: copyromdata(config, rom, 0, diagarea, 16);
3430: nameoffset = (diagarea[8] << 8) | diagarea[9];
3431: console_out_f(_T(" %02x %02x Size %04x Diag %04x Boot %04x Name %04x %04x %04x\n"),
3432: diagarea[0], diagarea[1],
3433: (diagarea[2] << 8) | diagarea[3],
3434: (diagarea[4] << 8) | diagarea[5],
3435: (diagarea[6] << 8) | diagarea[7],
3436: nameoffset,
3437: (diagarea[10] << 8) | diagarea[11],
3438: (diagarea[12] << 8) | diagarea[13]);
3439: if (nameoffset != 0 && nameoffset != 0xffff) {
3440: copyromdata(config, rom, nameoffset, diagarea, 256);
3441: diagarea[sizeof diagarea - 1] = 0;
3442: TCHAR *str = au((char*)diagarea);
3443: console_out_f(_T(" '%s'\n"), str);
3444: xfree(str);
3445: }
3446: }
3447: list = get_long_debug(list);
3448: }
3449: }
3450: } else if (c == 'R') { // residents
3451: list = get_long_debug(execbase + 300);
3452: while (list) {
3453: uaecptr resident = get_long_debug (list);
3454: if (!resident)
3455: break;
3456: if (resident & 0x80000000) {
3457: console_out_f (_T("-> %08X\n"), resident & 0x7fffffff);
3458: list = resident & 0x7fffffff;
3459: continue;
3460: }
3461: uae_u8 *addr;
3462: addr = get_real_address (get_long_debug (resident + 14));
3463: TCHAR *name1 = addr ? au ((char*)addr) : au("<null>");
3464: my_trim (name1);
3465: addr = get_real_address (get_long_debug (resident + 18));
3466: TCHAR *name2 = addr ? au ((char*)addr) : au("<null>");
3467: my_trim (name2);
3468: console_out_f (_T("%08X %08X: %02X %3d %02X %+3.3d '%s' ('%s')\n"),
3469: list, resident,
3470: get_byte_debug (resident + 10), get_byte_debug (resident + 11),
3471: get_byte_debug (resident + 12), (uae_s8)get_byte_debug (resident + 13),
3472: name1, name2);
3473: xfree (name2);
3474: xfree (name1);
3475: list += 4;
3476: }
3477: return;
3478: } else if (c == 'f' || c== 'F') { // filesystem.resource
3479: uaecptr fs = get_base ("FileSystem.resource", 336);
3480: if (fs) {
3481: static const TCHAR *fsnames[] = {
3482: _T("DosType"),
3483: _T("Version"),
3484: _T("PatchFlags"),
3485: _T("Type"),
3486: _T("Task"),
3487: _T("Lock"),
3488: _T("Handler"),
3489: _T("StackSize"),
3490: _T("Priority"),
3491: _T("Startup"),
3492: _T("SegList"),
3493: _T("GlobalVec"),
3494: NULL
3495: };
3496: uae_u8 *addr = get_real_address (get_long_debug (fs + 14));
3497: TCHAR *name = addr ? au ((char*)addr) : au ("<null>");
3498: my_trim (name);
3499: console_out_f (_T("%08x: '%s'\n"), fs, name);
3500: xfree (name);
3501: node = get_long_debug (fs + 18);
3502: while (get_long_debug (node)) {
3503: TCHAR *name = au ((char*)get_real_address (get_long_debug (node + 10)));
3504: my_trim (name);
3505: console_out_f (_T("%08x: '%s'\n"), node, name);
3506: xfree (name);
3507: for (int i = 0; fsnames[i]; i++) {
3508: uae_u32 v = get_long_debug (node + 14 + i * 4);
3509: console_out_f (_T("%16s = %08x %d\n"), fsnames[i], v, v);
3510: }
3511: console_out_f (_T("\n"));
3512: node = get_long_debug (node);
3513: }
3514:
3515: } else {
3516: console_out_f (_T("FileSystem.resource not found.\n"));
3517: }
3518: return;
3519: } else if (c == 'm' || c == 'M') { // memory
3520: list = execbase + 322;
3521: node = get_long_debug (list);
3522: while (get_long_debug (node)) {
3523: TCHAR *name = au ((char*)get_real_address (get_long_debug (node + 10)));
3524: uae_u16 v = get_word_debug (node + 8);
3525: console_out_f (_T("%08x %d %d %s\n"), node, (int)((v >> 8) & 0xff), (uae_s8)(v & 0xff), name);
3526: xfree (name);
3527: console_out_f (_T("Attributes %04x First %08x Lower %08x Upper %08x Free %d\n"),
3528: get_word_debug (node + 14), get_long_debug (node + 16), get_long_debug (node + 20),
3529: get_long_debug (node + 24), get_long_debug (node + 28));
3530: uaecptr mc = get_long_debug (node + 16);
3531: while (mc) {
3532: uae_u32 mc1 = get_long_debug (mc);
3533: uae_u32 mc2 = get_long_debug (mc + 4);
3534: console_out_f (_T(" %08x: %08x-%08x,%08x,%08x (%d)\n"), mc, mc, mc + mc2, mc1, mc2, mc2);
3535: mc = mc1;
3536: }
3537: console_out_f (_T("\n"));
3538: node = get_long_debug (node);
3539: }
3540: return;
3541: }
3542:
3543: bool full = false;
3544: switch (c)
3545: {
3546: case 'r': // resources
3547: list = execbase + 336;
3548: break;
3549: case 'd': // devices
3550: list = execbase + 350;
3551: full = true;
3552: break;
3553: case 'l': // libraries
3554: list = execbase + 378;
3555: full = true;
3556: break;
3557: case 'p': // ports
3558: list = execbase + 392;
3559: break;
3560: case 's': // semaphores
3561: list = execbase + 532;
3562: break;
3563: }
3564: if (list == 0)
3565: return;
3566: node = get_long_debug (list);
3567: while (get_long_debug (node)) {
3568: TCHAR *name = au ((char*)get_real_address (get_long_debug (node + 10)));
3569: uae_u16 v = get_word_debug (node + 8);
3570: console_out_f (_T("%08x %d %d"), node, (int)((v >> 8) & 0xff), (uae_s8)(v & 0xff));
3571: if (full) {
3572: uae_u16 ver = get_word_debug(node + 20);
3573: uae_u16 rev = get_word_debug(node + 22);
3574: uae_u32 op = get_word_debug(node + 32);
3575: console_out_f(_T(" %d.%d %d"), ver, rev, op);
3576: }
3577: console_out_f(_T(" %s"), name);
3578: xfree (name);
3579: if (full) {
3580: uaecptr idstring = get_long_debug(node + 24);
3581: if (idstring) {
3582: name = au((char*)get_real_address(idstring));
3583: console_out_f(_T(" (%s)"), name);
3584: xfree(name);
3585: }
3586: }
3587: console_out_f(_T("\n"));
3588: node = get_long_debug (node);
3589: }
3590: }
3591:
3592: static void breakfunc(uae_u32 v)
3593: {
3594: write_log(_T("Cycle breakpoint hit\n"));
3595: debugging = 1;
3596: set_special (SPCFLAG_BRK);
3597: }
3598:
3599: static int cycle_breakpoint(TCHAR **c)
3600: {
3601: TCHAR nc = (*c)[0];
3602: next_char(c);
3603: if (more_params(c)) {
3604: int count = readint(c);
3605: if (nc == 's') {
3606: if (more_params(c)) {
3607: int hp = readint(c);
3608: if (count >= vpos) {
3609: count = vpos - count;
3610: } else {
3611: count += maxvpos - vpos;
3612: }
3613: count *= maxhpos;
3614: if (hp >= current_hpos()) {
3615: count += hp - current_hpos();
3616: } else {
3617: count += maxhpos - current_hpos();
3618: }
3619: } else {
3620: count *= maxhpos;
3621: }
3622: }
3623: event2_newevent_x(-1, count, 0, breakfunc);
3624: return 1;
3625: }
3626: return 0;
3627: }
3628:
3629: #if 0
3630: static int trace_same_insn_count;
3631: static uae_u8 trace_insn_copy[10];
3632: static struct regstruct trace_prev_regs;
3633: #endif
3634: static uaecptr nextpc;
3635:
3636: int instruction_breakpoint (TCHAR **c)
3637: {
3638: struct breakpoint_node *bpn;
3639: int i;
3640:
3641: if (more_params (c)) {
3642: TCHAR nc = _totupper ((*c)[0]);
3643: if (nc == 'S') {
3644: next_char (c);
3645: sr_bpvalue = sr_bpmask = 0;
3646: if (more_params (c)) {
3647: sr_bpmask = 0xffff;
3648: sr_bpvalue = readhex (c);
3649: if (more_params (c))
3650: sr_bpmask = readhex (c);
3651: }
3652: console_out_f (_T("SR breakpoint, value=%04X, mask=%04X\n"), sr_bpvalue, sr_bpmask);
3653: return 0;
3654: } else if (nc == 'I') {
3655: next_char (c);
3656: if (more_params (c))
3657: skipins = readhex (c);
3658: else
3659: skipins = 0x10000;
3660: do_skip = 1;
3661: skipaddr_doskip = 1;
3662: return 1;
3663: } else if (nc == 'D' && (*c)[1] == 0) {
3664: for (i = 0; i < BREAKPOINT_TOTAL; i++)
3665: bpnodes[i].enabled = 0;
3666: console_out (_T("All breakpoints removed\n"));
3667: return 0;
3668: } else if (nc == 'L') {
3669: int got = 0;
3670: for (i = 0; i < BREAKPOINT_TOTAL; i++) {
3671: bpn = &bpnodes[i];
3672: if (!bpn->enabled)
3673: continue;
3674: console_out_f (_T("%8X "), bpn->addr);
3675: got = 1;
3676: }
3677: if (!got)
3678: console_out (_T("No breakpoints\n"));
3679: else
3680: console_out (_T("\n"));
3681: return 0;
3682: }
3683: skipaddr_doskip = 1;
3684: skipaddr_start = readhex (c);
3685: if (more_params (c)) {
3686: skipaddr_end = readhex (c);
3687: } else {
3688: for (i = 0; i < BREAKPOINT_TOTAL; i++) {
3689: bpn = &bpnodes[i];
3690: if (bpn->enabled && bpn->addr == skipaddr_start) {
3691: bpn->enabled = 0;
3692: console_out (_T("Breakpoint removed\n"));
3693: skipaddr_start = 0xffffffff;
3694: skipaddr_doskip = 0;
3695: return 0;
3696: }
3697: }
3698: for (i = 0; i < BREAKPOINT_TOTAL; i++) {
3699: bpn = &bpnodes[i];
3700: if (bpn->enabled)
3701: continue;
3702: bpn->addr = skipaddr_start;
3703: bpn->enabled = 1;
3704: console_out (_T("Breakpoint added\n"));
3705: skipaddr_start = 0xffffffff;
3706: skipaddr_doskip = 0;
3707: break;
3708: }
3709: return 0;
3710: }
3711: }
3712: #if 0
3713: if (skipaddr_start == 0xC0DEDBAD) {
3714: trace_same_insn_count = 0;
3715: logfile = fopen ("uae.trace", "w");
3716: memcpy (trace_insn_copy, regs.pc_p, 10);
3717: memcpy (&trace_prev_regs, ®s, sizeof regs);
3718: }
3719: #endif
3720: do_skip = 1;
3721: skipaddr_doskip = -1;
3722: return 1;
3723: }
3724:
3725: static int process_breakpoint (TCHAR **c)
3726: {
3727: processptr = 0;
3728: xfree (processname);
3729: processname = NULL;
3730: if (!more_params (c))
3731: return 0;
3732: if (**c == '\"') {
3733: TCHAR pn[200];
3734: next_string (c, pn, 200, 0);
3735: processname = ua (pn);
3736: } else {
3737: processptr = readhex (c);
3738: }
3739: do_skip = 1;
3740: skipaddr_doskip = 1;
3741: skipaddr_start = 0;
3742: return 1;
3743: }
3744:
3745: static void savemem (TCHAR **cc)
3746: {
3747: uae_u8 b;
3748: uae_u32 src, src2, len, len2;
3749: TCHAR *name;
3750: FILE *fp;
3751:
3752: if (!more_params (cc))
3753: goto S_argh;
3754:
3755: name = *cc;
3756: while (**cc != '\0' && !isspace (**cc))
3757: (*cc)++;
3758: if (!isspace (**cc))
3759: goto S_argh;
3760:
3761: **cc = '\0';
3762: (*cc)++;
3763: if (!more_params (cc))
3764: goto S_argh;
3765: src2 = src = readhex (cc);
3766: if (!more_params (cc))
3767: goto S_argh;
3768: len2 = len = readhex (cc);
3769: fp = _tfopen (name, _T("wb"));
3770: if (fp == NULL) {
3771: console_out_f (_T("Couldn't open file '%s'\n"), name);
3772: return;
3773: }
3774: while (len > 0) {
3775: b = get_byte_debug (src);
3776: src++;
3777: len--;
3778: if (fwrite (&b, 1, 1, fp) != 1) {
3779: console_out (_T("Error writing file\n"));
3780: break;
3781: }
3782: }
3783: fclose (fp);
3784: if (len == 0)
3785: console_out_f (_T("Wrote %08X - %08X (%d bytes) to '%s'\n"),
3786: src2, src2 + len2, len2, name);
3787: return;
3788: S_argh:
3789: console_out (_T("S-command needs more arguments!\n"));
3790: }
3791:
3792: static void searchmem (TCHAR **cc)
3793: {
3794: int i, sslen, got, val, stringmode;
3795: uae_u8 ss[256];
3796: uae_u32 addr, endaddr;
3797: TCHAR nc;
3798:
3799: got = 0;
3800: sslen = 0;
3801: stringmode = 0;
3802: ignore_ws (cc);
3803: if (**cc == '"') {
3804: stringmode = 1;
3805: (*cc)++;
3806: while (**cc != '"' && **cc != 0) {
3807: ss[sslen++] = tolower (**cc);
3808: (*cc)++;
3809: }
3810: if (**cc != 0)
3811: (*cc)++;
3812: } else {
3813: for (;;) {
3814: if (**cc == 32 || **cc == 0)
3815: break;
3816: nc = _totupper (next_char (cc));
3817: if (isspace (nc))
3818: break;
3819: if (isdigit(nc))
3820: val = nc - '0';
3821: else
3822: val = nc - 'A' + 10;
3823: if (val < 0 || val > 15)
3824: return;
3825: val *= 16;
3826: if (**cc == 32 || **cc == 0)
3827: break;
3828: nc = _totupper (next_char (cc));
3829: if (isspace (nc))
3830: break;
3831: if (isdigit(nc))
3832: val += nc - '0';
3833: else
3834: val += nc - 'A' + 10;
3835: if (val < 0 || val > 255)
3836: return;
3837: ss[sslen++] = (uae_u8)val;
3838: }
3839: }
3840: if (sslen == 0)
3841: return;
3842: ignore_ws (cc);
3843: addr = 0;
3844: endaddr = lastaddr ();
3845: if (more_params (cc)) {
3846: addr = readhex (cc);
3847: if (more_params (cc))
3848: endaddr = readhex (cc);
3849: }
3850: console_out_f (_T("Searching from %08X to %08X..\n"), addr, endaddr);
3851: while ((addr = nextaddr (addr, endaddr, NULL)) != 0xffffffff) {
3852: if (addr == endaddr)
3853: break;
3854: for (i = 0; i < sslen; i++) {
3855: uae_u8 b = get_byte_debug (addr + i);
3856: if (stringmode) {
3857: if (tolower (b) != ss[i])
3858: break;
3859: } else {
3860: if (b != ss[i])
3861: break;
3862: }
3863: }
3864: if (i == sslen) {
3865: got++;
3866: console_out_f (_T(" %08X"), addr);
3867: if (got > 100) {
3868: console_out (_T("\nMore than 100 results, aborting.."));
3869: break;
3870: }
3871: }
3872: if (iscancel (65536)) {
3873: console_out_f (_T("Aborted at %08X\n"), addr);
3874: break;
3875: }
3876: }
3877: if (!got)
3878: console_out (_T("nothing found"));
3879: console_out (_T("\n"));
3880: }
3881:
3882: static int staterecorder (TCHAR **cc)
3883: {
3884: #if 0
3885: TCHAR nc;
3886:
3887: if (!more_params (cc)) {
3888: if (savestate_dorewind (1)) {
3889: debug_rewind = 1;
3890: return 1;
3891: }
3892: return 0;
3893: }
3894: nc = next_char (cc);
3895: if (nc == 'l') {
3896: savestate_listrewind ();
3897: return 0;
3898: }
3899: #endif
3900: return 0;
3901: }
3902:
3903: static int debugtest_modes[DEBUGTEST_MAX];
3904: static const TCHAR *debugtest_names[] = {
3905: _T("Blitter"), _T("Keyboard"), _T("Floppy")
3906: };
3907:
3908: void debugtest (enum debugtest_item di, const TCHAR *format, ...)
3909: {
3910: va_list parms;
3911: TCHAR buffer[1000];
3912:
3913: if (!debugtest_modes[di])
3914: return;
3915: va_start (parms, format);
3916: _vsntprintf (buffer, 1000 - 1, format, parms);
3917: va_end (parms);
3918: write_log (_T("%s PC=%08X: %s\n"), debugtest_names[di], M68K_GETPC, buffer);
3919: if (debugtest_modes[di] == 2)
3920: activate_debugger ();
3921: }
3922:
3923: static void debugtest_set (TCHAR **inptr)
3924: {
3925: int i, val, val2;
3926: ignore_ws (inptr);
3927:
3928: val2 = 1;
3929: if (!more_params (inptr)) {
3930: for (i = 0; i < DEBUGTEST_MAX; i++)
3931: debugtest_modes[i] = 0;
3932: console_out (_T("All debugtests disabled\n"));
3933: return;
3934: }
3935: val = readint (inptr);
3936: if (more_params (inptr)) {
3937: val2 = readint (inptr);
3938: if (val2 > 0)
3939: val2 = 2;
3940: }
3941: if (val < 0) {
3942: for (i = 0; i < DEBUGTEST_MAX; i++)
3943: debugtest_modes[i] = val2;
3944: console_out (_T("All debugtests enabled\n"));
3945: return;
3946: }
3947: if (val >= 0 && val < DEBUGTEST_MAX) {
3948: if (debugtest_modes[val])
3949: debugtest_modes[val] = 0;
3950: else
3951: debugtest_modes[val] = val2;
3952: console_out_f (_T("Debugtest '%s': %s. break = %s\n"),
3953: debugtest_names[val], debugtest_modes[val] ? _T("on") :_T("off"), val2 == 2 ? _T("on") : _T("off"));
3954: }
3955: }
3956:
3957: static void debug_sprite (TCHAR **inptr)
3958: {
3959: uaecptr saddr, addr, addr2;
3960: int xpos, xpos_ecs;
3961: int ypos, ypos_ecs;
3962: int ypose, ypose_ecs;
3963: int attach;
3964: uae_u64 w1, w2, ww1, ww2;
3965: int size = 1, width;
3966: int ecs, sh10;
3967: int y, i;
3968: TCHAR tmp[80];
3969: int max = 2;
3970:
3971: addr2 = 0;
3972: ignore_ws (inptr);
3973: addr = readhex (inptr);
3974: ignore_ws (inptr);
3975: if (more_params (inptr))
3976: size = readhex (inptr);
3977: if (size != 1 && size != 2 && size != 4) {
3978: addr2 = size;
3979: ignore_ws (inptr);
3980: if (more_params (inptr))
3981: size = readint (inptr);
3982: if (size != 1 && size != 2 && size != 4)
3983: size = 1;
3984: }
3985: for (;;) {
3986: ecs = 0;
3987: sh10 = 0;
3988: saddr = addr;
3989: width = size * 16;
3990: w1 = get_word_debug (addr);
3991: w2 = get_word_debug (addr + size * 2);
3992: console_out_f (_T(" %06X "), addr);
3993: for (i = 0; i < size * 2; i++)
3994: console_out_f (_T("%04X "), get_word_debug (addr + i * 2));
3995: console_out_f (_T("\n"));
3996:
3997: ypos = w1 >> 8;
3998: xpos = w1 & 255;
3999: ypose = w2 >> 8;
4000: attach = (w2 & 0x80) ? 1 : 0;
4001: if (w2 & 4)
4002: ypos |= 256;
4003: if (w2 & 2)
4004: ypose |= 256;
4005: ypos_ecs = ypos;
4006: ypose_ecs = ypose;
4007: if (w2 & 0x40)
4008: ypos_ecs |= 512;
4009: if (w2 & 0x20)
4010: ypose_ecs |= 512;
4011: xpos <<= 1;
4012: if (w2 & 0x01)
4013: xpos |= 1;
4014: xpos_ecs = xpos << 2;
4015: if (w2 & 0x10)
4016: xpos_ecs |= 2;
4017: if (w2 & 0x08)
4018: xpos_ecs |= 1;
4019: if (w2 & (0x40 | 0x20 | 0x10 | 0x08))
4020: ecs = 1;
4021: if (w1 & 0x80)
4022: sh10 = 1;
4023: if (ypose < ypos)
4024: ypose += 256;
4025:
4026: for (y = ypos; y < ypose; y++) {
4027: int x;
4028: addr += size * 4;
4029: if (addr2)
4030: addr2 += size * 4;
4031: if (size == 1) {
4032: w1 = get_word_debug (addr);
4033: w2 = get_word_debug (addr + 2);
4034: if (addr2) {
4035: ww1 = get_word_debug (addr2);
4036: ww2 = get_word_debug (addr2 + 2);
4037: }
4038: } else if (size == 2) {
4039: w1 = get_long_debug (addr);
4040: w2 = get_long_debug (addr + 4);
4041: if (addr2) {
4042: ww1 = get_long_debug (addr2);
4043: ww2 = get_long_debug (addr2 + 4);
4044: }
4045: } else if (size == 4) {
4046: w1 = get_long_debug (addr + 0);
4047: w2 = get_long_debug (addr + 8);
4048: w1 <<= 32;
4049: w2 <<= 32;
4050: w1 |= get_long_debug (addr + 4);
4051: w2 |= get_long_debug (addr + 12);
4052: if (addr2) {
4053: ww1 = get_long_debug (addr2 + 0);
4054: ww2 = get_long_debug (addr2 + 8);
4055: ww1 <<= 32;
4056: ww2 <<= 32;
4057: ww1 |= get_long_debug (addr2 + 4);
4058: ww2 |= get_long_debug (addr2 + 12);
4059: }
4060: }
4061: width = size * 16;
4062: for (x = 0; x < width; x++) {
4063: int v1 = w1 & 1;
4064: int v2 = w2 & 1;
4065: int v = v1 * 2 + v2;
4066: w1 >>= 1;
4067: w2 >>= 1;
4068: if (addr2) {
4069: int vv1 = ww1 & 1;
4070: int vv2 = ww2 & 1;
4071: int vv = vv1 * 2 + vv2;
4072: vv1 >>= 1;
4073: vv2 >>= 1;
4074: v *= 4;
4075: v += vv;
4076: tmp[width - (x + 1)] = v >= 10 ? 'A' + v - 10 : v + '0';
4077: } else {
4078: tmp[width - (x + 1)] = v + '0';
4079: }
4080: }
4081: tmp[width] = 0;
4082: console_out_f (_T("%3d %06X %s\n"), y, addr, tmp);
4083: }
4084:
4085: console_out_f (_T("Sprite address %08X, width = %d\n"), saddr, size * 16);
4086: console_out_f (_T("OCS: StartX=%d StartY=%d EndY=%d\n"), xpos, ypos, ypose);
4087: console_out_f (_T("ECS: StartX=%d (%d.%d) StartY=%d EndY=%d%s\n"), xpos_ecs, xpos_ecs / 4, xpos_ecs & 3, ypos_ecs, ypose_ecs, ecs ? _T(" (*)") : _T(""));
4088: console_out_f (_T("Attach: %d. AGA SSCAN/SH10 bit: %d\n"), attach, sh10);
4089:
4090: addr += size * 4;
4091: if (get_word_debug (addr) == 0 && get_word_debug (addr + size * 4) == 0)
4092: break;
4093: max--;
4094: if (max <= 0)
4095: break;
4096: }
4097:
4098: }
4099:
4100: int debug_write_memory_16 (uaecptr addr, uae_u16 v)
4101: {
4102: addrbank *ad;
4103:
4104: ad = &get_mem_bank (addr);
4105: if (ad) {
4106: ad->wput (addr, v);
4107: return 1;
4108: }
4109: return -1;
4110: }
4111: int debug_write_memory_8 (uaecptr addr, uae_u8 v)
4112: {
4113: addrbank *ad;
4114:
4115: ad = &get_mem_bank (addr);
4116: if (ad) {
4117: ad->bput (addr, v);
4118: return 1;
4119: }
4120: return -1;
4121: }
4122: int debug_peek_memory_16 (uaecptr addr)
4123: {
4124: addrbank *ad;
4125:
4126: ad = &get_mem_bank (addr);
4127: if (ad->flags & (ABFLAG_RAM | ABFLAG_ROM | ABFLAG_ROMIN | ABFLAG_SAFE))
4128: return ad->wget (addr);
4129: if (ad == &custom_bank) {
4130: addr &= 0x1fe;
4131: return (ar_custom[addr + 0] << 8) | ar_custom[addr + 1];
4132: }
4133: return -1;
4134: }
4135: int debug_read_memory_16 (uaecptr addr)
4136: {
4137: addrbank *ad;
4138:
4139: ad = &get_mem_bank (addr);
4140: if (ad)
4141: return ad->wget (addr);
4142: return -1;
4143: }
4144: int debug_read_memory_8 (uaecptr addr)
4145: {
4146: addrbank *ad;
4147:
4148: ad = &get_mem_bank (addr);
4149: if (ad)
4150: return ad->bget (addr);
4151: return -1;
4152: }
4153:
4154: static void disk_debug (TCHAR **inptr)
4155: {
4156: TCHAR parm[10];
4157: int i;
4158:
4159: if (**inptr == 'd') {
4160: (*inptr)++;
4161: ignore_ws (inptr);
4162: disk_debug_logging = readint (inptr);
4163: console_out_f (_T("Disk logging level %d\n"), disk_debug_logging);
4164: return;
4165: }
4166: disk_debug_mode = 0;
4167: disk_debug_track = -1;
4168: ignore_ws (inptr);
4169: if (!next_string (inptr, parm, sizeof (parm) / sizeof (TCHAR), 1))
4170: goto end;
4171: for (i = 0; i < _tcslen(parm); i++) {
4172: if (parm[i] == 'R')
4173: disk_debug_mode |= DISK_DEBUG_DMA_READ;
4174: if (parm[i] == 'W')
4175: disk_debug_mode |= DISK_DEBUG_DMA_WRITE;
4176: if (parm[i] == 'P')
4177: disk_debug_mode |= DISK_DEBUG_PIO;
4178: }
4179: if (more_params(inptr))
4180: disk_debug_track = readint (inptr);
4181: if (disk_debug_track < 0 || disk_debug_track > 2 * 83)
4182: disk_debug_track = -1;
4183: if (disk_debug_logging == 0)
4184: disk_debug_logging = 1;
4185: end:
4186: console_out_f (_T("Disk breakpoint mode %c%c%c track %d\n"),
4187: disk_debug_mode & DISK_DEBUG_DMA_READ ? 'R' : '-',
4188: disk_debug_mode & DISK_DEBUG_DMA_WRITE ? 'W' : '-',
4189: disk_debug_mode & DISK_DEBUG_PIO ? 'P' : '-',
4190: disk_debug_track);
4191: }
4192:
4193: static void find_ea (TCHAR **inptr)
4194: {
4195: uae_u32 ea, sea, dea;
4196: uaecptr addr, end;
4197: int hits = 0;
4198:
4199: addr = 0;
4200: end = lastaddr ();
4201: ea = readhex (inptr);
4202: if (more_params(inptr)) {
4203: addr = readhex (inptr);
4204: if (more_params(inptr))
4205: end = readhex (inptr);
4206: }
4207: console_out_f (_T("Searching from %08X to %08X\n"), addr, end);
4208: while((addr = nextaddr (addr, end, &end)) != 0xffffffff) {
4209: if ((addr & 1) == 0 && addr + 6 <= end) {
4210: sea = 0xffffffff;
4211: dea = 0xffffffff;
4212: m68k_disasm_ea (addr, NULL, 1, &sea, &dea);
4213: if (ea == sea || ea == dea) {
4214: m68k_disasm (addr, NULL, 1);
4215: hits++;
4216: if (hits > 100) {
4217: console_out_f (_T("Too many hits. End addr = %08X\n"), addr);
4218: break;
4219: }
4220: }
4221: if (iscancel (65536)) {
4222: console_out_f (_T("Aborted at %08X\n"), addr);
4223: break;
4224: }
4225: }
4226: }
4227: }
4228:
4229: static void m68k_modify (TCHAR **inptr)
4230: {
4231: uae_u32 v;
4232: TCHAR parm[10];
4233: TCHAR c1, c2;
4234: int i;
4235:
4236: if (!next_string (inptr, parm, sizeof (parm) / sizeof (TCHAR), 1))
4237: return;
4238: c1 = _totupper (parm[0]);
4239: c2 = 99;
4240: if (c1 == 'A' || c1 == 'D' || c1 == 'P') {
4241: c2 = _totupper (parm[1]);
4242: if (isdigit (c2))
4243: c2 -= '0';
4244: else
4245: c2 = 99;
4246: }
4247: v = readhex (inptr);
4248: if (c1 == 'A' && c2 < 8)
4249: regs.regs[8 + c2] = v;
4250: else if (c1 == 'D' && c2 < 8)
4251: regs.regs[c2] = v;
4252: else if (c1 == 'P' && c2 == 0)
4253: regs.irc = v;
4254: else if (c1 == 'P' && c2 == 1)
4255: regs.ir = v;
4256: else if (!_tcscmp (parm, _T("SR"))) {
4257: regs.sr = v;
4258: MakeFromSR ();
4259: } else if (!_tcscmp (parm, _T("CCR"))) {
4260: regs.sr = (regs.sr & ~31) | (v & 31);
4261: MakeFromSR ();
4262: } else if (!_tcscmp (parm, _T("USP"))) {
4263: regs.usp = v;
4264: } else if (!_tcscmp (parm, _T("ISP"))) {
4265: regs.isp = v;
4266: } else if (!_tcscmp (parm, _T("PC"))) {
4267: m68k_setpc (v);
4268: fill_prefetch ();
4269: } else {
4270: for (i = 0; m2cregs[i].regname; i++) {
4271: if (!_tcscmp (parm, m2cregs[i].regname))
4272: val_move2c2 (m2cregs[i].regno, v);
4273: }
4274: }
4275: }
4276:
4277: static void ppc_disasm(uaecptr addr, uaecptr *nextpc, int cnt)
4278: {
4279: PPCD_CB disa;
4280:
4281: while(cnt-- > 0) {
4282: uae_u32 instr = get_long_debug(addr);
4283: disa.pc = addr;
4284: disa.instr = instr;
4285: PPCDisasm(&disa);
4286: TCHAR *mnemo = au(disa.mnemonic);
4287: TCHAR *ops = au(disa.operands);
4288: console_out_f(_T("%08X %08X %-12s%-30s\n"), addr, instr, mnemo, ops);
4289: xfree(ops);
4290: xfree(mnemo);
4291: addr += 4;
4292: }
4293: if (nextpc)
4294: *nextpc = addr;
4295: }
4296:
4297: static uaecptr nxdis, nxmem;
4298: static bool ppcmode;
4299:
4300: static BOOL debug_line (TCHAR *input)
4301: {
4302: TCHAR cmd, *inptr;
4303: uaecptr addr;
4304:
4305: inptr = input;
4306: cmd = next_char (&inptr);
4307:
4308: switch (cmd)
4309: {
4310: case 'c': dumpcia (); dumpdisk (); dumpcustom (); break;
4311: case 'i':
4312: {
4313: if (*inptr == 'l') {
4314: next_char (&inptr);
4315: if (more_params (&inptr)) {
4316: debug_illegal_mask = readhex (&inptr);
4317: } else {
4318: debug_illegal_mask = debug_illegal ? 0 : -1;
4319: debug_illegal_mask &= ~((uae_u64)255 << 24); // mask interrupts
4320: }
4321: console_out_f (_T("Exception breakpoint mask: %0I64X\n"), debug_illegal_mask);
4322: debug_illegal = debug_illegal_mask ? 1 : 0;
4323: } else {
4324: addr = 0xffffffff;
4325: if (more_params (&inptr))
4326: addr = readhex (&inptr);
4327: dump_vectors (addr);
4328: }
4329: break;
4330: }
4331: case 'e': dump_custom_regs (tolower(*inptr) == 'a'); break;
4332: case 'r':
4333: {
4334: if (*inptr == 'c')
4335: m68k_dumpcache ();
4336: else if (more_params(&inptr))
4337: m68k_modify (&inptr);
4338: else
4339: m68k_dumpstate (&nextpc);
4340: }
4341: break;
4342: case 'D': deepcheatsearch (&inptr); break;
4343: case 'C': cheatsearch (&inptr); break;
4344: case 'W': writeintomem (&inptr); break;
4345: case 'w': memwatch (&inptr); break;
4346: case 'S': savemem (&inptr); break;
4347: case 's':
4348: if (*inptr == 'c') {
4349: screenshot (1, 1);
4350: } else if (*inptr == 'p') {
4351: inptr++;
4352: debug_sprite (&inptr);
4353: } else if (*inptr == 'm') {
4354: if (*(inptr + 1) == 'c') {
4355: next_char (&inptr);
4356: next_char (&inptr);
4357: if (!smc_table)
4358: smc_detect_init (&inptr);
4359: else
4360: smc_free ();
4361: }
4362: } else {
4363: searchmem (&inptr);
4364: }
4365: break;
4366: case 'd':
4367: {
4368: if (*inptr == 'i') {
4369: next_char (&inptr);
4370: disk_debug (&inptr);
4371: } else if (*inptr == 'j') {
4372: inptr++;
4373: inputdevice_logging = 1 | 2;
4374: if (more_params (&inptr))
4375: inputdevice_logging = readint (&inptr);
4376: console_out_f (_T("Input logging level %d\n"), inputdevice_logging);
4377: } else if (*inptr == 'm') {
4378: memory_map_dump_2 (0);
4379: } else if (*inptr == 't') {
4380: next_char (&inptr);
4381: debugtest_set (&inptr);
4382: #ifdef _WIN32
4383: } else if (*inptr == 'g') {
4384: extern void update_disassembly (uae_u32);
4385: next_char (&inptr);
4386: if (more_params (&inptr))
4387: update_disassembly (readhex (&inptr));
4388: #endif
4389: } else {
4390: uae_u32 daddr;
4391: int count;
4392: if (*inptr == 'p') {
4393: ppcmode = true;
4394: next_char(&inptr);
4395: } else if(*inptr == 'o') {
4396: ppcmode = false;
4397: next_char(&inptr);
4398: }
4399: if (more_params (&inptr))
4400: daddr = readhex (&inptr);
4401: else
4402: daddr = nxdis;
4403: if (more_params (&inptr))
4404: count = readhex (&inptr);
4405: else
4406: count = 10;
4407: if (ppcmode) {
4408: ppc_disasm(daddr, &nxdis, count);
4409: } else {
4410: m68k_disasm (daddr, &nxdis, count);
4411: }
4412: }
4413: }
4414: break;
4415: case 'T':
4416: if (inptr[0] == 't' || inptr[0] == 0)
4417: show_exec_tasks ();
4418: else
4419: show_exec_lists (&inptr[0]);
4420: break;
4421: case 't':
4422: no_trace_exceptions = 0;
4423: if (*inptr != 't') {
4424: if (more_params (&inptr))
4425: skipaddr_doskip = readint (&inptr);
4426: if (skipaddr_doskip <= 0 || skipaddr_doskip > 10000)
4427: skipaddr_doskip = 1;
4428: } else {
4429: no_trace_exceptions = 1;
4430: }
4431: set_special (SPCFLAG_BRK);
4432: exception_debugging = 1;
4433: return true;
4434: case 'z':
4435: skipaddr_start = nextpc;
4436: skipaddr_doskip = 1;
4437: do_skip = 1;
4438: exception_debugging = 1;
4439: return true;
4440:
4441: case 'f':
4442: if (inptr[0] == 'a') {
4443: next_char (&inptr);
4444: find_ea (&inptr);
4445: } else if (inptr[0] == 'p') {
4446: inptr++;
4447: if (process_breakpoint (&inptr))
4448: return true;
4449: } else if (inptr[0] == 'c' || inptr[0] == 's') {
4450: if (cycle_breakpoint(&inptr))
4451: return true;
4452: } else if (inptr[0] == 'e' && inptr[1] == 'n') {
4453: break_if_enforcer = break_if_enforcer ? false : true;
4454: console_out_f(_T("Break when enforcer hit: %s\n"), break_if_enforcer ? _T("enabled") : _T("disabled"));
4455: } else {
4456: if (instruction_breakpoint (&inptr))
4457: return true;
4458: }
4459: break;
4460:
4461: case 'q':
4462: uae_quit();
4463: deactivate_debugger();
4464: return true;
4465:
4466: case 'g':
4467: if (more_params (&inptr)) {
4468: m68k_setpc (readhex (&inptr));
4469: fill_prefetch ();
4470: }
4471: deactivate_debugger();
4472: return true;
4473:
4474: case 'x':
4475: if (_totupper(inptr[0]) == 'X') {
4476: debugger_change(-1);
4477: } else {
4478: deactivate_debugger();
4479: close_console();
4480: return true;
4481: }
4482: break;
4483:
4484: case 'H':
4485: {
4486: int count, temp, badly, skip;
4487: uae_u32 addr = 0;
4488: uae_u32 oldpc = m68k_getpc ();
4489: struct regstruct save_regs = regs;
4490:
4491: badly = 0;
4492: if (inptr[0] == 'H') {
4493: badly = 1;
4494: inptr++;
4495: }
4496:
4497: if (more_params(&inptr))
4498: count = readint (&inptr);
4499: else
4500: count = 10;
4501: if (count > 1000) {
4502: addr = count;
4503: count = MAX_HIST;
4504: }
4505: if (count < 0)
4506: break;
4507: skip = count;
4508: if (more_params (&inptr))
4509: skip = count - readint (&inptr);
4510:
4511: temp = lasthist;
4512: while (count-- > 0 && temp != firsthist) {
4513: if (temp == 0)
4514: temp = MAX_HIST - 1;
4515: else
4516: temp--;
4517: }
4518: while (temp != lasthist) {
4519: regs = history[temp];
4520: if (history[temp].pc == addr || addr == 0) {
4521: m68k_setpc (history[temp].pc);
4522: if (badly) {
4523: m68k_dumpstate (NULL);
4524: } else {
4525: console_out_f(_T("%2d "), history[temp].intmask ? history[temp].intmask : (history[temp].s ? -1 : 0));
4526: m68k_disasm (history[temp].pc, NULL, 1);
4527: }
4528: if (addr && history[temp].pc == addr)
4529: break;
4530: }
4531: if (skip-- < 0)
4532: break;
4533: if (++temp == MAX_HIST)
4534: temp = 0;
4535: }
4536: regs = save_regs;
4537: m68k_setpc (oldpc);
4538: }
4539: break;
4540: case 'M':
4541: if (more_params (&inptr)) {
4542: switch (next_char (&inptr))
4543: {
4544: case 'a':
4545: if (more_params (&inptr))
4546: audio_channel_mask = readhex (&inptr);
4547: console_out_f (_T("Audio mask = %02X\n"), audio_channel_mask);
4548: break;
4549: case 's':
4550: if (more_params (&inptr))
4551: debug_sprite_mask = readhex (&inptr);
4552: console_out_f (_T("Sprite mask: %02X\n"), debug_sprite_mask);
4553: break;
4554: case 'b':
4555: if (more_params (&inptr)) {
4556: debug_bpl_mask = readhex (&inptr) & 0xff;
4557: if (more_params (&inptr))
4558: debug_bpl_mask_one = readhex (&inptr) & 0xff;
4559: notice_screen_contents_lost ();
4560: }
4561: console_out_f (_T("Bitplane mask: %02X (%02X)\n"), debug_bpl_mask, debug_bpl_mask_one);
4562: break;
4563: }
4564: }
4565: break;
4566: case 'm':
4567: {
4568: uae_u32 maddr;
4569: int lines;
4570: #ifdef _WIN32
4571: if (*inptr == 'g') {
4572: extern void update_memdump (uae_u32);
4573: next_char (&inptr);
4574: if (more_params (&inptr))
4575: update_memdump (readhex (&inptr));
4576: break;
4577: }
4578: #endif
4579: if (*inptr == 'm' && inptr[1] == 'u') {
4580: if (currprefs.mmu_model) {
4581: inptr += 2;
4582: if (more_params (&inptr))
4583: debug_mmu_mode = readint (&inptr);
4584: else
4585: debug_mmu_mode = 0;
4586: console_out_f (_T("MMU translation function code = %d\n"), debug_mmu_mode);
4587: }
4588: break;
4589: }
4590: if (more_params (&inptr)) {
4591: maddr = readhex (&inptr);
4592: } else {
4593: maddr = nxmem;
4594: }
4595: if (more_params (&inptr))
4596: lines = readhex (&inptr);
4597: else
4598: lines = 20;
4599: dumpmem (maddr, &nxmem, lines);
4600: }
4601: break;
4602: case 'v':
4603: case 'V':
4604: {
4605: int v1 = vpos, v2 = 0;
4606: if (more_params (&inptr))
4607: v1 = readint (&inptr);
4608: if (more_params (&inptr))
4609: v2 = readint (&inptr);
4610: if (debug_dma) {
4611: decode_dma_record (v2, v1, cmd == 'v', false);
4612: } else {
4613: debug_dma = v1 < 0 ? -v1 : 1;
4614: console_out_f (_T("DMA debugger enabled, mode=%d.\n"), debug_dma);
4615: }
4616: }
4617: break;
4618: case 'o':
4619: {
4620: if (copper_debugger (&inptr)) {
4621: debugger_active = 0;
4622: debugging = 0;
4623: return true;
4624: }
4625: break;
4626: }
4627: case 'O':
4628: break;
4629: case 'b':
4630: if (staterecorder (&inptr))
4631: return true;
4632: break;
4633: case 'U':
4634: if (currprefs.mmu_model && more_params (&inptr)) {
4635: int i;
4636: uaecptr addrl = readhex (&inptr);
4637: uaecptr addrp;
4638: console_out_f (_T("%08X translates to:\n"), addrl);
4639: for (i = 0; i < 4; i++) {
4640: bool super = (i & 2) != 0;
4641: bool data = (i & 1) != 0;
4642: console_out_f (_T("S%dD%d="), super, data);
4643: TRY(prb) {
4644: if (currprefs.mmu_model >= 68040)
4645: addrp = mmu_translate (addrl, super, data, false);
4646: else
4647: addrp = mmu030_translate (addrl, super, data, false);
4648: console_out_f (_T("%08X"), addrp);
4649: TRY(prb2) {
4650: if (currprefs.mmu_model >= 68040)
4651: addrp = mmu_translate (addrl, super, data, true);
4652: else
4653: addrp = mmu030_translate (addrl, super, data, true);
4654: console_out_f (_T(" RW"));
4655: } CATCH(prb2) {
4656: console_out_f (_T(" RO"));
4657: } ENDTRY
4658: } CATCH(prb) {
4659: console_out_f (_T("***********"));
4660: } ENDTRY
4661: console_out_f (_T(" "));
4662: }
4663: console_out_f (_T("\n"));
4664: }
4665: break;
4666: case 'h':
4667: case '?':
4668: if (more_params (&inptr))
4669: converter (&inptr);
4670: else
4671: debug_help ();
4672: break;
4673: }
4674: return false;
4675: }
4676:
4677: static void debug_1 (void)
4678: {
4679: TCHAR input[MAX_LINEWIDTH];
4680:
4681: m68k_dumpstate (&nextpc);
4682: nxdis = nextpc; nxmem = 0;
4683: debugger_active = 1;
4684:
4685: for (;;) {
4686: int v;
4687:
4688: if (!debugger_active)
4689: return;
4690: update_debug_info ();
4691: console_out (_T(">"));
4692: console_flush ();
4693: debug_linecounter = 0;
4694: v = console_get (input, MAX_LINEWIDTH);
4695: if (v < 0)
4696: return;
4697: if (v == 0)
4698: continue;
4699: if (debug_line (input))
4700: return;
4701: }
4702: }
4703:
4704: static void addhistory (void)
4705: {
4706: uae_u32 pc = m68k_getpc ();
4707: // if (!notinrom())
4708: // return;
4709: history[lasthist] = regs;
4710: history[lasthist].pc = m68k_getpc ();
4711: if (++lasthist == MAX_HIST)
4712: lasthist = 0;
4713: if (lasthist == firsthist) {
4714: if (++firsthist == MAX_HIST) firsthist = 0;
4715: }
4716: }
4717:
4718: static void debug_continue(void)
4719: {
4720: set_special (SPCFLAG_BRK);
4721: }
4722:
4723:
4724: void debug (void)
4725: {
4726: int i;
4727: int wasactive;
4728:
4729: if (savestate_state)
4730: return;
4731:
4732: bogusframe = 1;
4733: addhistory ();
4734:
4735: #if 0
4736: if (do_skip && skipaddr_start == 0xC0DEDBAD) {
4737: if (trace_same_insn_count > 0) {
4738: if (memcmp (trace_insn_copy, regs.pc_p, 10) == 0
4739: && memcmp (trace_prev_regs.regs, regs.regs, sizeof regs.regs) == 0)
4740: {
4741: trace_same_insn_count++;
4742: return;
4743: }
4744: }
4745: if (trace_same_insn_count > 1)
4746: fprintf (logfile, "[ repeated %d times ]\n", trace_same_insn_count);
4747: m68k_dumpstate (logfile, &nextpc);
4748: trace_same_insn_count = 1;
4749: memcpy (trace_insn_copy, regs.pc_p, 10);
4750: memcpy (&trace_prev_regs, ®s, sizeof regs);
4751: }
4752: #endif
4753:
4754: if (!memwatch_triggered) {
4755: if (do_skip) {
4756: uae_u32 pc;
4757: uae_u16 opcode;
4758: int bp = 0;
4759:
4760: pc = munge24 (m68k_getpc ());
4761: opcode = currprefs.cpu_model < 68020 && (currprefs.cpu_compatible || currprefs.cpu_cycle_exact) ? regs.ir : get_word_debug (pc);
4762:
4763: for (i = 0; i < BREAKPOINT_TOTAL; i++) {
4764: if (!bpnodes[i].enabled)
4765: continue;
4766: if (bpnodes[i].addr == pc) {
4767: bp = 1;
4768: console_out_f (_T("Breakpoint at %08X\n"), pc);
4769: break;
4770: }
4771: }
4772:
4773: if (skipaddr_doskip) {
4774: if (skipaddr_start == pc)
4775: bp = 1;
4776: if ((processptr || processname) && notinrom()) {
4777: uaecptr execbase = get_long_debug (4);
4778: uaecptr activetask = get_long_debug (execbase + 276);
4779: int process = get_byte_debug (activetask + 8) == 13 ? 1 : 0;
4780: char *name = (char*)get_real_address (get_long_debug (activetask + 10));
4781: if (process) {
4782: uaecptr cli = BPTR2APTR(get_long_debug (activetask + 172));
4783: uaecptr seglist = 0;
4784:
4785: uae_char *command = NULL;
4786: if (cli) {
4787: if (processname)
4788: command = (char*)get_real_address (BPTR2APTR(get_long_debug (cli + 16)));
4789: seglist = BPTR2APTR(get_long_debug (cli + 60));
4790: } else {
4791: seglist = BPTR2APTR(get_long_debug (activetask + 128));
4792: seglist = BPTR2APTR(get_long_debug (seglist + 12));
4793: }
4794: if (activetask == processptr || (processname && (!stricmp (name, processname) || (command && command[0] && !strnicmp (command + 1, processname, command[0]) && processname[command[0]] == 0)))) {
4795: while (seglist) {
4796: uae_u32 size = get_long_debug (seglist - 4) - 4;
4797: if (pc >= (seglist + 4) && pc < (seglist + size)) {
4798: bp = 1;
4799: break;
4800: }
4801: seglist = BPTR2APTR(get_long_debug (seglist));
4802: }
4803: }
4804: }
4805: } else if (skipins != 0xffffffff) {
4806: if (skipins == 0x10000) {
4807: if (opcode == 0x4e75 || opcode == 0x4e73 || opcode == 0x4e77)
4808: bp = 1;
4809: } else if (opcode == skipins)
4810: bp = 1;
4811: } else if (skipaddr_start == 0xffffffff && skipaddr_doskip < 0) {
4812: if ((pc < 0xe00000 || pc >= 0x1000000) && opcode != 0x4ef9)
4813: bp = 1;
4814: } else if (skipaddr_start == 0xffffffff && skipaddr_doskip > 0) {
4815: bp = 1;
4816: } else if (skipaddr_end != 0xffffffff) {
4817: if (pc >= skipaddr_start && pc < skipaddr_end)
4818: bp = 1;
4819: }
4820: }
4821: if (sr_bpmask || sr_bpvalue) {
4822: MakeSR ();
4823: if ((regs.sr & sr_bpmask) == sr_bpvalue) {
4824: console_out (_T("SR breakpoint\n"));
4825: bp = 1;
4826: }
4827: }
4828: if (!bp) {
4829: debug_continue();
4830: return;
4831: }
4832: }
4833: } else {
4834: console_out_f (_T("Memwatch %d: break at %08X.%c %c%c%c %08X PC=%08X "), memwatch_triggered - 1, mwhit.addr,
4835: mwhit.size == 1 ? 'B' : (mwhit.size == 2 ? 'W' : 'L'),
4836: (mwhit.rwi & 1) ? 'R' : ' ', (mwhit.rwi & 2) ? 'W' : ' ', (mwhit.rwi & 4) ? 'I' : ' ',
4837: mwhit.val, mwhit.pc);
4838: for (i = 0; memwatch_access_masks[i].mask; i++) {
4839: if (mwhit.access_mask == memwatch_access_masks[i].mask)
4840: console_out_f (_T("%s (%03x)\n"), memwatch_access_masks[i].name, mwhit.reg);
4841: }
4842: memwatch_triggered = 0;
4843: }
4844: if (skipaddr_doskip > 0) {
4845: skipaddr_doskip--;
4846: if (skipaddr_doskip > 0) {
4847: debug_continue();
4848: return;
4849: }
4850: }
4851:
4852: wasactive = ismouseactive ();
4853: #ifdef WITH_PPC
4854: uae_ppc_pause(1);
4855: #endif
4856: inputdevice_unacquire ();
4857: pause_sound ();
4858: setmouseactive (0);
4859: activate_console ();
4860: do_skip = 0;
4861: skipaddr_start = 0xffffffff;
4862: skipaddr_end = 0xffffffff;
4863: skipins = 0xffffffff;
4864: skipaddr_doskip = 0;
4865: exception_debugging = 0;
4866: debug_rewind = 0;
4867: processptr = 0;
4868: #if 0
4869: if (!currprefs.statecapture) {
4870: changed_prefs.statecapture = currprefs.statecapture = 1;
4871: savestate_init ();
4872: }
4873: #endif
4874: debug_1 ();
4875: if (!debug_rewind && !currprefs.cachesize
4876: #ifdef FILESYS
4877: && nr_units () == 0
4878: #endif
4879: ) {
4880: savestate_capture (1);
4881: }
4882: for (i = 0; i < BREAKPOINT_TOTAL; i++) {
4883: if (bpnodes[i].enabled)
4884: do_skip = 1;
4885: }
4886: if (sr_bpmask || sr_bpvalue)
4887: do_skip = 1;
4888: if (do_skip) {
4889: set_special (SPCFLAG_BRK);
4890: debugging = -1;
4891: }
4892: resume_sound ();
4893: inputdevice_acquire (TRUE);
4894: #ifdef WITH_PPC
4895: uae_ppc_pause(0);
4896: #endif
4897: setmouseactive (wasactive ? 2 : 0);
4898: }
4899:
4900: const TCHAR *debuginfo (int mode)
4901: {
4902: static TCHAR txt[100];
4903: uae_u32 pc = M68K_GETPC;
4904: _stprintf (txt, _T("PC=%08X INS=%04X %04X %04X"),
4905: pc, get_word_debug (pc), get_word_debug (pc + 2), get_word_debug (pc + 4));
4906: return txt;
4907: }
4908:
4909: #endif /* WINUAE_FOR_HATARI */
4910:
4911: void mmu_disasm (uaecptr pc, int lines)
4912: {
4913: debug_mmu_mode = regs.s ? 6 : 2;
4914: m68k_dumpstate (0xffffffff, NULL);
4915: m68k_disasm (pc, NULL, lines);
4916: }
4917:
4918: static int mmu_logging;
4919:
4920: #define MMU_PAGE_SHIFT 16
4921:
4922: struct mmudata {
4923: uae_u32 flags;
4924: uae_u32 addr;
4925: uae_u32 len;
4926: uae_u32 remap;
4927: uae_u32 p_addr;
4928: };
4929:
4930: static struct mmudata *mmubanks;
4931: static uae_u32 mmu_struct, mmu_callback, mmu_regs;
4932: static uae_u32 mmu_fault_bank_addr, mmu_fault_addr;
4933: static int mmu_fault_size, mmu_fault_rw;
4934: static int mmu_slots;
4935: static struct regstruct mmur;
4936:
4937: struct mmunode {
4938: struct mmudata *mmubank;
4939: struct mmunode *next;
4940: };
4941: static struct mmunode **mmunl;
4942: extern regstruct mmu_backup_regs;
4943:
4944: #define MMU_READ_U (1 << 0)
4945: #define MMU_WRITE_U (1 << 1)
4946: #define MMU_READ_S (1 << 2)
4947: #define MMU_WRITE_S (1 << 3)
4948: #define MMU_READI_U (1 << 4)
4949: #define MMU_READI_S (1 << 5)
4950:
4951: #define MMU_MAP_READ_U (1 << 8)
4952: #define MMU_MAP_WRITE_U (1 << 9)
4953: #define MMU_MAP_READ_S (1 << 10)
4954: #define MMU_MAP_WRITE_S (1 << 11)
4955: #define MMU_MAP_READI_U (1 << 12)
4956: #define MMU_MAP_READI_S (1 << 13)
4957:
4958: void mmu_do_hit (void)
4959: {
4960: int i;
4961: uaecptr p;
4962: uae_u32 pc;
4963:
4964: mmu_triggered = 0;
4965: pc = m68k_getpc ();
4966: p = mmu_regs + 18 * 4;
4967: put_long (p, pc);
4968: regs = mmu_backup_regs;
4969: regs.intmask = 7;
4970: regs.t0 = regs.t1 = 0;
4971: if (!regs.s) {
4972: regs.usp = m68k_areg (regs, 7);
4973: if (currprefs.cpu_model >= 68020)
4974: m68k_areg (regs, 7) = regs.m ? regs.msp : regs.isp;
4975: else
4976: m68k_areg (regs, 7) = regs.isp;
4977: regs.s = 1;
4978: }
4979: MakeSR ();
4980: m68k_setpc (mmu_callback);
4981: fill_prefetch ();
4982:
4983: if (currprefs.cpu_model > 68000) {
4984: for (i = 0 ; i < 9; i++) {
4985: m68k_areg (regs, 7) -= 4;
4986: put_long (m68k_areg (regs, 7), 0);
4987: }
4988: m68k_areg (regs, 7) -= 4;
4989: put_long (m68k_areg (regs, 7), mmu_fault_addr);
4990: m68k_areg (regs, 7) -= 2;
4991: put_word (m68k_areg (regs, 7), 0); /* WB1S */
4992: m68k_areg (regs, 7) -= 2;
4993: put_word (m68k_areg (regs, 7), 0); /* WB2S */
4994: m68k_areg (regs, 7) -= 2;
4995: put_word (m68k_areg (regs, 7), 0); /* WB3S */
4996: m68k_areg (regs, 7) -= 2;
4997: put_word (m68k_areg (regs, 7),
4998: (mmu_fault_rw ? 0 : 0x100) | (mmu_fault_size << 5)); /* SSW */
4999: m68k_areg (regs, 7) -= 4;
5000: put_long (m68k_areg (regs, 7), mmu_fault_bank_addr);
5001: m68k_areg (regs, 7) -= 2;
5002: put_word (m68k_areg (regs, 7), 0x7002);
5003: }
5004: m68k_areg (regs, 7) -= 4;
5005: put_long (m68k_areg (regs, 7), get_long_debug (p - 4));
5006: m68k_areg (regs, 7) -= 2;
5007: put_word (m68k_areg (regs, 7), mmur.sr);
5008: #ifdef JIT
5009: set_special(SPCFLAG_END_COMPILE);
5010: #endif
5011: }
5012:
5013: static void mmu_do_hit_pre (struct mmudata *md, uaecptr addr, int size, int rwi, uae_u32 v)
5014: {
5015: uae_u32 p, pc;
5016: int i;
5017:
5018: mmur = regs;
5019: pc = m68k_getpc ();
5020: if (mmu_logging)
5021: console_out_f (_T("MMU: hit %08X SZ=%d RW=%d V=%08X PC=%08X\n"), addr, size, rwi, v, pc);
5022:
5023: p = mmu_regs;
5024: put_long (p, 0); p += 4;
5025: for (i = 0; i < 16; i++) {
5026: put_long (p, regs.regs[i]);
5027: p += 4;
5028: }
5029: put_long (p, pc); p += 4;
5030: put_long (p, 0); p += 4;
5031: put_long (p, regs.usp); p += 4;
5032: put_long (p, regs.isp); p += 4;
5033: put_long (p, regs.msp); p += 4;
5034: put_word (p, regs.sr); p += 2;
5035: put_word (p, (size << 1) | ((rwi & 2) ? 1 : 0)); /* size and rw */ p += 2;
5036: put_long (p, addr); /* fault address */ p += 4;
5037: put_long (p, md->p_addr); /* bank address */ p += 4;
5038: put_long (p, v); p += 4;
5039: mmu_fault_addr = addr;
5040: mmu_fault_bank_addr = md->p_addr;
5041: mmu_fault_size = size;
5042: mmu_fault_rw = rwi;
5043: mmu_triggered = 1;
5044: }
5045:
5046: static int mmu_hit (uaecptr addr, int size, int rwi, uae_u32 *v)
5047: {
5048: int s, trig;
5049: uae_u32 flags;
5050: struct mmudata *md;
5051: struct mmunode *mn;
5052:
5053: if (mmu_triggered)
5054: return 1;
5055:
5056: mn = mmunl[addr >> MMU_PAGE_SHIFT];
5057: if (mn == NULL)
5058: return 0;
5059:
5060: s = regs.s;
5061: while (mn) {
5062: md = mn->mmubank;
5063: if (addr >= md->addr && addr < md->addr + md->len) {
5064: flags = md->flags;
5065: if (flags & (MMU_MAP_READ_U | MMU_MAP_WRITE_U | MMU_MAP_READ_S | MMU_MAP_WRITE_S | MMU_MAP_READI_U | MMU_MAP_READI_S)) {
5066: trig = 0;
5067: if (!s && (flags & MMU_MAP_READ_U) && (rwi & 1))
5068: trig = 1;
5069: if (!s && (flags & MMU_MAP_WRITE_U) && (rwi & 2))
5070: trig = 1;
5071: if (s && (flags & MMU_MAP_READ_S) && (rwi & 1))
5072: trig = 1;
5073: if (s && (flags & MMU_MAP_WRITE_S) && (rwi & 2))
5074: trig = 1;
5075: if (!s && (flags & MMU_MAP_READI_U) && (rwi & 4))
5076: trig = 1;
5077: if (s && (flags & MMU_MAP_READI_S) && (rwi & 4))
5078: trig = 1;
5079: if (trig) {
5080: uaecptr maddr = md->remap + (addr - md->addr);
5081: if (maddr == addr) /* infinite mmu hit loop? no thanks.. */
5082: return 1;
5083: if (mmu_logging)
5084: console_out_f (_T("MMU: remap %08X -> %08X SZ=%d RW=%d\n"), addr, maddr, size, rwi);
5085: if ((rwi & 2)) {
5086: switch (size)
5087: {
5088: case 4:
5089: put_long (maddr, *v);
5090: break;
5091: case 2:
5092: put_word (maddr, *v);
5093: break;
5094: case 1:
5095: put_byte (maddr, *v);
5096: break;
5097: }
5098: } else {
5099: switch (size)
5100: {
5101: case 4:
5102: *v = get_long_debug (maddr);
5103: break;
5104: case 2:
5105: *v = get_word_debug (maddr);
5106: break;
5107: case 1:
5108: *v = get_byte_debug (maddr);
5109: break;
5110: }
5111: }
5112: return 1;
5113: }
5114: }
5115: if (flags & (MMU_READ_U | MMU_WRITE_U | MMU_READ_S | MMU_WRITE_S | MMU_READI_U | MMU_READI_S)) {
5116: trig = 0;
5117: if (!s && (flags & MMU_READ_U) && (rwi & 1))
5118: trig = 1;
5119: if (!s && (flags & MMU_WRITE_U) && (rwi & 2))
5120: trig = 1;
5121: if (s && (flags & MMU_READ_S) && (rwi & 1))
5122: trig = 1;
5123: if (s && (flags & MMU_WRITE_S) && (rwi & 2))
5124: trig = 1;
5125: if (!s && (flags & MMU_READI_U) && (rwi & 4))
5126: trig = 1;
5127: if (s && (flags & MMU_READI_S) && (rwi & 4))
5128: trig = 1;
5129: if (trig) {
5130: mmu_do_hit_pre (md, addr, size, rwi, *v);
5131: return 1;
5132: }
5133: }
5134: }
5135: mn = mn->next;
5136: }
5137: return 0;
5138: }
5139:
5140: static void mmu_free_node(struct mmunode *mn)
5141: {
5142: if (!mn)
5143: return;
5144: mmu_free_node (mn->next);
5145: xfree (mn);
5146: }
5147:
5148: static void mmu_free(void)
5149: {
5150: struct mmunode *mn;
5151: int i;
5152:
5153: for (i = 0; i < mmu_slots; i++) {
5154: mn = mmunl[i];
5155: mmu_free_node (mn);
5156: }
5157: xfree (mmunl);
5158: mmunl = NULL;
5159: xfree (mmubanks);
5160: mmubanks = NULL;
5161: }
5162:
5163: static int getmmubank(struct mmudata *snptr, uaecptr p)
5164: {
5165: snptr->flags = get_long_debug (p);
5166: if (snptr->flags == 0xffffffff)
5167: return 1;
5168: snptr->addr = get_long_debug (p + 4);
5169: snptr->len = get_long_debug (p + 8);
5170: snptr->remap = get_long_debug (p + 12);
5171: snptr->p_addr = p;
5172: return 0;
5173: }
5174:
5175: int mmu_init(int mode, uaecptr parm, uaecptr parm2)
5176: {
5177: uaecptr p, p2, banks;
5178: int size;
5179: struct mmudata *snptr;
5180: struct mmunode *mn;
5181: static int wasjit;
5182: #ifdef JIT
5183: if (currprefs.cachesize) {
5184: wasjit = currprefs.cachesize;
5185: changed_prefs.cachesize = 0;
5186: console_out (_T("MMU: JIT disabled\n"));
5187: check_prefs_changed_comp ();
5188: }
5189: if (mode == 0) {
5190: if (mmu_enabled) {
5191: mmu_free ();
5192: deinitialize_memwatch ();
5193: console_out (_T("MMU: disabled\n"));
5194: changed_prefs.cachesize = wasjit;
5195: }
5196: mmu_logging = 0;
5197: return 1;
5198: }
5199: #endif
5200:
5201: if (mode == 1) {
5202: if (!mmu_enabled)
5203: return 0xffffffff;
5204: return mmu_struct;
5205: }
5206:
5207: p = parm;
5208: mmu_struct = p;
5209: if (get_long_debug (p) != 1) {
5210: console_out_f (_T("MMU: version mismatch %d <> %d\n"), get_long_debug (p), 1);
5211: return 0;
5212: }
5213: p += 4;
5214: mmu_logging = get_long_debug (p) & 1;
5215: p += 4;
5216: mmu_callback = get_long_debug (p);
5217: p += 4;
5218: mmu_regs = get_long_debug (p);
5219: p += 4;
5220:
5221: if (mode == 3) {
5222: int off;
5223: uaecptr addr = get_long_debug (parm2 + 4);
5224: if (!mmu_enabled)
5225: return 0;
5226: off = addr >> MMU_PAGE_SHIFT;
5227: mn = mmunl[off];
5228: while (mn) {
5229: if (mn->mmubank->p_addr == parm2) {
5230: getmmubank(mn->mmubank, parm2);
5231: if (mmu_logging)
5232: console_out_f (_T("MMU: bank update %08X: %08X - %08X %08X\n"),
5233: mn->mmubank->flags, mn->mmubank->addr, mn->mmubank->len + mn->mmubank->addr,
5234: mn->mmubank->remap);
5235: }
5236: mn = mn->next;
5237: }
5238: return 1;
5239: }
5240:
5241: mmu_slots = 1 << ((currprefs.address_space_24 ? 24 : 32) - MMU_PAGE_SHIFT);
5242: mmunl = xcalloc (struct mmunode*, mmu_slots);
5243: size = 1;
5244: p2 = get_long_debug (p);
5245: while (get_long_debug (p2) != 0xffffffff) {
5246: p2 += 16;
5247: size++;
5248: }
5249: p = banks = get_long_debug (p);
5250: snptr = mmubanks = xmalloc (struct mmudata, size);
5251: for (;;) {
5252: int off;
5253: if (getmmubank(snptr, p))
5254: break;
5255: p += 16;
5256: off = snptr->addr >> MMU_PAGE_SHIFT;
5257: if (mmunl[off] == NULL) {
5258: mn = mmunl[off] = xcalloc (struct mmunode, 1);
5259: } else {
5260: mn = mmunl[off];
5261: while (mn->next)
5262: mn = mn->next;
5263: mn = mn->next = xcalloc (struct mmunode, 1);
5264: }
5265: mn->mmubank = snptr;
5266: snptr++;
5267: }
5268:
5269: initialize_memwatch (1);
5270: console_out_f (_T("MMU: enabled, %d banks, CB=%08X S=%08X BNK=%08X SF=%08X, %d*%d\n"),
5271: size - 1, mmu_callback, parm, banks, mmu_regs, mmu_slots, 1 << MMU_PAGE_SHIFT);
5272: set_special (SPCFLAG_BRK);
5273: return 1;
5274: }
5275:
5276: void debug_parser (const TCHAR *cmd, TCHAR *out, uae_u32 outsize)
5277: {
5278: TCHAR empty[2] = { 0 };
5279: TCHAR *input = my_strdup (cmd);
5280: if (out == NULL && outsize == 0) {
5281: setconsolemode (empty, 1);
5282: } else if (out != NULL && outsize > 0) {
5283: out[0] = 0;
5284: setconsolemode (out, outsize);
5285: }
5286: debug_line (input);
5287: setconsolemode (NULL, 0);
5288: xfree (input);
5289: }
5290:
5291: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.