/** * Dissassemble - arg = starting address, or PC. */ int DebugCpu_DisAsm(int nArgc, char *psArgs[]) { Uint32 disasm_upper = 0; int insts, max_insts; uaecptr nextpc; FILE* mydebugOutput=debugOutput; if (nArgc > 1) { switch (Eval_Range(psArgs[1], &disasm_addr, &disasm_upper, false)) { case -1: /* invalid value(s) */ return DEBUGGER_CMDDONE; case 0: /* single value */ break; case 1: /* range */ break; } if (nArgc > 2) { mydebugOutput=fopen(psArgs[2],"w"); if (mydebugOutput==NULL) { fprintf(debugOutput,"Cannot open %s abort\n",psArgs[2]); return DEBUGGER_CMDDONE; } } } else { /* continue */ if(!disasm_addr) disasm_addr = M68000_GetPC(); } /* limit is topmost address or instruction count */ if (disasm_upper) { max_insts = INT_MAX; } else { // max_insts = ConfigureParams.Debugger.nDisasmLines; max_insts = 5; disasm_upper = 0xFFFFFFFF; } /* output a range */ for (insts = 0; insts < max_insts && disasm_addr < disasm_upper; insts++) { DebugCpu_ShowAddressInfo(disasm_addr); Disasm(debugOutput, (uaecptr)disasm_addr, &nextpc, 1, DISASM_ENGINE_EXT); disasm_addr = nextpc; } fflush(mydebugOutput); if (mydebugOutput!=debugOutput) {fclose(mydebugOutput);} return DEBUGGER_CMDCONT; }
/** * Dissassemble - arg = starting address, or PC. */ int DebugCpu_DisAsm(int nArgc, char *psArgs[]) { Uint32 disasm_upper = 0; int insts, max_insts; uaecptr nextpc; if (nArgc > 1) { switch (Eval_Range(psArgs[1], &disasm_addr, &disasm_upper, false)) { case -1: /* invalid value(s) */ return DEBUGGER_CMDDONE; case 0: /* single value */ break; case 1: /* range */ break; } } else { /* continue */ if(!disasm_addr) disasm_addr = M68000_GetPC(); } /* limit is topmost address or instruction count */ if (disasm_upper) { max_insts = INT_MAX; } else { disasm_upper = 0xFFFFFFFF; max_insts = ConfigureParams.Debugger.nDisasmLines; } /* output a range */ for (insts = 0; insts < max_insts && disasm_addr < disasm_upper; insts++) { DebugCpu_ShowAddressInfo(disasm_addr); Disasm(debugOutput, (uaecptr)disasm_addr, &nextpc, 1); disasm_addr = nextpc; } fflush(debugOutput); return DEBUGGER_CMDCONT; }
/** * Do a memory dump, args = starting address. */ int DebugCpu_MemDump(int nArgc, char *psArgs[]) { int i; char c; Uint32 memdump_upper = 0; if (nArgc > 1) { switch (Eval_Range(psArgs[1], &memdump_addr, &memdump_upper, false)) { case -1: /* invalid value(s) */ return DEBUGGER_CMDDONE; case 0: /* single value */ break; case 1: /* range */ break; } } /* continue */ if (!memdump_upper) { memdump_upper = memdump_addr + MEMDUMP_COLS * ConfigureParams.Debugger.nMemdumpLines; } while (memdump_addr < memdump_upper) { fprintf(debugOutput, "%8.8X: ", memdump_addr); /* print address */ for (i = 0; i < MEMDUMP_COLS; i++) /* print hex data */ fprintf(debugOutput, "%2.2x ", STMemory_ReadByte(memdump_addr++)); fprintf(debugOutput, " "); /* print ASCII data */ for (i = 0; i < MEMDUMP_COLS; i++) { c = STMemory_ReadByte(memdump_addr-MEMDUMP_COLS+i); if(!isprint((unsigned)c)) c = NON_PRINT_CHAR; /* non-printable as dots */ fprintf(debugOutput,"%c", c); } fprintf(debugOutput, "\n"); /* newline */ } /* while */ fflush(debugOutput); return DEBUGGER_CMDCONT; }
/** * Do a DSP memory dump, args = starting address or range. * <x|y|p> <address>: dump from X, Y or P, starting from given address, * e.g. "x 200" or "p 200-300" */ int DebugDsp_MemDump(int nArgc, char *psArgs[]) { Uint32 lower, upper; Uint16 dsp_memdump_upper = 0; char space; if (!bDspEnabled) { fprintf(stderr, "DSP isn't present or initialized.\n"); return DEBUGGER_CMDDONE; } if (nArgc != 1 && nArgc != 3) { DebugUI_PrintCmdHelp(psArgs[0]); return DEBUGGER_CMDDONE; } if (nArgc == 3) { space = toupper(psArgs[1][0]); switch (space) { case 'X': case 'Y': case 'P': break; default: fprintf(stderr,"Invalid DSP address space '%c'!\n", space); return DEBUGGER_CMDDONE; } switch (Eval_Range(psArgs[2], &lower, &upper, true)) { case -1: /* invalid value(s) */ return DEBUGGER_CMDDONE; case 0: /* single value */ break; case 1: /* range */ if (upper > 0xFFFF) { fprintf(stderr,"Invalid address 0x%x!\n", upper); return DEBUGGER_CMDDONE; } dsp_memdump_upper = upper; break; } if (lower > 0xFFFF) { fprintf(stderr,"Invalid address 0x%x!\n", lower); return DEBUGGER_CMDDONE; } dsp_memdump_addr = lower; dsp_mem_space = space; } /* continue */ if (!dsp_memdump_upper) { int lines = ConfigureParams.Debugger.nMemdumpLines; if ( dsp_memdump_addr < (0xFFFF - lines)) dsp_memdump_upper = dsp_memdump_addr + lines; else dsp_memdump_upper = 0xFFFF; } printf("DSP memdump from 0x%hx in '%c' address space:\n", dsp_memdump_addr, dsp_mem_space); dsp_memdump_addr = DSP_DisasmMemory(dsp_memdump_addr, dsp_memdump_upper, dsp_mem_space); return DEBUGGER_CMDCONT; }
/** * DSP dissassemble - arg = starting address/range, or PC. */ int DebugDsp_DisAsm(int nArgc, char *psArgs[]) { Uint32 lower, upper; Uint16 dsp_disasm_upper = 0; if (!bDspEnabled) { fprintf(stderr, "DSP isn't present or initialized.\n"); return DEBUGGER_CMDDONE; } if (nArgc > 1) { switch (Eval_Range(psArgs[1], &lower, &upper, true)) { case -1: /* invalid value(s) */ return DEBUGGER_CMDDONE; case 0: /* single value */ break; case 1: /* range */ if (upper > 0xFFFF) { fprintf(stderr,"Invalid address 0x%x!\n", upper); return DEBUGGER_CMDDONE; } dsp_disasm_upper = upper; break; } if (lower > 0xFFFF) { fprintf(stderr,"Invalid address 0x%x!\n", lower); return DEBUGGER_CMDDONE; } dsp_disasm_addr = lower; } else { /* continue */ if(!dsp_disasm_addr) { dsp_disasm_addr = DSP_GetPC(); } } if (!dsp_disasm_upper) { int lines = ConfigureParams.Debugger.nDisasmLines; if ( dsp_disasm_addr < (0xFFFF - lines)) dsp_disasm_upper = dsp_disasm_addr + lines; else dsp_disasm_upper = 0xFFFF; } printf("DSP disasm 0x%hx-0x%hx:\n", dsp_disasm_addr, dsp_disasm_upper); while (dsp_disasm_addr < dsp_disasm_upper) { DebugDsp_ShowAddressInfo(dsp_disasm_addr); dsp_disasm_addr = DSP_DisasmAddress(dsp_disasm_addr, dsp_disasm_addr); } return DEBUGGER_CMDCONT; }
/** * Command: CPU/DSP profiling enabling, exec stats, cycle and call stats. * Returns DEBUGGER_CMDDONE or DEBUGGER_CMDCONT. */ int Profile_Command(int nArgc, char *psArgs[], bool bForDsp) { static int show = 16; Uint32 *disasm_addr; bool *enabled; if (nArgc > 2) { show = atoi(psArgs[2]); } if (bForDsp) { Profile_DspGetPointers(&enabled, &disasm_addr); } else { Profile_CpuGetPointers(&enabled, &disasm_addr); } /* continue or explicit addresses command? */ if (nArgc < 2 || strcmp(psArgs[1], "addresses") == 0) { Uint32 lower, upper = 0; if (nArgc > 2) { if (Eval_Range(psArgs[2], &lower, &upper, false) < 0) { return DEBUGGER_CMDDONE; } } else { lower = *disasm_addr; } if (bForDsp) { *disasm_addr = Profile_DspShowAddresses(lower, upper, stdout); } else { *disasm_addr = Profile_CpuShowAddresses(lower, upper, stdout); } return DEBUGGER_CMDCONT; } else if (strcmp(psArgs[1], "on") == 0) { *enabled = true; fprintf(stderr, "Profiling enabled.\n"); } else if (strcmp(psArgs[1], "off") == 0) { *enabled = false; fprintf(stderr, "Profiling disabled.\n"); } else if (strcmp(psArgs[1], "stats") == 0) { if (bForDsp) { Profile_DspShowStats(); } else { Profile_CpuShowStats(); } } else if (strcmp(psArgs[1], "misses") == 0) { if (bForDsp) { fprintf(stderr, "Cache misses are recorded only for CPU, not DSP.\n"); } else { Profile_CpuShowMisses(show); } } else if (strcmp(psArgs[1], "cycles") == 0) { if (bForDsp) { Profile_DspShowCycles(show); } else { Profile_CpuShowCycles(show); } } else if (strcmp(psArgs[1], "counts") == 0) { if (bForDsp) { Profile_DspShowCounts(show, false); } else { Profile_CpuShowCounts(show, false); } } else if (strcmp(psArgs[1], "symbols") == 0) { if (bForDsp) { Profile_DspShowCounts(show, true); } else { Profile_CpuShowCounts(show, true); } } else if (strcmp(psArgs[1], "callers") == 0) { if (bForDsp) { Profile_DspShowCallers(stdout); } else { Profile_CpuShowCallers(stdout); } } else if (strcmp(psArgs[1], "stack") == 0) { Profile_ShowStack(bForDsp); } else if (strcmp(psArgs[1], "save") == 0) { Profile_Save(psArgs[2], bForDsp); } else if (strcmp(psArgs[1], "loops") == 0) { Profile_Loops(nArgc, psArgs); } else { DebugUI_PrintCmdHelp(psArgs[0]); } return DEBUGGER_CMDDONE; }