/**
* 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;
}
