![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to debugui.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|
Return to debugui.c CVS log | Up to [HATARI the Atari ST Emulator] / hatari / src |
1.1 root 1: /*
1.1.1.6 root 2: Hatari - debugui.c
1.1 root 3:
1.1.1.4 root 4: This file is distributed under the GNU Public License, version 2 or at
5: your option any later version. Read the file gpl.txt for details.
6:
1.1.1.6 root 7: debugui.c - this is the code for the mini-debugger. When the pause button is
8: pressed, the emulator is (hopefully) halted and this little CLI can be used
9: (in the terminal box) for debugging tasks like memory and register dumps.
1.1 root 10: */
1.1.1.10 root 11: const char DebugUI_fileid[] = "Hatari debugui.c : " __DATE__ " " __TIME__;
1.1 root 12:
13: #include <ctype.h>
1.1.1.8 root 14: #include <stdio.h>
15:
16: #include "config.h"
17:
18: #if HAVE_LIBREADLINE
19: #include <readline/readline.h>
20: #include <readline/history.h>
21: #endif
1.1 root 22:
23: #include "main.h"
1.1.1.9 root 24: #include "change.h"
1.1 root 25: #include "configuration.h"
1.1.1.11 root 26: #include "memorySnapShot.h"
1.1.1.9 root 27: #include "file.h"
1.1 root 28: #include "reset.h"
29: #include "m68000.h"
1.1.1.9 root 30: #include "str.h"
1.1.1.3 root 31: #include "stMemory.h"
1.1 root 32: #include "sound.h"
33: #include "tos.h"
1.1.1.11 root 34: #include "options.h"
1.1.1.4 root 35: #include "debugui.h"
1.1.1.11 root 36: #include "breakcond.h"
1.1.1.8 root 37: #include "hatari-glue.h"
1.1.1.11 root 38: #include "screen.h"
39: #include "statusbar.h"
40: #include "video.h"
41:
42: int bExceptionDebugging;
1.1 root 43:
44: #define MEMDUMP_COLS 16 /* memdump, number of bytes per row */
45: #define MEMDUMP_ROWS 4 /* memdump, number of rows */
1.1.1.2 root 46: #define NON_PRINT_CHAR '.' /* character to display for non-printables */
1.1 root 47: #define DISASM_INSTS 5 /* disasm - number of instructions */
48:
1.1.1.11 root 49: static Uint32 disasm_addr; /* disasm address */
50: static Uint32 memdump_addr; /* memdump address */
51:
52: static Uint16 dsp_disasm_addr; /* DSP disasm address */
53: static Uint16 dsp_memdump_addr; /* DSP memdump address */
54: static char dsp_mem_space = 'P'; /* X, Y, P */
1.1.1.6 root 55:
1.1.1.9 root 56: static FILE *debugOutput;
1.1.1.2 root 57:
1.1.1.11 root 58: static Uint32 CpuBreakPoint[16]; /* 68k breakpoints */
59: static int nCpuActiveBPs = 0; /* Amount of active breakpoints */
60: static int nCpuActiveCBs = 0; /* Amount of active conditional breakpoints */
61: static int nCpuSteps = 0; /* Amount of steps for CPU single-stepping */
62:
63: static Uint16 DspBreakPoint[16]; /* DSP breakpoints */
64: static int nDspActiveBPs = 0; /* Amount of active breakpoints */
65: static int nDspActiveCBs = 0; /* Amount of active conditional breakpoints */
66: static int nDspSteps = 0; /* Amount of steps for DSP single-stepping */
1.1.1.2 root 67:
1.1.1.11 root 68: static int DebugUI_Help(int nArgc, char *psArgv[]);
69: static void DebugUI_PrintCmdHelp(const char *psCmd);
1.1.1.6 root 70:
71:
1.1.1.8 root 72: /**
1.1.1.11 root 73: * Save/Restore snapshot of debugging session variables
1.1.1.8 root 74: */
1.1.1.11 root 75: void DebugUI_MemorySnapShot_Capture(bool bSave)
1.1.1.6 root 76: {
1.1.1.11 root 77: MemorySnapShot_Store(&disasm_addr, sizeof(disasm_addr));
78: MemorySnapShot_Store(&memdump_addr, sizeof(memdump_addr));
79: MemorySnapShot_Store(&dsp_disasm_addr, sizeof(dsp_disasm_addr));
80: MemorySnapShot_Store(&dsp_memdump_addr, sizeof(dsp_memdump_addr));
81: MemorySnapShot_Store(&dsp_mem_space, sizeof(dsp_mem_space));
82:
83: MemorySnapShot_Store(&CpuBreakPoint, sizeof(CpuBreakPoint));
84: MemorySnapShot_Store(&nCpuActiveBPs, sizeof(nCpuActiveBPs));
85: MemorySnapShot_Store(&nCpuActiveCBs, sizeof(nCpuActiveCBs));
86: MemorySnapShot_Store(&DspBreakPoint, sizeof(DspBreakPoint));
87: MemorySnapShot_Store(&nDspActiveBPs, sizeof(nDspActiveBPs));
88: MemorySnapShot_Store(&nDspActiveCBs, sizeof(nDspActiveCBs));
89:
90: BreakCond_MemorySnapShot_Capture(bSave);
1.1.1.9 root 91: }
92:
93:
94: /**
95: * Close a log file if open, and set it to default stream.
96: */
97: static void DebugUI_SetLogDefault(void)
98: {
99: if (debugOutput != stderr)
100: {
101: if (debugOutput)
102: {
103: File_Close(debugOutput);
104: fprintf(stderr, "Debug log closed.\n");
105: }
106: debugOutput = stderr;
107: }
1.1.1.2 root 108: }
109:
1.1.1.6 root 110:
1.1.1.11 root 111: /**
112: * Open (or close) given log file.
113: */
114: static int DebugUI_SetLogFile(int nArgc, char *psArgs[])
115: {
116: File_Close(debugOutput);
117: debugOutput = NULL;
118:
119: if (nArgc > 1)
120: debugOutput = File_Open(psArgs[1], "w");
121:
122: if (debugOutput)
123: fprintf(stderr, "Debug log '%s' opened.\n", psArgs[1]);
124: else
125: debugOutput = stderr;
126:
127: return DEBUGGER_CMDDONE;
128: }
129:
130:
1.1.1.8 root 131: /**
132: * Load a binary file to a memory address.
133: */
1.1.1.11 root 134: static int DebugUI_LoadBin(int nArgc, char *psArgs[])
1.1.1.6 root 135: {
136: FILE *fp;
137: unsigned char c;
1.1.1.11 root 138: Uint32 address;
1.1.1.6 root 139: int i=0;
140:
1.1.1.11 root 141: if (nArgc < 3)
142: {
143: DebugUI_PrintCmdHelp(psArgs[0]);
144: return DEBUGGER_CMDDONE;
145: }
146:
147: if (!Str_GetNumber(psArgs[2], &address))
1.1.1.6 root 148: {
1.1.1.11 root 149: fprintf(stderr, "Invalid address!\n");
150: return DEBUGGER_CMDDONE;
1.1.1.6 root 151: }
152: address &= 0x00FFFFFF;
1.1.1.11 root 153:
154: if ((fp = fopen(psArgs[1], "rb")) == NULL)
1.1.1.6 root 155: {
1.1.1.11 root 156: fprintf(stderr, "Cannot open file '%s'!\n", psArgs[1]);
157: return DEBUGGER_CMDDONE;
1.1.1.6 root 158: }
159:
160: c = fgetc(fp);
161: while (!feof(fp))
162: {
163: i++;
164: STMemory_WriteByte(address++, c);
165: c = fgetc(fp);
166: }
167: fprintf(stderr," Read 0x%x bytes.\n", i);
168: fclose(fp);
1.1.1.11 root 169:
170: return DEBUGGER_CMDDONE;
1.1 root 171: }
172:
1.1.1.6 root 173:
1.1.1.8 root 174: /**
175: * Dump memory from an address to a binary file.
176: */
1.1.1.11 root 177: static int DebugUI_SaveBin(int nArgc, char *psArgs[])
1.1.1.6 root 178: {
179: FILE *fp;
180: unsigned char c;
1.1.1.11 root 181: Uint32 address;
182: Uint32 bytes, i = 0;
1.1.1.6 root 183:
1.1.1.11 root 184: if (nArgc < 4)
1.1.1.6 root 185: {
1.1.1.11 root 186: DebugUI_PrintCmdHelp(psArgs[0]);
187: return DEBUGGER_CMDDONE;
188: }
189:
190: if (!Str_GetNumber(psArgs[2], &address))
191: {
192: fprintf(stderr, " Invalid address!\n");
193: return DEBUGGER_CMDDONE;
1.1.1.6 root 194: }
195: address &= 0x00FFFFFF;
1.1.1.11 root 196:
197: if (!Str_GetNumber(psArgs[3], &bytes))
1.1.1.6 root 198: {
1.1.1.11 root 199: fprintf(stderr, " Invalid length!\n");
200: return DEBUGGER_CMDDONE;
201: }
202:
203: if ((fp = fopen(psArgs[1], "wb")) == NULL)
204: {
205: fprintf(stderr," Cannot open file '%s'!\n", psArgs[1]);
206: return DEBUGGER_CMDDONE;
1.1.1.6 root 207: }
208:
209: while (i < bytes)
210: {
211: c = STMemory_ReadByte(address++);
212: fputc(c, fp);
213: i++;
214: }
215: fclose(fp);
1.1.1.11 root 216: fprintf(stderr, " Wrote 0x%x bytes.\n", bytes);
217:
218: return DEBUGGER_CMDDONE;
1.1 root 219: }
220:
1.1.1.6 root 221:
1.1.1.11 root 222: #if ENABLE_DSP_EMU
223:
224: #include "dsp.h"
225:
1.1.1.8 root 226: /**
1.1.1.11 root 227: * Command: Dump or set a DSP register
1.1.1.8 root 228: */
1.1.1.11 root 229: static int DebugUI_DspRegister(int nArgc, char *psArgs[])
1.1 root 230: {
1.1.1.11 root 231: int i;
232: char reg[4], *assign;
233: Uint32 value;
234: char *arg;
235:
236: if (!bDspEnabled)
237: {
238: printf("DSP isn't present or initialized.\n");
239: return DEBUGGER_CMDDONE;
240: }
241:
242: if (nArgc == 1)
243: {
244: /* No parameter - dump all registers */
245: DSP_DisasmRegisters();
246: return DEBUGGER_CMDDONE;
247: }
248:
249: arg = psArgs[1];
250: assign = strchr(arg, '=');
251: /* has '=' and reg name is max. 3 letters that fit to string */
252: if (!assign || assign - arg > 3+1)
253: goto error_msg;
254:
255: *assign++ = '\0';
256: if (!Str_GetNumber(assign, &value))
257: goto error_msg;
258:
259: for (i = 0; i < 3 && arg[i]; i++)
260: reg[i] = toupper(arg[i]);
261:
262: DSP_Disasm_SetRegister(reg, value);
263: return DEBUGGER_CMDDONE;
264:
265: error_msg:
266: fprintf(stderr,"\tError, usage: dr or dr xx=yyyy\n"
267: "\tWhere: xx=A0-A2, B0-B2, X0, X1, Y0, Y1, R0-R7,\n"
268: "\t N0-N7, M0-M7, LA, LC, PC, SR, SP, OMR, SSH, SSL\n"
269: "\tand yyyy is a hex value.\n");
270:
271: return DEBUGGER_CMDDONE;
1.1 root 272: }
273:
274:
1.1.1.8 root 275: /**
1.1.1.11 root 276: * DSP dissassemble - arg = starting address/range, or PC.
1.1.1.8 root 277: */
1.1.1.11 root 278: static int DebugUI_DspDisAsm(int nArgc, char *psArgs[])
1.1.1.6 root 279: {
1.1.1.11 root 280: Uint32 lower, upper;
281: Uint16 dsp_disasm_upper = 0;
1.1.1.6 root 282:
1.1.1.11 root 283: if (!bDspEnabled)
1.1.1.6 root 284: {
1.1.1.11 root 285: printf("DSP isn't present or initialized.\n");
286: return DEBUGGER_CMDDONE;
287: }
1.1.1.6 root 288:
1.1.1.11 root 289: if (nArgc > 1)
290: {
291: switch (Str_ParseRange(psArgs[1], &lower, &upper))
292: {
293: case -1:
294: /* invalid value(s) */
295: return DEBUGGER_CMDDONE;
296: case 0:
297: /* single value */
298: break;
299: case 1:
300: /* range */
301: if (upper > 0xFFFF)
302: {
303: fprintf(stderr,"Invalid address '%x'!\n", upper);
304: return DEBUGGER_CMDDONE;
305: }
306: dsp_disasm_upper = upper;
307: break;
308: }
309:
310: if (lower > 0xFFFF)
311: {
312: fprintf(stderr,"Invalid address '%x'!\n", lower);
313: return DEBUGGER_CMDDONE;
314: }
315: dsp_disasm_addr = lower;
316: }
317: else
318: {
319: /* continue */
320: if(!dsp_disasm_addr)
321: {
322: dsp_disasm_addr = DSP_GetPC();
323: }
324: }
325: if (!dsp_disasm_upper)
326: {
327: if ( dsp_disasm_addr < (0xFFFF - 8))
328: dsp_disasm_upper = dsp_disasm_addr + 8;
329: else
330: dsp_disasm_upper = 0xFFFF;
331: }
332: printf("DSP disasm %hx-%hx:\n", dsp_disasm_addr, dsp_disasm_upper);
333: dsp_disasm_addr = DSP_DisasmAddress(dsp_disasm_addr, dsp_disasm_upper);
1.1.1.6 root 334:
1.1.1.11 root 335: return DEBUGGER_CMDCONT;
336: }
337:
338:
339: /**
340: * Do a DSP memory dump, args = starting address or range.
341: * <x|y|p> <address>: dump from X, Y or P, starting from given address,
342: * e.g. "x 200" or "p 200-300"
343: */
344: static int DebugUI_DspMemDump(int nArgc, char *psArgs[])
345: {
346: Uint32 lower, upper;
347: Uint16 dsp_memdump_upper = 0;
348: char space;
349:
350: if (!bDspEnabled)
351: {
352: printf("DSP isn't present or initialized.\n");
353: return DEBUGGER_CMDDONE;
354: }
355: if (nArgc == 2)
356: {
357: fprintf(stderr,"Memory space or address/range missing\n");
358: return DEBUGGER_CMDDONE;
359: }
360:
361: if (nArgc == 3)
362: {
363: space = toupper(psArgs[1][0]);
364: switch (space)
365: {
366: case 'X':
367: case 'Y':
368: case 'P':
369: break;
370: default:
371: fprintf(stderr,"Invalid DSP address space '%c'!\n", space);
372: return DEBUGGER_CMDDONE;
373: }
374: switch (Str_ParseRange(psArgs[2], &lower, &upper))
375: {
376: case -1:
377: /* invalid value(s) */
378: return DEBUGGER_CMDDONE;
379: case 0:
380: /* single value */
381: break;
382: case 1:
383: /* range */
384: if (upper > 0xFFFF)
1.1.1.6 root 385: {
1.1.1.11 root 386: fprintf(stderr,"Invalid address '%x'!\n", upper);
387: return DEBUGGER_CMDDONE;
1.1.1.6 root 388: }
1.1.1.11 root 389: dsp_memdump_upper = upper;
390: break;
391: }
392: if (lower > 0xFFFF)
1.1.1.6 root 393: {
1.1.1.11 root 394: fprintf(stderr,"Invalid address '%x'!\n", lower);
395: return DEBUGGER_CMDDONE;
1.1.1.6 root 396: }
1.1.1.11 root 397: dsp_memdump_addr = lower;
398: dsp_mem_space = space;
399: } /* continue */
400:
401: if (!dsp_memdump_upper)
402: {
403: if ( dsp_memdump_addr < (0xFFFF - 7))
404: dsp_memdump_upper = dsp_memdump_addr + 7;
1.1.1.6 root 405: else
1.1.1.11 root 406: dsp_memdump_upper = 0xFFFF;
407: }
408:
409:
410: printf("DSP memdump from %hx in '%c' address space\n", dsp_memdump_addr, dsp_mem_space);
411: DSP_DisasmMemory(dsp_memdump_addr, dsp_memdump_upper, dsp_mem_space);
412: dsp_memdump_addr = dsp_memdump_upper + 1;
413:
414: return DEBUGGER_CMDCONT;
415: }
416:
417: /**
418: * Toggle or list DSP breakpoints.
419: */
420: static int DebugUI_DspBreakPoint(int nArgc, char *psArgs[])
421: {
422: int i;
423: Uint16 addr;
424: Uint32 BreakAddr;
425:
426: /* List breakpoints? */
427: if (nArgc == 1)
428: {
429: /* No arguments - so list available breakpoints */
430: if (!nDspActiveBPs)
431: {
432: fputs("No DSP breakpoints set.\n", stderr);
433: return DEBUGGER_CMDDONE;
434: }
435:
436: fputs("Currently active DSP breakpoints:\n", stderr);
437: for (i = 0; i < nDspActiveBPs; i++)
438: {
439: addr = DspBreakPoint[i];
440: DSP_DisasmAddress(addr, addr);
441: }
442:
443: return DEBUGGER_CMDDONE;
444: }
445:
446: /* Parse parameter as breakpoint value */
447: if (!Str_GetNumber(psArgs[1], &BreakAddr) || BreakAddr > 0xFFFF)
448: {
449: fputs("Not a valid value for a DSP breakpoint!\n", stderr);
450: return DEBUGGER_CMDDONE;
451: }
452:
453: /* Is the breakpoint already in the list? Then disable it! */
454: for (i = 0; i < nDspActiveBPs; i++)
455: {
456: if (BreakAddr == DspBreakPoint[i])
457: {
458: DspBreakPoint[i] = DspBreakPoint[nDspActiveBPs-1];
459: nDspActiveBPs -= 1;
460: fprintf(stderr, "DSP breakpoint at %x deleted.\n", BreakAddr);
461: return DEBUGGER_CMDDONE;
462: }
463: }
464:
465: /* Is there at least one free slot available? */
466: if (nDspActiveBPs == ARRAYSIZE(DspBreakPoint))
467: {
468: fputs("No more available free DSP breakpoints!\n", stderr);
469: return DEBUGGER_CMDDONE;
470: }
471:
472: /* Add new breakpoint */
473: DspBreakPoint[nDspActiveBPs] = BreakAddr;
474: nDspActiveBPs += 1;
475: fprintf(stderr, "DSP breakpoint added at %x.\n", BreakAddr);
476:
477: return DEBUGGER_CMDDONE;
478: }
479:
480: /**
481: * DSP wrapper for BreakCond_Command/BreakPointCount, returns DEBUGGER_END
482: */
483: static int DebugUI_BreakCondDsp(int nArgc, char *psArgs[])
484: {
485: BreakCond_Command((const char *)psArgs[1], true);
486: nDspActiveCBs = BreakCond_BreakPointCount(true);
487: return DEBUGGER_CMDDONE;
488: }
489:
490: /**
491: * Check if we hit a DSP breakpoint
492: */
493: static void DebugUI_CheckDspBreakpoints(void)
494: {
495: Uint16 pc = DSP_GetPC();
496: int i;
497:
498: for (i = 0; i < nDspActiveBPs; i++)
499: {
500: if (pc == DspBreakPoint[i])
501: {
502: fprintf(stderr, "\nDSP breakpoint at %x ...", pc);
503: DebugUI();
504: break;
505: }
506: }
507: }
508:
509:
510: /**
511: * This function is called after each DSP instruction when debugging is enabled.
512: */
513: void DebugUI_DspCheck(void)
514: {
515: if (nDspActiveBPs)
516: {
517: DebugUI_CheckDspBreakpoints();
518: }
519: if (nDspActiveCBs)
520: {
521: if (BreakCond_MatchDsp())
522: DebugUI();
523: }
524: if (nDspSteps)
525: {
526: nDspSteps -= 1;
527: if (nDspSteps == 0)
528: DebugUI();
529: }
530: }
531:
532: #endif /* ENABLE_DSP_EMU */
533:
534:
535:
536: /**
537: * Dissassemble - arg = starting address, or PC.
538: */
539: static int DebugUI_DisAsm(int nArgc, char *psArgs[])
540: {
541: Uint32 disasm_upper = 0;
542: uaecptr nextpc;
543:
544: if (nArgc > 1)
545: {
546: switch (Str_ParseRange(psArgs[1], &disasm_addr, &disasm_upper))
547: {
548: case -1:
549: /* invalid value(s) */
550: return DEBUGGER_CMDDONE;
551: case 0:
552: /* single value */
553: break;
554: case 1:
555: /* range */
1.1.1.6 root 556: disasm_upper &= 0x00FFFFFF;
1.1.1.11 root 557: break;
1.1.1.6 root 558: }
559: }
1.1.1.11 root 560: else
561: {
562: /* continue */
1.1.1.6 root 563: if(!disasm_addr)
1.1.1.8 root 564: disasm_addr = M68000_GetPC();
1.1.1.11 root 565: }
1.1.1.6 root 566: disasm_addr &= 0x00FFFFFF;
567:
568: /* output a single block. */
1.1.1.11 root 569: if (!disasm_upper)
1.1.1.6 root 570: {
1.1.1.9 root 571: m68k_disasm(debugOutput, (uaecptr)disasm_addr, &nextpc, DISASM_INSTS);
1.1.1.6 root 572: disasm_addr = nextpc;
1.1.1.9 root 573: fflush(debugOutput);
1.1.1.11 root 574: return DEBUGGER_CMDCONT;
1.1.1.6 root 575: }
576:
577: /* output a range */
578: while (disasm_addr < disasm_upper)
579: {
1.1.1.9 root 580: m68k_disasm(debugOutput, (uaecptr)disasm_addr, &nextpc, 1);
1.1.1.6 root 581: disasm_addr = nextpc;
582: }
1.1.1.9 root 583: fflush(debugOutput);
1.1.1.11 root 584:
585: return DEBUGGER_CMDCONT;
1.1.1.2 root 586: }
587:
1.1.1.6 root 588:
1.1.1.8 root 589: /**
1.1.1.11 root 590: * Set address of the named register to given argument.
591: * Return register size in bits or zero for uknown register name.
592: * Handles D0-7 data and A0-7 address registers, but not PC & SR
593: * registers as they need to be accessed using UAE accessors.
1.1.1.8 root 594: */
1.1.1.11 root 595: int DebugUI_GetCpuRegisterAddress(const char *reg, Uint32 **addr)
1.1.1.6 root 596: {
1.1.1.11 root 597: char r0, r1;
598: if (!reg[0] || !reg[1] || reg[2])
599: return 0;
600:
601: r0 = toupper(reg[0]);
602: r1 = toupper(reg[1]);
603:
604: if (r0 == 'D') /* Data regs? */
1.1.1.6 root 605: {
1.1.1.11 root 606: if (r1 >= '0' && r1 <= '7')
1.1.1.6 root 607: {
1.1.1.11 root 608: *addr = &(Regs[REG_D0 + r1 - '0']);
609: return 32;
1.1.1.6 root 610: }
1.1.1.11 root 611: fprintf(stderr,"\tBad data register, valid values are 0-7\n");
612: return 0;
613: }
614: if(r0 == 'A') /* Address regs? */
615: {
616: if (r1 >= '0' && r1 <= '7')
617: {
618: *addr = &(Regs[REG_A0 + r1 - '0']);
619: return 32;
620: }
621: fprintf(stderr,"\tBad address register, valid values are 0-7\n");
622: return 0;
1.1.1.6 root 623: }
1.1.1.11 root 624: return 0;
625: }
626:
627:
628: /**
629: * Dump or set CPU registers
630: */
631: static int DebugUI_CpuRegister(int nArgc, char *psArgs[])
632: {
633: int i;
634: char reg[3], *assign;
635: Uint32 value;
636: char *arg;
637:
638: /* If no parameter has been given, simply dump all registers */
639: if (nArgc == 1)
640: {
641: uaecptr nextpc;
642: /* use the UAE function instead */
643: m68k_dumpstate(debugOutput, &nextpc);
644: fflush(debugOutput);
645: return DEBUGGER_CMDDONE;
646: }
647:
648: arg = psArgs[1];
1.1.1.6 root 649:
1.1.1.11 root 650: assign = strchr(arg, '=');
651: /* has '=' and reg name is max. 2 letters that fit to string */
652: if (!assign || assign - arg > 2+1)
1.1.1.6 root 653: {
654: fprintf(stderr,"\tError, usage: r or r xx=yyyy\n\tWhere: xx=A0-A7, D0-D7, PC or SR and yyyy is a hex value.\n");
1.1.1.11 root 655: return DEBUGGER_CMDDONE;
1.1.1.6 root 656: }
657:
1.1.1.11 root 658: *assign++ = '\0';
659: if (!Str_GetNumber(assign, &value))
1.1.1.6 root 660: {
661: fprintf(stderr,"\tError, usage: r or r xx=yyyy\n\tWhere: xx=A0-A7, D0-D7, PC or SR and yyyy is a hex value.\n");
1.1.1.11 root 662: return DEBUGGER_CMDDONE;
1.1.1.6 root 663: }
1.1.1.11 root 664:
665: for (i = 0; i < 2 && arg[i]; i++)
666: {
667: reg[i] = toupper(arg[i]);
668: }
669:
1.1.1.6 root 670: /* set SR and update conditional flags for the UAE CPU core. */
671: if (reg[0] == 'S' && reg[1] == 'R')
672: {
1.1.1.8 root 673: M68000_SetSR(value);
1.1.1.6 root 674: }
675: else if (reg[0] == 'P' && reg[1] == 'C') /* set PC? */
676: {
1.1.1.8 root 677: M68000_SetPC(value);
1.1.1.6 root 678: }
1.1.1.11 root 679: else
1.1.1.6 root 680: {
1.1.1.11 root 681: Uint32 *regaddr;
682: /* check&set data and address registers */
683: if (DebugUI_GetCpuRegisterAddress(reg, ®addr))
1.1.1.6 root 684: {
1.1.1.11 root 685: *regaddr = value;
686: }
687: else
688: {
689: fprintf(stderr, "\t Bad register!\n");
1.1.1.6 root 690: }
691: }
1.1.1.11 root 692: return DEBUGGER_CMDDONE;
693: }
694:
695:
696: /**
697: * Toggle or list CPU breakpoints.
698: */
699: static int DebugUI_CpuBreakPoint(int nArgc, char *psArgs[])
700: {
701: int i;
702: uaecptr nextpc;
703: Uint32 BreakAddr;
704:
705: /* List breakpoints? */
706: if (nArgc == 1)
1.1.1.6 root 707: {
1.1.1.11 root 708: /* No arguments - so list available breakpoints */
709: if (!nCpuActiveBPs)
1.1.1.6 root 710: {
1.1.1.11 root 711: fputs("No CPU breakpoints set.\n", stderr);
712: return DEBUGGER_CMDDONE;
713: }
1.1.1.6 root 714:
1.1.1.11 root 715: fputs("Currently active CPU breakpoints:\n", stderr);
716: for (i = 0; i < nCpuActiveBPs; i++)
717: {
718: m68k_disasm(stderr, (uaecptr)CpuBreakPoint[i], &nextpc, 1);
1.1.1.6 root 719: }
1.1.1.11 root 720:
721: return DEBUGGER_CMDDONE;
1.1.1.6 root 722: }
1.1.1.11 root 723:
724: /* Parse parameter as breakpoint value */
725: if (!Str_GetNumber(psArgs[1], &BreakAddr)
726: || (BreakAddr > STRamEnd && BreakAddr < 0xe00000)
727: || BreakAddr > 0xff0000)
1.1.1.6 root 728: {
1.1.1.11 root 729: fputs("Not a valid value for a CPU breakpoint!\n", stderr);
730: return DEBUGGER_CMDDONE;
1.1.1.6 root 731: }
1.1.1.11 root 732:
733: /* Is the breakpoint already in the list? Then disable it! */
734: for (i = 0; i < nCpuActiveBPs; i++)
735: {
736: if (BreakAddr == CpuBreakPoint[i])
737: {
738: CpuBreakPoint[i] = CpuBreakPoint[nCpuActiveBPs-1];
739: nCpuActiveBPs -= 1;
740: fprintf(stderr, "CPU breakpoint at %x deleted.\n", BreakAddr);
741: return DEBUGGER_CMDDONE;
742: }
743: }
744:
745: /* Is there at least one free slot available? */
746: if (nCpuActiveBPs == ARRAYSIZE(CpuBreakPoint))
747: {
748: fputs("No more available free CPU breakpoints!\n", stderr);
749: return DEBUGGER_CMDDONE;
750: }
751:
752: /* Add new breakpoint */
753: CpuBreakPoint[nCpuActiveBPs] = BreakAddr;
754: nCpuActiveBPs += 1;
755: fprintf(stderr, "CPU breakpoint added at %x.\n", BreakAddr);
756:
757: return DEBUGGER_CMDDONE;
1.1 root 758: }
759:
1.1.1.11 root 760: /**
761: * CPU wrapper for BreakCond_Command/BreakPointCount, returns DEBUGGER_END
762: */
763: static int DebugUI_BreakCondCpu(int nArgc, char *psArgs[])
764: {
765: BreakCond_Command((const char*)psArgs[1], false);
766: nCpuActiveCBs = BreakCond_BreakPointCount(false);
767: return DEBUGGER_CMDDONE;
768: }
1.1.1.6 root 769:
1.1.1.8 root 770: /**
771: * Do a memory dump, args = starting address.
772: */
1.1.1.11 root 773: static int DebugUI_MemDump(int nArgc, char *psArgs[])
1.1.1.6 root 774: {
775: int i,j;
776: char c;
1.1.1.11 root 777: Uint32 memdump_upper = 0;
1.1.1.2 root 778:
1.1.1.11 root 779: if (nArgc > 1)
1.1.1.6 root 780: {
1.1.1.11 root 781: switch (Str_ParseRange(psArgs[1], &memdump_addr, &memdump_upper))
1.1.1.6 root 782: {
1.1.1.11 root 783: case -1:
784: /* invalid value(s) */
785: return DEBUGGER_CMDDONE;
786: case 0:
787: /* single value */
788: break;
789: case 1:
790: /* range */
1.1.1.6 root 791: memdump_upper &= 0x00FFFFFF;
1.1.1.11 root 792: break;
1.1.1.6 root 793: }
794: } /* continue */
795: memdump_addr &= 0x00FFFFFF;
796:
1.1.1.11 root 797: if (!memdump_upper)
1.1.1.6 root 798: {
799: for (j=0;j<MEMDUMP_ROWS;j++)
800: {
1.1.1.11 root 801: fprintf(debugOutput, "%6.6X: ", memdump_addr); /* print address */
1.1.1.6 root 802: for (i = 0; i < MEMDUMP_COLS; i++) /* print hex data */
1.1.1.9 root 803: fprintf(debugOutput, "%2.2x ", STMemory_ReadByte(memdump_addr++));
804: fprintf(debugOutput, " "); /* print ASCII data */
1.1.1.6 root 805: for (i = 0; i < MEMDUMP_COLS; i++)
806: {
807: c = STMemory_ReadByte(memdump_addr-MEMDUMP_COLS+i);
1.1.1.8 root 808: if (!isprint((unsigned)c))
1.1.1.6 root 809: c = NON_PRINT_CHAR; /* non-printable as dots */
1.1.1.9 root 810: fprintf(debugOutput,"%c", c);
1.1.1.6 root 811: }
1.1.1.9 root 812: fprintf(debugOutput, "\n"); /* newline */
1.1.1.6 root 813: }
1.1.1.9 root 814: fflush(debugOutput);
1.1.1.11 root 815: return DEBUGGER_CMDCONT;
1.1.1.6 root 816: } /* not a range */
817:
818: while (memdump_addr < memdump_upper)
819: {
1.1.1.11 root 820: fprintf(debugOutput, "%6.6X: ", memdump_addr); /* print address */
1.1.1.6 root 821: for (i = 0; i < MEMDUMP_COLS; i++) /* print hex data */
1.1.1.9 root 822: fprintf(debugOutput, "%2.2x ", STMemory_ReadByte(memdump_addr++));
823: fprintf(debugOutput, " "); /* print ASCII data */
1.1.1.6 root 824: for (i = 0; i < MEMDUMP_COLS; i++)
825: {
826: c = STMemory_ReadByte(memdump_addr-MEMDUMP_COLS+i);
1.1.1.8 root 827: if(!isprint((unsigned)c))
1.1.1.6 root 828: c = NON_PRINT_CHAR; /* non-printable as dots */
1.1.1.9 root 829: fprintf(debugOutput,"%c", c);
1.1.1.6 root 830: }
1.1.1.9 root 831: fprintf(debugOutput, "\n"); /* newline */
1.1.1.6 root 832: } /* while */
1.1.1.9 root 833: fflush(debugOutput);
1.1.1.11 root 834:
835: return DEBUGGER_CMDCONT;
836: }
1.1 root 837:
1.1.1.6 root 838:
1.1.1.8 root 839: /**
1.1.1.11 root 840: * Command: Write to memory, arg = starting address, followed by bytes.
1.1.1.8 root 841: */
1.1.1.11 root 842: static int DebugUI_MemWrite(int nArgc, char *psArgs[])
1.1 root 843: {
1.1.1.11 root 844: int i, numBytes;
845: Uint32 write_addr, d;
846: unsigned char bytes[256]; /* store bytes */
1.1.1.6 root 847:
1.1.1.11 root 848: if (nArgc < 3)
849: {
850: DebugUI_PrintCmdHelp(psArgs[0]);
851: return DEBUGGER_CMDDONE;
852: }
1.1.1.6 root 853:
1.1.1.11 root 854: /* Read address */
855: if (!Str_GetNumber(psArgs[1], &write_addr))
1.1.1.6 root 856: {
857: fprintf(stderr, "Bad address!\n");
1.1.1.11 root 858: return DEBUGGER_CMDDONE;
1.1.1.6 root 859: }
860:
861: write_addr &= 0x00FFFFFF;
1.1.1.11 root 862: numBytes = 0;
1.1.1.6 root 863:
864: /* get bytes data */
1.1.1.11 root 865: for (i = 2; i < nArgc; i++)
1.1.1.6 root 866: {
1.1.1.11 root 867: if (!Str_GetNumber(psArgs[i], &d) || d > 255)
1.1.1.6 root 868: {
1.1.1.11 root 869: fprintf(stderr, "Bad byte argument: '%s'!\n", psArgs[i]);
870: return DEBUGGER_CMDDONE;
1.1.1.6 root 871: }
872:
1.1.1.11 root 873: bytes[numBytes] = d & 0x0FF;
1.1.1.6 root 874: numBytes++;
875: }
876:
877: /* write the data */
878: for (i = 0; i < numBytes; i++)
879: STMemory_WriteByte(write_addr + i, bytes[i]);
1.1 root 880:
1.1.1.11 root 881: return DEBUGGER_CMDDONE;
882: }
1.1.1.6 root 883:
1.1.1.8 root 884: /**
1.1.1.11 root 885: * Command: Show given value in bin/dec/hex number bases or change number base
1.1.1.8 root 886: */
1.1.1.11 root 887: static int DebugUI_ShowValue(int argc, char *argv[])
1.1 root 888: {
1.1.1.11 root 889: static const struct {
890: const char name[4];
891: int base;
892: } bases[] = {
893: { "bin", 2 },
894: { "dec", 10 },
895: { "hex", 16 }
896: };
897: bool one, ones;
898: Uint32 value;
899: int bit, i;
900:
901: if (argc < 2)
902: {
903: DebugUI_PrintCmdHelp(argv[0]);
904: return DEBUGGER_CMDDONE;
905: }
906:
907: for (i = 0; i < ARRAYSIZE(bases); i++)
908: {
909: if (strcasecmp(bases[i].name, argv[1]) == 0)
910: {
911: if (ConfigureParams.Log.nNumberBase != bases[i].base)
912: {
913: fprintf(stderr, "Switched default number base from %d to %d-based (%s) values\n",
914: ConfigureParams.Log.nNumberBase,
915: bases[i].base, bases[i].name);
916: ConfigureParams.Log.nNumberBase = bases[i].base;
917: } else {
918: fprintf(stderr, "Already in '%s' mode\n", bases[i].name);
919: }
920: return DEBUGGER_CMDDONE;
921: }
922: }
923:
924: if (!Str_GetNumber(argv[1], &value))
925: return DEBUGGER_CMDDONE;
926:
927: fprintf(stderr, "'%s' = %%", argv[1]);
928: ones = false;
929: for (bit = 31; bit >= 0; bit--)
930: {
931: one = value & (1<<bit);
932: if (one || ones)
933: {
934: fputc(one ? '1':'0', stderr);
935: ones = true;
936: }
937: }
938: if (!ones)
939: fputc('0', stderr);
940: fprintf(stderr, " (bin), #%u (dec), $%x (hex)\n", value, value);
941: return DEBUGGER_CMDDONE;
1.1 root 942: }
943:
1.1.1.9 root 944:
1.1.1.8 root 945: /**
1.1.1.11 root 946: * Command: Set options
1.1.1.8 root 947: */
1.1.1.11 root 948: static int DebugUI_SetOptions(int argc, char *argv[])
1.1.1.6 root 949: {
1.1.1.11 root 950: CNF_PARAMS current;
1.1.1.6 root 951:
1.1.1.11 root 952: /* get configuration changes */
953: current = ConfigureParams;
1.1 root 954:
1.1.1.11 root 955: /* Parse and apply options */
956: if (Opt_ParseParameters(argc, (const char**)argv))
1.1.1.6 root 957: {
1.1.1.11 root 958: ConfigureParams.Screen.bFullScreen = false;
959: Change_CopyChangedParamsToConfiguration(¤t, &ConfigureParams, false);
1.1.1.6 root 960: }
1.1.1.11 root 961: else
962: {
963: ConfigureParams = current;
964: }
965:
966: return DEBUGGER_CMDDONE;
967: }
968:
969:
970: /**
971: * Command: Continue emulation / single-stepping
972: */
973: static int DebugUI_Continue(int nArgc, char *psArgv[], bool bStepDsp)
974: {
975: const char *chip;
976: int steps = 0;
977:
978: if (nArgc > 1)
979: {
980: steps = atoi(psArgv[1]);
981: }
982: /* at most one should be active at the same time */
983: nDspSteps = 0;
984: nCpuSteps = 0;
985: if (steps <= 0)
986: {
1.1.1.12! root 987: fprintf(stderr,"Returning to emulation...\n");
1.1.1.11 root 988: return DEBUGGER_END;
989: }
990: if (bStepDsp)
991: {
992: nDspSteps = steps;
993: #if ENABLE_DSP_EMU
994: chip = "DSP";
995: #else
996: chip = "<NONE>";
997: #endif
998: } else {
999: nCpuSteps = steps;
1000: chip = "CPU";
1.1.1.9 root 1001: }
1.1.1.11 root 1002: fprintf(stderr,"Returning to emulation for %i %s instructions...\n", steps, chip);
1003: return DEBUGGER_END;
1004: }
1005:
1006: /**
1007: * Command: Continue emulation / single-stepping CPU wrapper
1008: */
1009: static int DebugUI_CpuContinue(int nArgc, char *psArgv[])
1010: {
1011: return DebugUI_Continue(nArgc, psArgv, false);
1012: }
1013: /**
1014: * Command: Continue emulation / single-stepping DSP wrapper
1015: */
1016: static int DebugUI_DspContinue(int nArgc, char *psArgv[])
1017: {
1018: return DebugUI_Continue(nArgc, psArgv, true);
1019: }
1.1.1.6 root 1020:
1.1.1.8 root 1021:
1.1.1.11 root 1022: /**
1023: * Command: Quit emulator
1024: */
1025: static int DebugUI_QuitEmu(int nArgc, char *psArgv[])
1026: {
1027: bQuitProgram = true;
1028: M68000_SetSpecial(SPCFLAG_BRK); /* Assure that CPU core shuts down */
1029: return DEBUGGER_END;
1030: }
1031:
1032:
1033: typedef struct
1034: {
1035: int (*pFunction)(int argc, char *argv[]);
1036: const char *sLongName;
1037: const char *sShortName;
1038: const char *sShortDesc;
1039: const char *sUsage;
1040: bool bNoParsing;
1041: } dbgcommand_t;
1042:
1043: dbgcommand_t commandtab[] =
1044: {
1045: #if ENABLE_DSP_EMU
1046: { DebugUI_DspBreakPoint, "dspaddress", "da",
1047: "toggle or list (traditional) DSP address breakpoints",
1048: "[address]\n"
1049: "\tToggle breakpoint at <address> or list all breakpoints when\n"
1050: "\tno address is given.",
1051: false },
1052: { DebugUI_BreakCondDsp, "dspbreak", "db",
1053: "set/remove/list DSP register/RAM condition breakpoints",
1054: "[help | all | <breakpoint index> | <breakpoint condition>]\n"
1055: "\tSet breakpoint with given condition, remove breakpoint with\n"
1056: "\tgiven index or list all breakpoints when no args are given.\n"
1057: "\t'help' outputs breakpoint condition syntax help, 'all' removes\n"
1058: "\tall conditional breakpoints",
1059: true },
1060: { DebugUI_DspDisAsm, "dspdisasm", "dd",
1061: "disassemble DSP code",
1062: "[address]\n"
1063: "\tDisassemble from DSP-PC, otherwise at given address.",
1064: false },
1065: { DebugUI_DspMemDump, "dspmemdump", "dm",
1066: "dump DSP memory",
1067: "<x|y|p> [address]\n"
1068: "\tdump DSP memory at address, or continue from previous address if not\n"
1069: "\tspecified.",
1070: false },
1071: { DebugUI_DspRegister, "dspreg", "dr",
1072: "read/write DSP registers",
1073: "[REG=value]"
1074: "\tSet or dump contents of DSP registers.",
1075: false },
1076: { DebugUI_DspContinue, "dspcont", "dc",
1077: "continue emulation / DSP single-stepping",
1078: "[steps]\n"
1079: "\tLeave debugger and continue emulation for <steps> DSP instructions\n"
1080: "\tor forever if no steps have been specified.",
1081: false },
1082: #endif
1083: { DebugUI_CpuBreakPoint, "address", "a",
1084: "toggle or list (traditional) CPU address breakpoints",
1085: "[address]\n"
1086: "\tToggle breakpoint at <address> or list all breakpoints when\n"
1087: "\tno address is given.",
1088: false },
1089: { DebugUI_BreakCondCpu, "breakpoint", "b",
1090: "set/remove/list register/RAM condition breakpoints",
1091: "[help | all | <breakpoint index> | <breakpoint condition>]\n"
1092: "\tSet breakpoint with given condition, remove breakpoint with\n"
1093: "\tgiven index or list all breakpoints when no args are given.\n"
1094: "\t'help' outputs breakpoint condition syntax help, 'all' removes\n"
1095: "\tall conditional breakpoints",
1096: true },
1097: { DebugUI_DisAsm, "disasm", "d",
1098: "disassemble from PC, or given address",
1099: "[address]\n"
1100: "\tIf no address is given, this command disassembles from the last\n"
1101: "\tposition or from current PC if no last postition is available.",
1102: false },
1103: { DebugUI_CpuRegister, "cpureg", "r",
1104: "dump register values or set register to value",
1105: "[REG=value]\n"
1106: "\tSet CPU register to value or dumps all register if no parameter\n"
1107: "\thas been specified.",
1108: false },
1109: { DebugUI_MemDump, "memdump", "m",
1110: "dump memory",
1111: "[address]\n"
1112: "\tdump memory at address or continue dump from previous address.",
1113: false },
1114: { DebugUI_MemWrite, "memwrite", "w",
1115: "write bytes to memory",
1116: "address byte1 [byte2 ...]\n"
1117: "\tWrite bytes to a memory address, bytes are space separated\n"
1118: "\thexadecimals.",
1119: false },
1120: { DebugUI_SetLogFile, "logfile", "f",
1121: "open or close log file",
1122: "[filename]\n"
1123: "\tOpen log file, no argument closes the log file. Output of\n"
1124: "\tregister & memory dumps and disassembly will be written to it.",
1125: false },
1126: { DebugUI_LoadBin, "loadbin", "l",
1127: "load a file into memory",
1128: "filename address\n"
1129: "\tLoad the file <filename> into memory starting at <address>.",
1130: false },
1131: { DebugUI_SaveBin, "savebin", "s",
1132: "save memory to a file",
1133: "filename address length\n"
1134: "\tSave the memory block at <address> with given <length> to\n"
1135: "\tthe file <filename>.",
1136: false },
1137: { DebugUI_SetOptions, "setopt", "o",
1138: "set Hatari command line options",
1139: "[command line parameters]\n"
1140: "\tSet options like command line parameters. For example to"
1141: "\tenable CPU disasm tracing: setopt --trace cpu_disasm",
1142: false },
1143: { DebugUI_ShowValue, "value", "v",
1144: "set number base / show value in other number bases",
1145: "<bin|dec|hex|value>\n"
1146: "\tHelper to change the default number base and to see given values\n"
1147: "\tin all the supported bin/dec/hex number bases.",
1148: false },
1149: { DebugUI_CpuContinue, "cont", "c",
1150: "continue emulation / CPU single-stepping",
1151: "[steps]\n"
1152: "\tLeave debugger and continue emulation for <steps> CPU instructions\n"
1153: "\tor forever if no steps have been specified.",
1154: false },
1155: { DebugUI_QuitEmu, "quit", "q",
1156: "quit emulator",
1157: "\n"
1158: "\tLeave debugger and quit emulator.",
1159: false },
1160: { DebugUI_Help, "help", "h",
1161: "print help",
1162: "[command]"
1163: "\tPrint help text for available commands.",
1164: false },
1165: };
1166:
1167:
1168: /**
1169: * Print help text for one command
1170: */
1171: static void DebugUI_PrintCmdHelp(const char *psCmd)
1172: {
1173: int i;
1174:
1175: /* Search the command ... */
1176: for (i = 0; i < ARRAYSIZE(commandtab); i++)
1.1.1.6 root 1177: {
1.1.1.11 root 1178: if (!strcmp(psCmd, commandtab[i].sLongName)
1179: || !strcmp(psCmd, commandtab[i].sShortName))
1180: {
1181: /* ... and print help text */
1182: fprintf(stderr, "'%s' or '%s' - %s\n",
1183: commandtab[i].sLongName, commandtab[i].sShortName,
1184: commandtab[i].sShortDesc);
1185: fprintf(stderr, "Usage: %s %s\n", commandtab[i].sShortName,
1186: commandtab[i].sUsage);
1187: return;
1.1.1.6 root 1188: }
1.1.1.11 root 1189: }
1.1.1.6 root 1190:
1.1.1.11 root 1191: fprintf(stderr, "Unknown command '%s'\n", psCmd);
1192: }
1.1.1.6 root 1193:
1194:
1.1.1.11 root 1195: /**
1196: * Command: Print debugger help screen.
1197: */
1198: static int DebugUI_Help(int nArgc, char *psArgs[])
1199: {
1200: int i;
1201:
1202: if (nArgc > 1)
1203: {
1204: DebugUI_PrintCmdHelp(psArgs[1]);
1205: return DEBUGGER_CMDDONE;
1206: }
1207:
1208: fputs("Available commands:\n", stderr);
1209: for (i = 0; i < ARRAYSIZE(commandtab); i++)
1210: {
1211: fprintf(stderr, " %12s (%2s) : %s\n", commandtab[i].sLongName,
1212: commandtab[i].sShortName, commandtab[i].sShortDesc);
1213: }
1214:
1215: fprintf(stderr,
1216: "If value is prefixed with '$', it's a hexadecimal, if with '#', it's\n"
1217: "a normal decimal, if with '%%', it's a binary decimal. Prefix can\n"
1218: "be skipped for numbers in the default number base (currently %d).\n"
1219: "Adresses may be given as a range like '$fc0000-$fc0100'.\n"
1220: "'h <command>' gives more help.\n", ConfigureParams.Log.nNumberBase);
1221: return DEBUGGER_CMDDONE;
1222: }
1223:
1224:
1225: /**
1226: * Parse debug command and execute it.
1227: */
1228: int DebugUI_ParseCommand(char *input)
1229: {
1230: char *psArgs[64];
1231: const char *delim;
1232: static char sLastCmd[80] = { '\0' };
1233: int nArgc, cmd = -1;
1234: int i, retval;
1.1.1.6 root 1235:
1.1.1.11 root 1236: psArgs[0] = strtok(input, " \t");
1237:
1238: if (psArgs[0] == NULL)
1239: {
1240: if (strlen(sLastCmd) > 0)
1241: psArgs[0] = sLastCmd;
1.1.1.8 root 1242: else
1.1.1.11 root 1243: return DEBUGGER_CMDDONE;
1244: }
1245:
1246: /* Search the command ... */
1247: for (i = 0; i < ARRAYSIZE(commandtab); i++)
1248: {
1249: if (!strcmp(psArgs[0], commandtab[i].sLongName)
1250: || !strcmp(psArgs[0], commandtab[i].sShortName))
1251: {
1252: cmd = i;
1253: break;
1254: }
1255: }
1256: if (cmd == -1)
1257: {
1258: fprintf(stderr, "Command '%s' not found.\n"
1259: "Use 'help' to view a list of available commands.\n",
1260: psArgs[0]);
1261: return DEBUGGER_CMDDONE;
1262: }
1263:
1264: if (commandtab[cmd].bNoParsing)
1265: delim = "";
1266: else
1267: delim = " \t";
1268:
1269: /* Separate arguments and put the pointers into psArgs */
1270: for (nArgc = 1; nArgc < ARRAYSIZE(psArgs); nArgc++)
1271: {
1272: psArgs[nArgc] = strtok(NULL, delim);
1273: if (psArgs[nArgc] == NULL)
1274: break;
1275: }
1.1.1.6 root 1276:
1.1.1.11 root 1277: if (!debugOutput) {
1278: /* make sure also calls from control.c work */
1279: DebugUI_SetLogDefault();
1.1.1.6 root 1280: }
1281:
1.1.1.11 root 1282: /* ... and execute the function */
1283: retval = commandtab[i].pFunction(nArgc, psArgs);
1284: /* Save commando string if it can be repeated */
1285: if (retval == DEBUGGER_CMDCONT)
1286: strncpy(sLastCmd, psArgs[0], sizeof(sLastCmd));
1287: else
1288: sLastCmd[0] = '\0';
1.1.1.9 root 1289: return retval;
1290: }
1291:
1.1.1.11 root 1292:
1.1.1.9 root 1293: /**
1.1.1.11 root 1294: * Read a command line from the keyboard and return a pointer to the string.
1295: * @return Pointer to the string which should be deallocated free()
1296: * after use. Returns NULL when error occured.
1.1.1.9 root 1297: */
1.1.1.11 root 1298: static char *DebugUI_GetCommand(void)
1.1.1.9 root 1299: {
1300: char *input;
1.1.1.8 root 1301:
1.1.1.9 root 1302: #if HAVE_LIBREADLINE
1303: input = readline("> ");
1304: if (!input)
1.1.1.11 root 1305: return NULL;
1.1.1.9 root 1306: if (input[0] != 0)
1307: add_history(input);
1308: #else
1309: fprintf(stderr, "> ");
1310: input = malloc(256);
1311: if (!input)
1.1.1.11 root 1312: return NULL;
1.1.1.9 root 1313: input[0] = '\0';
1.1.1.11 root 1314: if (fgets(input, 256, stdin) == NULL)
1315: {
1316: free(input);
1317: return NULL;
1318: }
1.1.1.9 root 1319: #endif
1.1.1.11 root 1320: input = Str_Trim(input);
1.1.1.9 root 1321:
1.1.1.11 root 1322: return input;
1323: }
1324:
1325:
1326: /**
1327: * Texts shown when entering the debugger on first and successive times
1328: */
1329: static void DebugUI_WelcomeText(void)
1330: {
1331: int hbl, fcycles, lcycles;
1332: static const char *welcome =
1333: "\n----------------------------------------------------------------------"
1334: "\nYou have entered debug mode. Type c to continue emulation, h for help.\n";
1335: if (welcome)
1336: {
1337: fputs(welcome, stderr);
1338: welcome = NULL;
1339: }
1340: Video_GetPosition(&fcycles, &hbl, &lcycles);
1341: fprintf(stderr, "\nCPU=$%x, VBL=%d, FrameCycles=%d, HBL=%d, LineCycles=%d, DSP=",
1342: M68000_GetPC(), nVBLs, fcycles, hbl, lcycles);
1343: if (bDspEnabled)
1344: fprintf(stderr, "$%x\n", DSP_GetPC());
1345: else
1346: fprintf(stderr, "N/A\n");
1.1 root 1347: }
1348:
1349:
1.1.1.8 root 1350: /**
1.1.1.11 root 1351: * Debugger user interface main function.
1.1.1.8 root 1352: */
1.1.1.4 root 1353: void DebugUI(void)
1.1 root 1354: {
1.1.1.11 root 1355: int cmdret;
1356:
1357: /* if you want disassembly or memdumping to start/continue from
1358: * specific address, you can set them here. If disassembly
1359: * address is zero, disassembling starts from PC.
1360: */
1361: #if ENABLE_DSP_EMU
1362: dsp_disasm_addr = 0;
1363: dsp_memdump_addr = 0;
1364: dsp_mem_space = 'P';
1365: #endif
1366: memdump_addr = 0;
1.1.1.6 root 1367: disasm_addr = 0;
1.1.1.2 root 1368:
1.1.1.11 root 1369: if (bInFullScreen)
1370: Screen_ReturnFromFullScreen();
1371:
1372: DebugUI_WelcomeText();
1373:
1374: /* override paused message so that user knows to look into console
1375: * on how to continue in case he invoked the debugger by accident.
1376: */
1377: Statusbar_AddMessage("Console Debugger", 100);
1378: Statusbar_Update(sdlscrn);
1379:
1380: do
1381: {
1382: char *psCmd;
1383:
1384: /* Read command from the keyboard */
1385: psCmd = DebugUI_GetCommand();
1386:
1387: if (psCmd)
1388: {
1389: /* Parse and execute the command string */
1390: cmdret = DebugUI_ParseCommand(psCmd);
1391: free(psCmd);
1392: }
1393: else
1394: {
1395: cmdret = DEBUGGER_END;
1396: }
1397: }
1398: while (cmdret != DEBUGGER_END);
1399:
1.1.1.9 root 1400: DebugUI_SetLogDefault();
1.1.1.11 root 1401:
1402: /* If "real-time" debugging like breakpoints has been set, we've
1403: * got to tell the CPU core to call us after each instruction! */
1404: if (nCpuActiveBPs || nCpuActiveCBs || nCpuSteps)
1405: M68000_SetSpecial(SPCFLAG_DEBUGGER);
1406: else
1407: M68000_UnsetSpecial(SPCFLAG_DEBUGGER);
1408: /* ...and DSP core */
1409: if (nDspActiveBPs || nDspActiveCBs || nDspSteps)
1410: DSP_SetDebugging(true);
1411: else
1412: DSP_SetDebugging(false);
1413: }
1414:
1415:
1416: /**
1417: * Check if we hit a CPU breakpoint
1418: */
1419: static void DebugUI_CheckCpuBreakpoints(void)
1420: {
1421: Uint32 pc = M68000_GetPC();
1422: int i;
1423:
1424: for (i = 0; i < nCpuActiveBPs; i++)
1425: {
1426: if (pc == CpuBreakPoint[i])
1427: {
1428: fprintf(stderr, "\nCPU breakpoint at %x ...", pc);
1429: DebugUI();
1430: break;
1431: }
1432: }
1433: }
1434:
1435:
1436: /**
1437: * This function is called after each CPU instruction when debugging is enabled.
1438: */
1439: void DebugUI_CpuCheck(void)
1440: {
1441: if (nCpuActiveBPs)
1442: {
1443: DebugUI_CheckCpuBreakpoints();
1444: }
1445: if (nCpuActiveCBs)
1446: {
1447: if (BreakCond_MatchCpu())
1448: DebugUI();
1449: }
1450: if (nCpuSteps)
1451: {
1452: nCpuSteps -= 1;
1453: if (nCpuSteps == 0)
1454: DebugUI();
1455: }
1.1 root 1456: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.