![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to debugInfo.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 / debug|
Return to debugInfo.c CVS log | Up to [HATARI the Atari ST Emulator] / hatari / src / debug |
1.1 root 1: /*
2: Hatari - debuginfo.c
3:
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:
7: debuginfo.c - functions needed to show info about the atari HW & OS
8: components and "lock" that info to be shown on entering the debugger.
9: */
10: const char DebugInfo_fileid[] = "Hatari debuginfo.c : " __DATE__ " " __TIME__;
11:
12: #include <stdio.h>
13: #include <assert.h>
14: #include "main.h"
15: #include "configuration.h"
16: #include "debugInfo.h"
17: #include "debugcpu.h"
18: #include "debugdsp.h"
19: #include "debugui.h"
20: #include "dsp.h"
21: #include "evaluate.h"
22: #include "ioMem.h"
23: #include "m68000.h"
24: #include "stMemory.h"
25: #include "tos.h"
26: #include "video.h"
27:
28:
29: /* ------------------------------------------------------------------
30: * TOS information
31: */
32: #define OS_SYSBASE 0x4F2
33: #define OS_HEADER_SIZE 0x30
34:
35: #define COOKIE_JAR 0x5A0
36:
37: #define BASEPAGE_SIZE 0x100
38:
39: #define GEM_MAGIC 0x87654321
40: #define GEM_MUPB_SIZE 0xC
41:
42: #define RESET_MAGIC 0x31415926
43: #define RESET_VALID 0x426
44: #define RESET_VECTOR 0x42A
45:
46: #define COUNTRY_SPAIN 4
47:
48: /**
49: * DebugInfo_GetSysbase: set osversion to given argument.
50: * return sysbase address on success and zero on failure.
51: */
52: static Uint32 DebugInfo_GetSysbase(Uint16 *osversion)
53: {
54: Uint32 sysbase = STMemory_ReadLong(OS_SYSBASE);
55:
56: if (!STMemory_ValidArea(sysbase, OS_HEADER_SIZE)) {
57: fprintf(stderr, "Invalid TOS base address!\n");
58: return 0;
59: }
60: if (sysbase != TosAddress || sysbase != STMemory_ReadLong(sysbase+0x08)) {
61: fprintf(stderr, "Sysbase and os_beg address in OS header mismatch!\n");
62: return 0;
63: }
64: *osversion = STMemory_ReadWord(sysbase+0x02);
65: return sysbase;
66: }
67:
68: /**
69: * DebugInfo_CurrentBasepage: get currently running TOS program basepage
70: */
71: static Uint32 DebugInfo_CurrentBasepage(void)
72: {
73: Uint32 basepage, sysbase;
74: Uint16 osversion, osconf;
75:
76: sysbase = DebugInfo_GetSysbase(&osversion);
77: if (!sysbase) {
78: return 0;
79: }
80: if (osversion >= 0x0102) {
81: basepage = STMemory_ReadLong(sysbase+0x28);
82: } else {
83: osconf = STMemory_ReadWord(sysbase+0x1C);
84: if((osconf>>1) == COUNTRY_SPAIN) {
85: basepage = 0x873C;
86: } else {
87: basepage = 0x602C;
88: }
89: }
90: if (STMemory_ValidArea(basepage, 4)) {
91: return STMemory_ReadLong(basepage);
92: }
93: fprintf(stderr, "Pointer 0x%06x to basepage address is invalid!\n", basepage);
94: return 0;
95: }
96:
97: /**
98: * DebugInfo_Basepage: show TOS process basepage information
99: * at given address.
100: */
101: static void DebugInfo_Basepage(Uint32 basepage)
102: {
103: Uint8 cmdlen;
104: Uint32 env;
105:
106: if (!basepage) {
107: /* default to current process basepage */
108: basepage = DebugInfo_CurrentBasepage();
109: if (!basepage) {
110: return;
111: }
112: }
113: fprintf(stderr, "Process basepage information:\n");
114: if (!STMemory_ValidArea(basepage, BASEPAGE_SIZE) ||
115: STMemory_ReadLong(basepage) != basepage) {
116: fprintf(stderr, "- address 0x%06x is invalid!\n", basepage);
117: return;
118: }
119: fprintf(stderr, "- TPA start : 0x%06x\n", STMemory_ReadLong(basepage));
120: fprintf(stderr, "- TPA end +1 : 0x%06x\n", STMemory_ReadLong(basepage+0x04));
121: fprintf(stderr, "- Text segment : 0x%06x\n", STMemory_ReadLong(basepage+0x08));
122: fprintf(stderr, "- Text size : 0x%x\n", STMemory_ReadLong(basepage+0x0C));
123: fprintf(stderr, "- Data segment : 0x%06x\n", STMemory_ReadLong(basepage+0x10));
124: fprintf(stderr, "- Data size : 0x%x\n", STMemory_ReadLong(basepage+0x14));
125: fprintf(stderr, "- BSS segment : 0x%06x\n", STMemory_ReadLong(basepage+0x18));
126: fprintf(stderr, "- BSS size : 0x%x\n", STMemory_ReadLong(basepage+0x1C));
127: fprintf(stderr, "- Process DTA : 0x%06x\n", STMemory_ReadLong(basepage+0x20));
128: fprintf(stderr, "- Parent basepage: 0x%06x\n", STMemory_ReadLong(basepage+0x24));
129:
130: env = STMemory_ReadLong(basepage+0x2C);
131: fprintf(stderr, "- Environment : 0x%06x\n", env);
132: if (STMemory_ValidArea(env, 4096)) {
133: Uint32 end = env + 4096;
134: while (env < end && *(STRam+env)) {
135: fprintf(stderr, "'%s'\n", STRam+env);
136: env += strlen((const char *)(STRam+env)) + 1;
137: }
138: }
139: cmdlen = STMemory_ReadByte(basepage+0x80);
140: fprintf(stderr, "- Command argslen: %d\n", cmdlen);
141: if (cmdlen) {
142: int offset = 0;
143: while (offset < cmdlen) {
144: fprintf(stderr, " '%s'", STRam+basepage+0x81+offset);
145: offset += strlen((const char *)(STRam+basepage+0x81+offset)) + 1;
146: }
147: fprintf(stderr, "\n");
148: }
149: }
150:
151: /**
152: * DebugInfo_OSHeader: display TOS OS Header
153: */
154: static void DebugInfo_OSHeader(Uint32 dummy)
155: {
156: Uint32 sysbase, gemblock, basepage;
157: Uint16 osversion, osconf;
158:
159: sysbase = DebugInfo_GetSysbase(&osversion);
160: if (!sysbase) {
161: return;
162: }
163: fprintf(stderr, "OS base addr : 0x%06x\n", sysbase);
164: fprintf(stderr, "OS RAM end+1 : 0x%06x\n", STMemory_ReadLong(sysbase+0x0C));
165: fprintf(stderr, "TOS version : 0x%x\n", osversion);
166:
167: fprintf(stderr, "Reset handler: 0x%06x\n", STMemory_ReadLong(sysbase+0x04));
168: fprintf(stderr, "Reset vector : 0x%06x\n", STMemory_ReadLong(RESET_VECTOR));
169: fprintf(stderr, "Reset valid : 0x%x (valid=0x%x)\n", STMemory_ReadLong(RESET_VALID), RESET_MAGIC);
170:
171: gemblock = STMemory_ReadLong(sysbase+0x14);
172: fprintf(stderr, "GEM Memory Usage Parameter Block:\n");
173: if (STMemory_ValidArea(gemblock, GEM_MUPB_SIZE)) {
174: fprintf(stderr, "- Block addr : 0x%06x\n", gemblock);
175: fprintf(stderr, "- GEM magic : 0x%x (valid=0x%x)\n", STMemory_ReadLong(gemblock), GEM_MAGIC);
176: fprintf(stderr, "- GEM entry : 0x%06x\n", STMemory_ReadLong(gemblock+4));
177: fprintf(stderr, "- GEM end : 0x%06x\n", STMemory_ReadLong(gemblock+8));
178: } else {
179: fprintf(stderr, "- is at INVALID 0x%06x address.\n", gemblock);
180: }
181:
182: fprintf(stderr, "OS date : 0x%x\n", STMemory_ReadLong(sysbase+0x14));
183: fprintf(stderr, "OS DOS date : 0x%x\n", STMemory_ReadLong(sysbase+0x1E));
184:
185: osconf = STMemory_ReadWord(sysbase+0x1C);
186: fprintf(stderr, "OS Conf bits : lang=%d, %s\n", osconf>>1, osconf&1 ? "PAL":"NTSC");
187: fprintf(stderr, "Cookie Jar : 0x%06x\n", STMemory_ReadLong(COOKIE_JAR));
188:
189: /* last 3 OS header fields are only available as of TOS 1.02 */
190: if (osversion >= 0x0102) {
191: fprintf(stderr, "Memory pool : 0x%06x\n", STMemory_ReadLong(sysbase+0x20));
192: fprintf(stderr, "Kbshift addr : 0x%06x\n", STMemory_ReadLong(sysbase+0x24));
193: } else {
194: /* TODO: GEMDOS memory pool address for TOS 1.0? */
195: fprintf(stderr, "Kbshift addr : 0x000E1B\n");
196: }
197: basepage = DebugInfo_CurrentBasepage();
198: if (basepage) {
199: fprintf(stderr, "Basepage : 0x%06x\n", basepage);
200: }
201: }
202:
203:
204: /* ------------------------------------------------------------------
205: * Falcon HW information
206: */
207:
208: /**
209: * DebugInfo_Videl : display the Videl registers values.
210: */
211: static void DebugInfo_Videl(Uint32 dummy)
212: {
213: if (ConfigureParams.System.nMachineType != MACHINE_FALCON) {
214: fprintf(stderr, "Not Falcon - no Videl!\n");
215: return;
216: }
217:
218: fprintf(stderr, "$FF8006 : monitor type : %02x\n", IoMem_ReadByte(0xff8006));
219: fprintf(stderr, "$FF820E : offset to next line : %04x\n", IoMem_ReadWord(0xff820e));
220: fprintf(stderr, "$FF8210 : VWRAP - line width : %04x\n", IoMem_ReadWord(0xff8210));
221: fprintf(stderr, "$FF8260 : ST shift mode : %02x\n", IoMem_ReadByte(0xff8260));
222: fprintf(stderr, "$FF8265 : Horizontal scroll register : %02x\n", IoMem_ReadByte(0xff8265));
223: fprintf(stderr, "$FF8266 : Falcon shift mode : %04x\n", IoMem_ReadWord(0xff8266));
224: fprintf(stderr, "\n");
225: fprintf(stderr, "$FF8280 : HHC - Horizontal Hold Counter : %04x\n", IoMem_ReadWord(0xff8280));
226: fprintf(stderr, "$FF8282 : HHT - Horizontal Hold Timer : %04x\n", IoMem_ReadWord(0xff8282));
227: fprintf(stderr, "$FF8284 : HBB - Horizontal Border Begin : %04x\n", IoMem_ReadWord(0xff8284));
228: fprintf(stderr, "$FF8286 : HBE - Horizontal Border End : %04x\n", IoMem_ReadWord(0xff8286));
229: fprintf(stderr, "$FF8288 : HDB - Horizontal Display Begin : %04x\n", IoMem_ReadWord(0xff8288));
230: fprintf(stderr, "$FF828A : HDE - Horizontal Display End : %04x\n", IoMem_ReadWord(0xff828a));
231: fprintf(stderr, "$FF828C : HSS - Horizontal SS : %04x\n", IoMem_ReadWord(0xff828c));
232: fprintf(stderr, "$FF828E : HFS - Horizontal FS : %04x\n", IoMem_ReadWord(0xff828e));
233: fprintf(stderr, "$FF8290 : HEE - Horizontal EE : %04x\n", IoMem_ReadWord(0xff8290));
234: fprintf(stderr, "\n");
235: fprintf(stderr, "$FF82A0 : VFC - Vertical Frequency Counter : %04x\n", IoMem_ReadWord(0xff82a0));
236: fprintf(stderr, "$FF82A2 : VFT - Vertical Frequency Timer : %04x\n", IoMem_ReadWord(0xff82a2));
237: fprintf(stderr, "$FF82A4 : VBB - Vertical Border Begin : %04x\n", IoMem_ReadWord(0xff82a4));
238: fprintf(stderr, "$FF82A6 : VBE - Vertical Border End : %04x\n", IoMem_ReadWord(0xff82a6));
239: fprintf(stderr, "$FF82A8 : VDB - Vertical Display Begin : %04x\n", IoMem_ReadWord(0xff82a8));
240: fprintf(stderr, "$FF82AA : VDE - Vertical Display End : %04x\n", IoMem_ReadWord(0xff82aa));
241: fprintf(stderr, "$FF82AC : VSS - Vertical SS : %04x\n", IoMem_ReadWord(0xff82ac));
242: fprintf(stderr, "\n");
243: fprintf(stderr, "$FF82C0 : VCO - Video control : %04x\n", IoMem_ReadWord(0xff82c0));
244: fprintf(stderr, "$FF82C2 : VMD - Video mode : %04x\n", IoMem_ReadWord(0xff82c2));
245: fprintf(stderr, "\n");
246: }
247:
248: /**
249: * DebugInfo_Crossbar : display the Crossbar registers values.
250: */
251: static void DebugInfo_Crossbar(Uint32 dummy)
252: {
253: char matrixDMA[5], matrixDAC[5], matrixDSP[5], matrixEXT[5];
254: char frqDMA[11], frqDAC[11], frqDSP[11], frqEXT[11];
255: char dataSize[15];
256:
257: if (ConfigureParams.System.nMachineType != MACHINE_FALCON) {
258: fprintf(stderr, "Not Falcon - no Crossbar!\n");
259: return;
260: }
261:
262: fprintf(stderr, "$FF8900 : Sound DMA control : %02x\n", IoMem_ReadByte(0xff8900));
263: fprintf(stderr, "$FF8901 : Sound DMA control : %02x\n", IoMem_ReadByte(0xff8901));
264: fprintf(stderr, "$FF8903 : Frame Start High : %02x\n", IoMem_ReadByte(0xff8903));
265: fprintf(stderr, "$FF8905 : Frame Start middle : %02x\n", IoMem_ReadByte(0xff8905));
266: fprintf(stderr, "$FF8907 : Frame Start low : %02x\n", IoMem_ReadByte(0xff8907));
267: fprintf(stderr, "$FF8909 : Frame Count High : %02x\n", IoMem_ReadByte(0xff8909));
268: fprintf(stderr, "$FF890B : Frame Count middle : %02x\n", IoMem_ReadByte(0xff890b));
269: fprintf(stderr, "$FF890D : Frame Count low : %02x\n", IoMem_ReadByte(0xff890d));
270: fprintf(stderr, "$FF890f : Frame End High : %02x\n", IoMem_ReadByte(0xff890f));
271: fprintf(stderr, "$FF8911 : Frame End middle : %02x\n", IoMem_ReadByte(0xff8911));
272: fprintf(stderr, "$FF8913 : Frame End low : %02x\n", IoMem_ReadByte(0xff8913));
273: fprintf(stderr, "\n");
274: fprintf(stderr, "$FF8920 : Sound Mode Control : %02x\n", IoMem_ReadByte(0xff8920));
275: fprintf(stderr, "$FF8921 : Sound Mode Control : %02x\n", IoMem_ReadByte(0xff8921));
276: fprintf(stderr, "$FF8930 : DMA Crossbar Input Select Controller : %04x\n", IoMem_ReadWord(0xff8930));
277: fprintf(stderr, "$FF8932 : DMA Crossbar Output Select Controller : %04x\n", IoMem_ReadWord(0xff8932));
278: fprintf(stderr, "\n");
279: fprintf(stderr, "$FF8934 : External Sync Frequency Divider : %02x\n", IoMem_ReadByte(0xff8934));
280: fprintf(stderr, "$FF8935 : Internal Sync Frequency Divider : %02x\n", IoMem_ReadByte(0xff8935));
281: fprintf(stderr, "$FF8936 : Record Track select : %02x\n", IoMem_ReadByte(0xff8936));
282: fprintf(stderr, "$FF8937 : Codec Input Source : %02x\n", IoMem_ReadByte(0xff8937));
283: fprintf(stderr, "$FF8938 : Codec ADC Input : %02x\n", IoMem_ReadByte(0xff8938));
284: fprintf(stderr, "$FF8939 : Gain Settings Per Channel : %02x\n", IoMem_ReadByte(0xff8939));
285: fprintf(stderr, "$FF893A : Attenuation Settings Per Channel : %02x\n", IoMem_ReadByte(0xff893a));
286: fprintf(stderr, "$FF893C : Codec Status : %04x\n", IoMem_ReadWord(0xff893c));
287: fprintf(stderr, "$FF8940 : GPIO Data Direction : %04x\n", IoMem_ReadWord(0xff8940));
288: fprintf(stderr, "$FF8942 : GPIO Data : %04x\n", IoMem_ReadWord(0xff8942));
289: fprintf(stderr, "\n");
290:
291: /* DAC connexion */
292: switch ((IoMem_ReadWord(0xff8932) >> 13) & 3) {
293: case 0 : strcpy(matrixDAC, "OOXO"); break;
294: case 1 : strcpy(matrixDAC, "OXOO"); break;
295: case 2 : strcpy(matrixDAC, "XOOO"); break;
296: case 3 : strcpy(matrixDAC, "OOOX"); break;
297: }
298:
299: /* DMA connexion */
300: switch ((IoMem_ReadWord(0xff8932) >> 1) & 3) {
301: case 0 : strcpy(matrixDMA, "OOXO"); break;
302: case 1 : strcpy(matrixDMA, "OXOO"); break;
303: case 2 : strcpy(matrixDMA, "XOOO"); break;
304: case 3 : strcpy(matrixDMA, "OOOX"); break;
305: }
306:
307: /* DSP connexion */
308: switch ((IoMem_ReadWord(0xff8932) >> 5) & 3) {
309: case 0 : strcpy(matrixDSP, "OOXO"); break;
310: case 1 : strcpy(matrixDSP, "OXOO"); break;
311: case 2 : strcpy(matrixDSP, "XOOO"); break;
312: case 3 : strcpy(matrixDSP, "OOOX"); break;
313: }
314:
315: /* External input connexion */
316: switch ((IoMem_ReadWord(0xff8932) >> 9) & 3) {
317: case 0 : strcpy(matrixEXT, "OOXO"); break;
318: case 1 : strcpy(matrixEXT, "OXOO"); break;
319: case 2 : strcpy(matrixEXT, "XOOO"); break;
320: case 3 : strcpy(matrixEXT, "OOOX"); break;
321: }
322:
323: /* HandShake mode test */
324: if ((IoMem_ReadWord(0xff8932) & 7) == 2) {
325: matrixDMA[1] = 'H';
326: }
327:
328: /* HandShake mode test */
329: if ((IoMem_ReadWord(0xff8932) & 0xf) == 2) {
330: matrixDSP[2] = 'H';
331: }
332:
333: /* DSP Frequency */
334: if ((IoMem_ReadByte(0xff8935) & 0xf) == 0) {
335: strcpy(frqDSP, "(STe Freq)");
336: }else {
337: switch ((IoMem_ReadWord(0xff8930) >> 5) & 0x3) {
338: case 0: strcpy(frqDSP, " (25 Mhz) "); break;
339: case 1: strcpy(frqDSP, "(External)"); break;
340: case 2: strcpy(frqDSP, " (32 Mhz) "); break;
341: default: strcpy(frqDSP, "undefined "); break;break;
342: }
343: }
344:
345: /* DMA Frequency */
346: if ((IoMem_ReadByte(0xff8935) & 0xf) == 0) {
347: strcpy(frqDMA, "(STe Freq)");
348: }else {
349: switch ((IoMem_ReadWord(0xff8930) >> 1) & 0x3) {
350: case 0: strcpy(frqDMA, " (25 Mhz) "); break;
351: case 1: strcpy(frqDMA, "(External)"); break;
352: case 2: strcpy(frqDMA, " (32 Mhz) "); break;
353: default: strcpy(frqDMA, "undefined "); break;break;
354: }
355: }
356:
357: /* External Frequency */
358: if ((IoMem_ReadByte(0xff8935) & 0xf) == 0) {
359: strcpy(frqEXT, "(STe Freq)");
360: }else {
361: switch ((IoMem_ReadWord(0xff8930) >> 9) & 0x3) {
362: case 0: strcpy(frqEXT, " (25 Mhz) "); break;
363: case 1: strcpy(frqEXT, "(External)"); break;
364: case 2: strcpy(frqEXT, " (32 Mhz) "); break;
365: default: strcpy(frqEXT, "undefined "); break;break;
366: }
367: }
368:
369: /* DAC Frequency */
370: if ((IoMem_ReadByte(0xff8935) & 0xf) == 0) {
371: strcpy(frqDAC, "(STe Freq)");
372: }else {
373: strcpy(frqDAC, " (25 Mhz) ");
374: }
375:
376: /* data size */
377: switch ((IoMem_ReadByte(0xff8921) >> 6) & 0x3) {
378: case 0: strcpy (dataSize, "8 bits stereo"); break;
379: case 1: strcpy (dataSize, "16 bits stereo"); break;
380: case 2: strcpy (dataSize, "8 bits mono"); break;
381: default: strcpy (dataSize, "undefined"); break;
382: }
383:
384: /* Display the crossbar Matrix */
385: fprintf(stderr, " INPUT\n");
386: fprintf(stderr, "External Imp ---%c------%c------%c------%c\n", matrixDAC[0], matrixDMA[0], matrixDSP[0], matrixEXT[0]);
387: fprintf(stderr, "%s | | | | O = no connexion\n", frqEXT);
388: fprintf(stderr, " | | | | X = connexion\n");
389: fprintf(stderr, "Dsp Transmit ---%c------%c------%c------%c H = Handshake connexion\n", matrixDAC[1], matrixDMA[1], matrixDSP[1], matrixEXT[1]);
390: fprintf(stderr, "%s | | | |\n", frqDSP);
391: fprintf(stderr, " | | | | %s\n", dataSize);
392: fprintf(stderr, "DMA PlayBack ---%c------%c------%c------%c\n", matrixDAC[2], matrixDMA[2], matrixDSP[2], matrixEXT[2]);
393: fprintf(stderr, "%s | | | |\n", frqDMA);
394: fprintf(stderr, " | | | |\n");
395: fprintf(stderr, "ADC ---%c------%c------%c------%c\n", matrixDAC[3], matrixDMA[3], matrixDSP[3], matrixEXT[3]);
396: fprintf(stderr, "%s | | | |\n", frqDAC);
397: fprintf(stderr, " DAC DMA DSP External OUTPUT\n");
398: fprintf(stderr, " Record Record Out\n");
399: fprintf(stderr, "\n");
400: }
401:
402:
403: /* ------------------------------------------------------------------
404: * CPU and DSP information wrappers
405: */
406:
407: /**
408: * Helper to call debugcpu.c and debugdsp.c debugger commands
409: */
410: static void DebugInfo_CallCommand(int (*func)(int, char* []), const char *command, Uint32 arg)
411: {
412: char cmdbuffer[16], argbuffer[12];
413: char *argv[] = { cmdbuffer, NULL };
414: int argc = 1;
415:
416: assert(strlen(command) < sizeof(cmdbuffer));
417: strcpy(cmdbuffer, command);
418: if (arg) {
419: sprintf(argbuffer, "$%x", arg);
420: argv[argc++] = argbuffer;
421: }
422: func(argc, argv);
423: }
424:
425: static void DebugInfo_CpuRegister(Uint32 arg)
426: {
427: DebugInfo_CallCommand(DebugCpu_Register, "register", arg);
428: }
429: static void DebugInfo_CpuDisAsm(Uint32 arg)
430: {
431: DebugInfo_CallCommand(DebugCpu_DisAsm, "disasm", arg);
432: }
433: static void DebugInfo_CpuMemDump(Uint32 arg)
434: {
435: DebugInfo_CallCommand(DebugCpu_MemDump, "memdump", arg);
436: }
437:
438: #if ENABLE_DSP_EMU
439:
440: static void DebugInfo_DspRegister(Uint32 arg)
441: {
442: DebugInfo_CallCommand(DebugDsp_Register, "dspreg", arg);
443: }
444: static void DebugInfo_DspDisAsm(Uint32 arg)
445: {
446: DebugInfo_CallCommand(DebugDsp_DisAsm, "dspdisasm", arg);
447: }
448:
449: static void DebugInfo_DspMemDump(Uint32 arg)
450: {
451: char cmdbuf[] = "dspmemdump";
452: char addrbuf[6], spacebuf[2] = "X";
453: char *argv[] = { cmdbuf, spacebuf, addrbuf };
454: spacebuf[0] = (arg>>16)&0xff;
455: sprintf(addrbuf, "$%x", (Uint16)(arg&0xffff));
456: DebugDsp_MemDump(3, argv);
457: }
458:
459: /**
460: * Convert arguments to Uint32 arg suitable for DSP memdump callback
461: */
462: static Uint32 DebugInfo_DspMemArgs(int argc, char *argv[])
463: {
464: Uint32 value;
465: char space;
466: if (argc != 2) {
467: return 0;
468: }
469: space = toupper(argv[0][0]);
470: if ((space != 'X' && space != 'Y' && space != 'P') || argv[0][1]) {
471: fprintf(stderr, "ERROR: invalid DSP address space '%s'!\n", argv[0]);
472: return 0;
473: }
474: if (!Eval_Number(argv[1], &value) || value > 0xffff) {
475: fprintf(stderr, "ERROR: invalid DSP address '%s'!\n", argv[1]);
476: return 0;
477: }
478: return ((Uint32)space<<16) | value;
479: }
480:
481: #endif /* ENABLE_DSP_EMU */
482:
483:
484: static void DebugInfo_RegAddr(Uint32 arg)
485: {
486: bool forDsp;
487: char regname[3];
488: Uint32 *regvalue, mask;
489: char cmdbuf[12], addrbuf[6];
490: char *argv[] = { cmdbuf, addrbuf };
491:
492: regname[0] = (arg>>24)&0xff;
493: regname[1] = (arg>>16)&0xff;
494: regname[2] = '\0';
495:
496: if (DebugCpu_GetRegisterAddress(regname, ®value)) {
497: mask = 0xffffffff;
498: forDsp = false;
499: } else {
500: if (!DSP_GetRegisterAddress(regname, ®value, &mask)) {
501: fprintf(stderr, "ERROR: invalid address/data register '%s'!\n", regname);
502: return;
503: }
504: forDsp = true;
505: }
506: sprintf(addrbuf, "$%x", *regvalue & mask);
507:
508: if ((arg & 0xff) == 'D') {
509: strcpy(cmdbuf, "disasm");
510: if (forDsp) {
511: #if ENABLE_DSP_EMU
512: DebugDsp_DisAsm(2, argv);
513: #endif
514: } else {
515: DebugCpu_DisAsm(2, argv);
516: }
517: } else {
518: strcpy(cmdbuf, "memdump");
519: if (forDsp) {
520: #if ENABLE_DSP_EMU
521: DebugDsp_MemDump(2, argv);
522: #endif
523: } else {
524: DebugCpu_MemDump(2, argv);
525: }
526: }
527: }
528:
529: /**
530: * Convert arguments to Uint32 arg suitable for RegAddr callback
531: */
532: static Uint32 DebugInfo_RegAddrArgs(int argc, char *argv[])
533: {
534: Uint32 value, *regaddr;
535: if (argc != 2) {
536: return 0;
537: }
538:
539: if (strcmp(argv[0], "disasm") == 0) {
540: value = 'D';
541: } else if (strcmp(argv[0], "memdump") == 0) {
542: value = 'M';
543: } else {
544: fprintf(stderr, "ERROR: regaddr operation can be only 'disasm' or 'memdump', not '%s'!\n", argv[0]);
545: return 0;
546: }
547:
548: if (strlen(argv[1]) != 2 ||
549: (!DebugCpu_GetRegisterAddress(argv[1], ®addr) &&
550: (toupper(argv[1][0]) != 'R' || !isdigit(argv[1][1]) || argv[1][2]))) {
551: /* not CPU register or Rx DSP register */
552: fprintf(stderr, "ERROR: invalid address/data register '%s'!\n", argv[1]);
553: return 0;
554: }
555:
556: value |= argv[1][0] << 24;
557: value |= argv[1][1] << 16;
558: value &= 0xffff00ff;
559: return value;
560: }
561:
562:
563: /* ------------------------------------------------------------------
564: * Debugger & readline TAB completion integration
565: */
566:
567: /**
568: * Default information on entering the debugger
569: */
570: static void DebugInfo_Default(Uint32 dummy)
571: {
572: int hbl, fcycles, lcycles;
573: Video_GetPosition(&fcycles, &hbl, &lcycles);
574: fprintf(stderr, "\nCPU=$%x, VBL=%d, FrameCycles=%d, HBL=%d, LineCycles=%d, DSP=",
575: M68000_GetPC(), nVBLs, fcycles, hbl, lcycles);
576: if (bDspEnabled)
577: fprintf(stderr, "$%x\n", DSP_GetPC());
578: else
579: fprintf(stderr, "N/A\n");
580: }
581:
582: static const struct {
583: /* whether callback is used only for locking */
584: bool lock;
585: const char *name;
586: void (*func)(Uint32 arg);
587: /* convert args in argv into single Uint32 for func */
588: Uint32 (*args)(int argc, char *argv[]);
589: const char *info;
590: } infotable[] = {
591: { false,"basepage", DebugInfo_Basepage, NULL, "Show program basepage info at given <address>" },
592: { false,"crossbar", DebugInfo_Crossbar, NULL, "Show Falcon crossbar HW register values" },
593: { true, "default", DebugInfo_Default, NULL, "Show default debugger entry information" },
594: { true, "disasm", DebugInfo_CpuDisAsm, NULL, "Disasm CPU from PC or given <address>" },
595: #if ENABLE_DSP_EMU
596: { true, "dspdisasm", DebugInfo_DspDisAsm, NULL, "Disasm DSP from given <address>" },
597: { true, "dspmemdump",DebugInfo_DspMemDump, DebugInfo_DspMemArgs, "Dump DSP memory from given <space> <address>" },
598: { true, "dspregs", DebugInfo_DspRegister,NULL, "Show DSP register values" },
599: #endif
600: { true, "memdump", DebugInfo_CpuMemDump, NULL, "Dump CPU memory from given <address>" },
601: { false,"osheader", DebugInfo_OSHeader, NULL, "Show TOS OS header information" },
602: { true, "regaddr", DebugInfo_RegAddr, DebugInfo_RegAddrArgs, "Show <disasm|memdump> from CPU/DSP address pointed by <register>" },
603: { true, "registers", DebugInfo_CpuRegister,NULL, "Show CPU register values" },
604: { false,"videl", DebugInfo_Videl, NULL, "Show Falcon Videl HW register values" }
605: };
606:
607: static int LockedFunction = 2; /* index for the "default" function */
608: static Uint32 LockedArgument;
609:
610: /**
611: * Show selected debugger session information
612: * (when debugger is (again) entered)
613: */
614: void DebugInfo_ShowSessionInfo(void)
615: {
616: infotable[LockedFunction].func(LockedArgument);
617: }
618:
619:
620: /**
621: * Readline match callback for info subcommand name completion.
622: * STATE = 0 -> different text from previous one.
623: * Return next match or NULL if no matches.
624: */
625: static char *DebugInfo_Match(const char *text, int state, bool lock)
626: {
627: static int i, len;
628: const char *name;
629:
630: if (!state) {
631: /* first match */
632: len = strlen(text);
633: i = 0;
634: }
635: /* next match */
636: while (i++ < ARRAYSIZE(infotable)) {
637: if (!lock && infotable[i-1].lock) {
638: continue;
639: }
640: name = infotable[i-1].name;
641: if (strncmp(name, text, len) == 0)
642: return (strdup(name));
643: }
644: return NULL;
645: }
646: char *DebugInfo_MatchLock(const char *text, int state)
647: {
648: return DebugInfo_Match(text, state, true);
649: }
650: char *DebugInfo_MatchInfo(const char *text, int state)
651: {
652: return DebugInfo_Match(text, state, false);
653: }
654:
655:
656: /**
657: * Show requested command information.
658: */
659: int DebugInfo_Command(int nArgc, char *psArgs[])
660: {
661: Uint32 value;
662: const char *cmd;
663: bool ok, lock;
664: int i, sub;
665:
666: sub = -1;
667: if (nArgc > 1) {
668: cmd = psArgs[1];
669: /* which subcommand? */
670: for (i = 0; i < ARRAYSIZE(infotable); i++) {
671: if (strcmp(cmd, infotable[i].name) == 0) {
672: sub = i;
673: break;
674: }
675: }
676: }
677:
678: if (infotable[sub].args) {
679: /* value needs callback specific conversion */
680: value = infotable[sub].args(nArgc-2, psArgs+2);
681: ok = !!value;
682: } else {
683: if (nArgc > 2) {
684: /* value is normal number */
685: ok = Eval_Number(psArgs[2], &value);
686: } else {
687: value = 0;
688: ok = true;
689: }
690: }
691:
692: lock = (strcmp(psArgs[0], "lock") == 0);
693:
694: if (sub < 0 || !ok) {
695: /* no subcommand or something wrong with value, show info */
696: fprintf(stderr, "%s subcommands are:\n", psArgs[0]);
697: for (i = 0; i < ARRAYSIZE(infotable); i++) {
698: if (!lock && infotable[i].lock) {
699: continue;
700: }
701: fprintf(stderr, "- %s: %s\n",
702: infotable[i].name, infotable[i].info);
703: }
704: return DEBUGGER_CMDDONE;
705: }
706:
707: if (lock) {
708: /* lock given subcommand and value */
709: LockedFunction = sub;
710: LockedArgument = value;
711: fprintf(stderr, "Locked %s output.\n", psArgs[1]);
712: } else {
713: /* do actual work */
714: infotable[sub].func(value);
715: }
716: return DEBUGGER_CMDDONE;
717: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.