sylar/DragonVM
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
DragonVM/src/debugger/Debugger.cpp

1657 lines
No EOL
65 KiB
C++
Raw Blame History

#include "Debugger.hpp"
#include "../runtime/DragonRuntime.hpp"
#include "DisassemblyLoader.hpp"
#include <ostd/Defines.hpp>
#include <ostd/Console.hpp>
namespace dragon
{
//Close Event Listener
Debugger::tCloseEventListener Debugger::closeEventListener;
void Debugger::tCloseEventListener::init(void)
{
validate();
enableSignals();
connectSignal(ostd::tBuiltinSignals::WindowClosed);
}
void Debugger::tCloseEventListener::handleSignal(ostd::tSignal& signal)
{
m_mainWindowClosed = signal.ID == ostd::tBuiltinSignals::WindowClosed;
}
//Debugger::Utils
DisassemblyList Debugger::Utils::findCodeRegion(const DisassemblyList& code, uint16_t address, uint16_t codeRegionMargin)
{
if (code.size() <= (codeRegionMargin * 2) + 1) return code;
std::vector<dragon::code::Assembler::tDisassemblyLine> codeRegion;
uint16_t start = 0;
uint16_t end = (codeRegionMargin * 2);
for (int32_t i = 0; i < code.size(); i++)
{
if (code[i].addr != address) continue;
if (i + 1 <= codeRegionMargin) break;
if (code.size() - (i + 1) < codeRegionMargin)
{
end = code.size() - 1;
start = end - ((codeRegionMargin * 2) + 1);
break;
}
start = i - codeRegionMargin;
end = i + codeRegionMargin;
break;
}
for (int16_t i = start; i <= end; i++)
codeRegion.push_back(code[i]);
return codeRegion;
}
ostd::String Debugger::Utils::findSymbol(const DisassemblyList& list, uint16_t address, uint16_t* outSize)
{
for (auto& line : list)
{
if (line.addr == address)
{
if (outSize != nullptr)
*outSize = line.size;
return line.code;
}
}
return "";
}
uint16_t Debugger::Utils::findSymbol(const DisassemblyList& list, const ostd::String& symbol, uint16_t* outSize)
{
for (auto& line : list)
{
if (line.code == symbol)
{
if (outSize != nullptr)
*outSize = line.size;
return line.addr;
}
}
return 0x0000;
}
bool Debugger::Utils::isValidLabelNameChar(char c)
{
return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c == '_');
}
void Debugger::Utils::clearConsoleLine(void)
{
for (int32_t i = 0; i < ostd::Utils::getConsoleWidth(); i++)
out.p("\b");
for (int32_t i = 0; i < ostd::Utils::getConsoleWidth(); i++)
out.p(" ");
for (int32_t i = 0; i < ostd::Utils::getConsoleWidth(); i++)
out.p("\b");
}
bool Debugger::Utils::isEscapeKeyPressed(bool blocking)
{
ostd::KeyboardController kbc;
kbc.disableCommandBuffer();
kbc.disableOutput();
if (blocking)
{
ostd::eKeys key = ostd::eKeys::NoKeyPressed;
while ((key = kbc.waitForKeyPress()) != ostd::eKeys::Escape)
{
ostd::Utils::sleep(120);
}
return true;
}
return kbc.getPressedKey() == ostd::eKeys::Escape;
}
ostd::ConsoleOutputHandler& Debugger::Utils::printFullLine(char c, const ostd::ConsoleColors::tConsoleColor& foreground)
{
int32_t cw = ostd::Utils::getConsoleWidth();
ostd::String str = ostd::Utils::duplicateChar(c, cw);
out.fg(foreground).p(str).reset().nl();
return out;
}
ostd::ConsoleOutputHandler& Debugger::Utils::printFullLine(char c, const ostd::ConsoleColors::tConsoleColor& foreground, const ostd::ConsoleColors::tConsoleColor& background)
{
int32_t cw = ostd::Utils::getConsoleWidth();
ostd::String str = ostd::Utils::duplicateChar(c, cw);
out.bg(background).fg(foreground).p(str).reset().nl();
return out;
}
//Debugger::Display
void Debugger::Display::colorizeInstructionBody(const ostd::String& instBody, bool currentLine, const DisassemblyList& labelList)
{
ostd::RegexRichString rgxrstr(instBody);
rgxrstr.fg("\\{|\\}|\\+|\\*|\\-|\\/|\\(|\\)|\\[|\\]", "Red"); //Operators
rgxrstr.fg("0x[0-9A-Fa-f]+|0b[0-1]+|(?<!\\w)[0-9]+(?!\\w)", "BrightYellow"); //Number Constants
rgxrstr.fg("(?<!\\w)(r[1-9]|r10|fl|pp|rv|fp|sp|ip|acc)(?!\\w)", "BrightGreen", true); //Registers
rgxrstr.fg("\\%low", "Magenta");
rgxrstr.col("\\$\\w+", "Cyan", "Black"); //Labels
ostd::String instEdit = rgxrstr.getRawString();
for (auto& label : labelList)
{
int32_t index = -1;
ostd::String labelEdit = label.code;
labelEdit.trim();
while ((index = instEdit.indexOf(labelEdit, index + 1)) != -1)
{
if (index + labelEdit.len() < instEdit.len() && Utils::isValidLabelNameChar(instEdit.at(index + labelEdit.len())))
continue;
ostd::String instStr = instEdit;
instStr.cpp_str_ref().replace(index, labelEdit.len(), labelEdit.cpp_str() + "[@@ style foreground:brightgray](" + ostd::Utils::getHexStr(label.addr, true, 2).cpp_str() + ")[@@/]");
instEdit = instStr;
}
}
rgxrstr.setRawString(instEdit);
out.p("\t").pStyled(rgxrstr);
if (currentLine)
out.p(" ").bg(ostd::ConsoleColors::Yellow).fg(ostd::ConsoleColors::Black).p(" <-- ");
out.nl();
out.reset().reset();
}
void Debugger::Display::colorCodeInstructions(const ostd::String& inst, bool currentLine, const DisassemblyList& labelList)
{
ostd::String instEditor = inst;
ostd::String instBody = "";
ostd::String instHead = inst;
instEditor.trim();
if (instEditor.contains(" "))
{
instHead = instEditor.new_substr(0, instEditor.indexOf(" "));
instBody = instEditor.new_substr(instEditor.indexOf(" "));
}
if (currentLine)
{
out.bg(ostd::ConsoleColors::Yellow).fg(ostd::ConsoleColors::Black);
}
else if (instHead == "call" || instHead == "ret" || instHead == "int" || instHead == "rti")
out.bg(ostd::ConsoleColors::BrightRed).fg(ostd::ConsoleColors::White);
else if (instHead == "hlt" || instHead == "debug_break")
out.fg(ostd::ConsoleColors::Red);
else if (instHead == "nop")
out.fg(ostd::ConsoleColors::Gray);
else if(instHead.isNumeric())
out.fg(ostd::ConsoleColors::Magenta);
else
out.fg(ostd::ConsoleColors::Blue);
out.p(instHead.cpp_str());
out.reset().reset();
colorizeInstructionBody(instBody, currentLine, labelList);
}
void Debugger::Display::printPrompt(void)
{
out.fg(ostd::ConsoleColors::Magenta).p(" (ddb) #/> ").fg(ostd::ConsoleColors::White).flush();
}
void Debugger::Display::printStep(void)
{
out.clear();
int32_t codeRegionSpan = 15;
auto codeRegion = Utils::findCodeRegion(debugger.code, debugger.currentAddress, codeRegionSpan);
for (int32_t i = 0; i < codeRegion.size(); i++)
{
auto& _da = codeRegion[i];
bool currentLine = _da.addr == debugger.currentAddress;
ostd::String label = Utils::findSymbol(debugger.labels, _da.addr);
bool specialSection = _da.code.startsWith("[") &&_da.code.endsWith("]");
label.fixedLength(debugger.labelLineLength);
out.fg(ostd::ConsoleColors::Gray).p(label.cpp_str()).p(" ");
if (currentLine)
{
out.fg(ostd::ConsoleColors::Black).bg(ostd::ConsoleColors::Yellow).p(ostd::Utils::getHexStr(_da.addr, true, 2).cpp_str()).p(" ").reset();;
}
else
{
if (specialSection)
out.fg(ostd::ConsoleColors::Cyan);
else if (_da.code == "debug_break")
out.fg(ostd::ConsoleColors::Red);
else
out.fg(ostd::ConsoleColors::BrightGray);
out.p(ostd::Utils::getHexStr(_da.addr, true, 2).cpp_str()).p(" ");
}
if (specialSection)
out.fg(ostd::ConsoleColors::Cyan).p(_da.code.cpp_str()).nl();
colorCodeInstructions(_da.code, currentLine, debugger.labels);
out.reset();
}
Utils::printFullLine('#', ostd::ConsoleColors::Black, ostd::ConsoleColors::Yellow);
}
void Debugger::Display::printDiff(void)
{
out.clear();
ostd::String str;
str.add("|===============|================PREV================|================CURR================|=====|===PREV====|===CURR====|");
str.add("\n");
str.add("| InstAddr: |*%PREV_INST_ADDR%*******************|*%CURR_INST_ADDR%*******************| R1 |*%PREV_R1%*|*%CURR_R1%*|");
str.add("\n");
str.add("|---------------|------------------------------------|------------------------------------|-----|-----------|-----------|");
str.add("\n");
str.add("| Code: | ----- |*%CURR_CODE%************************| R2 |*%PREV_R2%*|*%CURR_R2%*|");
str.add("\n");
str.add("|---------------|------------------------------------|------------------------------------|-----|-----------|-----------|");
str.add("\n");
str.add("| StackFrame: |*%PREV_STACK_FRAME%*****************|*%CURR_STACK_FRAME%*****************| R3 |*%PREV_R3%*|*%CURR_R3%*|");
str.add("\n");
str.add("|---------------|------------------------------------|------------------------------------|-----|-----------|-----------|");
str.add("\n");
str.add("| DBG BRK: |*%PREV_DBG_BRK%*********************|*%CURR_DBG_BRK%*********************| R4 |*%PREV_R4%*|*%CURR_R4%*|");
str.add("\n");
str.add("|---------------|------------------------------------|------------------------------------|-----|-----------|-----------|");
str.add("\n");
str.add("| INT Handler: |*%PREV_INT_HANDLER%*****************|*%CURR_INT_HANDLER%*****************| R5 |*%PREV_R5%*|*%CURR_R5%*|");
str.add("\n");
str.add("|---------------|------------------------------------|------------------------------------|-----|-----------|-----------|");
str.add("\n");
str.add("| BIOS Mode: |*%PREV_BIOS_MODE%*******************|**%CURR_BIOS_MODE%******************| R6 |*%PREV_R6%*|*%CURR_R6%*|");
str.add("\n");
str.add("|---------------|------------------------------------|------------------------------------|-----|-----------|-----------|");
str.add("\n");
str.add("| SubRoutine: |*%PREV_SUB_ROUTINE%*****************|**%CURR_SUB_ROUTINE%****************| R7 |*%PREV_R7%*|*%CURR_R7%*|");
str.add("\n");
str.add("|---------------|------------------------------------|------------------------------------|-----|-----------|-----------|");
str.add("\n");
str.add("| IP: |*%PREV_IP%**************************|**%CURR_IP%*************************| R8 |*%PREV_R8%*|*%CURR_R8%*|");
str.add("\n");
str.add("|---------------|------------------------------------|------------------------------------|-----|-----------|-----------|");
str.add("\n");
str.add("| SP: |*%PREV_SP%**************************|**%CURR_SP%*************************| R9 |*%PREV_R9%*|*%CURR_R9%*|");
str.add("\n");
str.add("|---------------|------------------------------------|------------------------------------|-----|-----------|-----------|");
str.add("\n");
str.add("| FP: |*%PREV_FP%**************************|**%CURR_FP%*************************| R10 |*%PREV_R10%|*%CURR_R10%|");
str.add("\n");
str.add("|---------------|------------------------------------|------------------------------------|=====|===========|===========|");
str.add("\n");
str.add("| RV: |*%PREV_RV%**************************|**%CURR_RV%*************************| S1 |*%PREV_S1%*|*%CURR_S1*%|");
str.add("\n");
str.add("|---------------|------------------------------------|------------------------------------|-----|-----------|-----------|");
str.add("\n");
str.add("| PP: |*%PREV_PP%**************************|**%CURR_PP%*************************| S2 |*%PREV_S2%*|*%CURR_S2%*|");
str.add("\n");
str.add("|---------------|------------------------------------|------------------------------------|-----|-----------|-----------|");
str.add("\n");
str.add("| FL: |*%PREV_FL%**************************|**%CURR_FL%*************************| S3 |*%PREV_S3%*|*%CURR_S3%*|");
str.add("\n");
str.add("|---------------|------------------------------------|------------------------------------|=====|===========|===========|");
str.add("\n");
str.add("| ACC: |*%PREV_ACC%*************************|**%CURR_ACC%************************|");
str.add("\n");
str.add("|===============|====================================|====================================|");
str.replaceAll("*", "");
int32_t item_len = 36;
const dragon::DragonRuntime::tMachineDebugInfo& minfo = dragon::DragonRuntime::getMachineInfoDiff();
ostd::String tmp = " ", tmpStyle = "";
//Instruction Address
{
tmp.add(ostd::Utils::getHexStr(minfo.previousInstructionAddress, true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%PREV_INST_ADDR%", tmpStyle);
tmp = " ";
tmp.add(ostd::Utils::getHexStr(minfo.currentInstructionAddress, true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
if (minfo.currentInstructionAddress != minfo.previousInstructionAddress)
tmpStyle = "[@@style foreground:Black,background:BrightRed]";
else
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%CURR_INST_ADDR%", tmpStyle);
}
//Code
{
tmp = " ", tmpStyle = "";
ostd::String prevCode = " (";
prevCode.add(minfo.previousInstructionOpCode).add(") ");
for (int32_t i = 0; i < minfo.previousInstructionFootprintSize; i++)
prevCode.add(ostd::Utils::getHexStr(minfo.previousInstructionFootprint[i], false, 1)).add(" ");
tmp.add(prevCode);
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%CURR_CODE%", tmpStyle);
// tmp = " ";
// ostd::String currCode = " (";
// currCode.add(minfo.currentInstructionOpCode).add(") ");
// for (int32_t i = 0; i < minfo.currentInstructionFootprintSize; i++)
// currCode.add(ostd::Utils::getHexStr(minfo.currentInstructionFootprint[i], false, 1)).add(" ");
// tmp.add(currCode);
// tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
// // if (currCode != prevCode)
// // tmpStyle = "[@@style foreground:Black,background:BrightRed]";
// // else
// tmpStyle = "[@@style foreground:Blue]";
// tmpStyle.add(tmp).add("[@@/]");
// str.replaceAll("%CURR_CODE%", tmpStyle);
}
//Stack Frame
{
tmp = " ", tmpStyle = "";
tmp.add(ostd::Utils::getHexStr(minfo.previousInstructionStackFrameSize, true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%PREV_STACK_FRAME%", tmpStyle);
tmp = " ";
tmp.add(ostd::Utils::getHexStr(minfo.currentInstructionStackFrameSize, true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
if (minfo.currentInstructionStackFrameSize != minfo.previousInstructionStackFrameSize)
tmpStyle = "[@@style foreground:Black,background:BrightRed]";
else
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%CURR_STACK_FRAME%", tmpStyle);
}
//Debug Break
{
tmp = " ", tmpStyle = "";
tmp.add(STR_BOOL(minfo.previousInstructionDebugBreak));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%PREV_DBG_BRK%", tmpStyle);
tmp = " ";
tmp.add(STR_BOOL(minfo.currentInstructionDebugBreak));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
if (minfo.currentInstructionDebugBreak != minfo.previousInstructionDebugBreak)
tmpStyle = "[@@style foreground:Black,background:BrightRed]";
else
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%CURR_DBG_BRK%", tmpStyle);
}
//INT Handler
{
tmp = " ", tmpStyle = "";
tmp.add(minfo.previousInstructionInterruptHandlerCount);
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%PREV_INT_HANDLER%", tmpStyle);
tmp = " ";
tmp.add(minfo.currentInstructionInterruptHandlerCount);
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
if (minfo.currentInstructionInterruptHandlerCount != minfo.previousInstructionInterruptHandlerCount)
tmpStyle = "[@@style foreground:Black,background:BrightRed]";
else
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%CURR_INT_HANDLER%", tmpStyle);
}
//Bios Mode
{
tmp = " ", tmpStyle = "";
tmp.add(STR_BOOL(minfo.previousInstructionBiosMode));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%PREV_BIOS_MODE%", tmpStyle);
tmp = " ";
tmp.add(STR_BOOL(minfo.currentInstructionBiosMode));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
if (minfo.currentInstructionBiosMode != minfo.previousInstructionBiosMode)
tmpStyle = "[@@style foreground:Black,background:BrightRed]";
else
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%CURR_BIOS_MODE%", tmpStyle);
}
//SubRoutine Info
{
tmp = " ", tmpStyle = "";
tmp.add(minfo.previousSubRoutineCounter).add(" (");
tmp.add(STR_BOOL(minfo.previousIsInSubRoutine)).add(")");
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
ostd::String old_tmp = tmp;
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%PREV_SUB_ROUTINE%", tmpStyle);
tmp = " ";
tmp.add(minfo.currentSubRoutineCounter).add(" (");
tmp.add(STR_BOOL(minfo.currentIsInSubRoutine)).add(")");
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
if (old_tmp != tmp)
tmpStyle = "[@@style foreground:Black,background:BrightRed]";
else
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%CURR_SUB_ROUTINE%", tmpStyle);
}
//System Registers
{
tmp = " ", tmpStyle = "";
tmp.add(ostd::Utils::getHexStr(minfo.previousInstructionRegisters[dragon::data::Registers::IP], true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%PREV_IP%", tmpStyle);
tmp = " ";
tmp.add(ostd::Utils::getHexStr(minfo.currentInstructionRegisters[dragon::data::Registers::IP], true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
if (minfo.currentInstructionRegisters[dragon::data::Registers::IP] != minfo.previousInstructionRegisters[dragon::data::Registers::IP])
tmpStyle = "[@@style foreground:Black,background:BrightRed]";
else
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%CURR_IP%", tmpStyle);
tmp = " ", tmpStyle = "";
tmp.add(ostd::Utils::getHexStr(minfo.previousInstructionRegisters[dragon::data::Registers::SP], true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%PREV_SP%", tmpStyle);
tmp = " ";
tmp.add(ostd::Utils::getHexStr(minfo.currentInstructionRegisters[dragon::data::Registers::SP], true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
if (minfo.currentInstructionRegisters[dragon::data::Registers::SP] != minfo.previousInstructionRegisters[dragon::data::Registers::SP])
tmpStyle = "[@@style foreground:Black,background:BrightRed]";
else
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%CURR_SP%", tmpStyle);
tmp = " ", tmpStyle = "";
tmp.add(ostd::Utils::getHexStr(minfo.previousInstructionRegisters[dragon::data::Registers::FP], true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%PREV_FP%", tmpStyle);
tmp = " ";
tmp.add(ostd::Utils::getHexStr(minfo.currentInstructionRegisters[dragon::data::Registers::FP], true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
if (minfo.currentInstructionRegisters[dragon::data::Registers::FP] != minfo.previousInstructionRegisters[dragon::data::Registers::FP])
tmpStyle = "[@@style foreground:Black,background:BrightRed]";
else
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%CURR_FP%", tmpStyle);
tmp = " ", tmpStyle = "";
tmp.add(ostd::Utils::getHexStr(minfo.previousInstructionRegisters[dragon::data::Registers::RV], true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%PREV_RV%", tmpStyle);
tmp = " ";
tmp.add(ostd::Utils::getHexStr(minfo.currentInstructionRegisters[dragon::data::Registers::RV], true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
if (minfo.currentInstructionRegisters[dragon::data::Registers::RV] != minfo.previousInstructionRegisters[dragon::data::Registers::RV])
tmpStyle = "[@@style foreground:Black,background:BrightRed]";
else
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%CURR_RV%", tmpStyle);
tmp = " ", tmpStyle = "";
tmp.add(ostd::Utils::getHexStr(minfo.previousInstructionRegisters[dragon::data::Registers::PP], true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%PREV_PP%", tmpStyle);
tmp = " ";
tmp.add(ostd::Utils::getHexStr(minfo.currentInstructionRegisters[dragon::data::Registers::PP], true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
if (minfo.currentInstructionRegisters[dragon::data::Registers::PP] != minfo.previousInstructionRegisters[dragon::data::Registers::PP])
tmpStyle = "[@@style foreground:Black,background:BrightRed]";
else
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%CURR_PP%", tmpStyle);
tmp = " ", tmpStyle = "";
tmp.add(ostd::Utils::getHexStr(minfo.previousInstructionRegisters[dragon::data::Registers::FL], true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%PREV_FL%", tmpStyle);
tmp = " ";
tmp.add(ostd::Utils::getHexStr(minfo.currentInstructionRegisters[dragon::data::Registers::FL], true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
if (minfo.currentInstructionRegisters[dragon::data::Registers::FL] != minfo.previousInstructionRegisters[dragon::data::Registers::FL])
tmpStyle = "[@@style foreground:Black,background:BrightRed]";
else
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%CURR_FL%", tmpStyle);
tmp = " ", tmpStyle = "";
tmp.add(ostd::Utils::getHexStr(minfo.previousInstructionRegisters[dragon::data::Registers::ACC], true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%PREV_ACC%", tmpStyle);
tmp = " ";
tmp.add(ostd::Utils::getHexStr(minfo.currentInstructionRegisters[dragon::data::Registers::ACC], true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
if (minfo.currentInstructionRegisters[dragon::data::Registers::ACC] != minfo.previousInstructionRegisters[dragon::data::Registers::ACC])
tmpStyle = "[@@style foreground:Black,background:BrightRed]";
else
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%CURR_ACC%", tmpStyle);
}
item_len = 11;
//General Registers
{
tmp = " ", tmpStyle = "";
tmp.add(ostd::Utils::getHexStr(minfo.previousInstructionRegisters[dragon::data::Registers::R1], true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%PREV_R1%", tmpStyle);
tmp = " ";
tmp.add(ostd::Utils::getHexStr(minfo.currentInstructionRegisters[dragon::data::Registers::R1], true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
if (minfo.currentInstructionRegisters[dragon::data::Registers::R1] != minfo.previousInstructionRegisters[dragon::data::Registers::R1])
tmpStyle = "[@@style foreground:Black,background:BrightRed]";
else
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%CURR_R1%", tmpStyle);
tmp = " ", tmpStyle = "";
tmp.add(ostd::Utils::getHexStr(minfo.previousInstructionRegisters[dragon::data::Registers::R2], true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%PREV_R2%", tmpStyle);
tmp = " ";
tmp.add(ostd::Utils::getHexStr(minfo.currentInstructionRegisters[dragon::data::Registers::R2], true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
if (minfo.currentInstructionRegisters[dragon::data::Registers::R2] != minfo.previousInstructionRegisters[dragon::data::Registers::R2])
tmpStyle = "[@@style foreground:Black,background:BrightRed]";
else
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%CURR_R2%", tmpStyle);
tmp = " ", tmpStyle = "";
tmp.add(ostd::Utils::getHexStr(minfo.previousInstructionRegisters[dragon::data::Registers::R3], true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%PREV_R3%", tmpStyle);
tmp = " ";
tmp.add(ostd::Utils::getHexStr(minfo.currentInstructionRegisters[dragon::data::Registers::R3], true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
if (minfo.currentInstructionRegisters[dragon::data::Registers::R3] != minfo.previousInstructionRegisters[dragon::data::Registers::R3])
tmpStyle = "[@@style foreground:Black,background:BrightRed]";
else
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%CURR_R3%", tmpStyle);
tmp = " ", tmpStyle = "";
tmp.add(ostd::Utils::getHexStr(minfo.previousInstructionRegisters[dragon::data::Registers::R4], true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%PREV_R4%", tmpStyle);
tmp = " ";
tmp.add(ostd::Utils::getHexStr(minfo.currentInstructionRegisters[dragon::data::Registers::R4], true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
if (minfo.currentInstructionRegisters[dragon::data::Registers::R4] != minfo.previousInstructionRegisters[dragon::data::Registers::R4])
tmpStyle = "[@@style foreground:Black,background:BrightRed]";
else
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%CURR_R4%", tmpStyle);
tmp = " ", tmpStyle = "";
tmp.add(ostd::Utils::getHexStr(minfo.previousInstructionRegisters[dragon::data::Registers::R5], true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%PREV_R5%", tmpStyle);
tmp = " ";
tmp.add(ostd::Utils::getHexStr(minfo.currentInstructionRegisters[dragon::data::Registers::R5], true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
if (minfo.currentInstructionRegisters[dragon::data::Registers::R5] != minfo.previousInstructionRegisters[dragon::data::Registers::R5])
tmpStyle = "[@@style foreground:Black,background:BrightRed]";
else
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%CURR_R5%", tmpStyle);
tmp = " ", tmpStyle = "";
tmp.add(ostd::Utils::getHexStr(minfo.previousInstructionRegisters[dragon::data::Registers::R6], true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%PREV_R6%", tmpStyle);
tmp = " ";
tmp.add(ostd::Utils::getHexStr(minfo.currentInstructionRegisters[dragon::data::Registers::R6], true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
if (minfo.currentInstructionRegisters[dragon::data::Registers::R6] != minfo.previousInstructionRegisters[dragon::data::Registers::R6])
tmpStyle = "[@@style foreground:Black,background:BrightRed]";
else
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%CURR_R6%", tmpStyle);
tmp = " ", tmpStyle = "";
tmp.add(ostd::Utils::getHexStr(minfo.previousInstructionRegisters[dragon::data::Registers::R7], true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%PREV_R7%", tmpStyle);
tmp = " ";
tmp.add(ostd::Utils::getHexStr(minfo.currentInstructionRegisters[dragon::data::Registers::R7], true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
if (minfo.currentInstructionRegisters[dragon::data::Registers::R7] != minfo.previousInstructionRegisters[dragon::data::Registers::R7])
tmpStyle = "[@@style foreground:Black,background:BrightRed]";
else
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%CURR_R7%", tmpStyle);
tmp = " ", tmpStyle = "";
tmp.add(ostd::Utils::getHexStr(minfo.previousInstructionRegisters[dragon::data::Registers::R8], true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%PREV_R8%", tmpStyle);
tmp = " ";
tmp.add(ostd::Utils::getHexStr(minfo.currentInstructionRegisters[dragon::data::Registers::R8], true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
if (minfo.currentInstructionRegisters[dragon::data::Registers::R8] != minfo.previousInstructionRegisters[dragon::data::Registers::R8])
tmpStyle = "[@@style foreground:Black,background:BrightRed]";
else
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%CURR_R8%", tmpStyle);
tmp = " ", tmpStyle = "";
tmp.add(ostd::Utils::getHexStr(minfo.previousInstructionRegisters[dragon::data::Registers::R9], true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%PREV_R9%", tmpStyle);
tmp = " ";
tmp.add(ostd::Utils::getHexStr(minfo.currentInstructionRegisters[dragon::data::Registers::R9], true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
if (minfo.currentInstructionRegisters[dragon::data::Registers::R9] != minfo.previousInstructionRegisters[dragon::data::Registers::R9])
tmpStyle = "[@@style foreground:Black,background:BrightRed]";
else
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%CURR_R9%", tmpStyle);
tmp = " ", tmpStyle = "";
tmp.add(ostd::Utils::getHexStr(minfo.previousInstructionRegisters[dragon::data::Registers::R10], true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%PREV_R10%", tmpStyle);
tmp = " ";
tmp.add(ostd::Utils::getHexStr(minfo.currentInstructionRegisters[dragon::data::Registers::R10], true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
if (minfo.currentInstructionRegisters[dragon::data::Registers::R10] != minfo.previousInstructionRegisters[dragon::data::Registers::R10])
tmpStyle = "[@@style foreground:Black,background:BrightRed]";
else
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%CURR_R10%", tmpStyle);
}
//Special Registers
{
tmp = " ", tmpStyle = "";
tmp.add(ostd::Utils::getHexStr(minfo.previousInstructionRegisters[dragon::data::Registers::S1], true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%PREV_S1%", tmpStyle);
tmp = " ";
tmp.add(ostd::Utils::getHexStr(minfo.currentInstructionRegisters[dragon::data::Registers::S1], true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
if (minfo.currentInstructionRegisters[dragon::data::Registers::S1] != minfo.previousInstructionRegisters[dragon::data::Registers::S1])
tmpStyle = "[@@style foreground:Black,background:BrightRed]";
else
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%CURR_S1%", tmpStyle);
tmp = " ", tmpStyle = "";
tmp.add(ostd::Utils::getHexStr(minfo.previousInstructionRegisters[dragon::data::Registers::S2], true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%PREV_S2%", tmpStyle);
tmp = " ";
tmp.add(ostd::Utils::getHexStr(minfo.currentInstructionRegisters[dragon::data::Registers::S2], true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
if (minfo.currentInstructionRegisters[dragon::data::Registers::S2] != minfo.previousInstructionRegisters[dragon::data::Registers::S2])
tmpStyle = "[@@style foreground:Black,background:BrightRed]";
else
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%CURR_S2%", tmpStyle);
tmp = " ", tmpStyle = "";
tmp.add(ostd::Utils::getHexStr(minfo.previousInstructionRegisters[dragon::data::Registers::S3], true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%PREV_S3%", tmpStyle);
tmp = " ";
tmp.add(ostd::Utils::getHexStr(minfo.currentInstructionRegisters[dragon::data::Registers::S3], true, 2));
tmp.addPadding(item_len, ' ', ostd::String::ePaddingBehavior::AllowOddExtraLeft);
if (minfo.currentInstructionRegisters[dragon::data::Registers::S3] != minfo.previousInstructionRegisters[dragon::data::Registers::S3])
tmpStyle = "[@@style foreground:Black,background:BrightRed]";
else
tmpStyle = "[@@style foreground:Blue]";
tmpStyle.add(tmp).add("[@@/]");
str.replaceAll("%CURR_S3%", tmpStyle);
}
ostd::RegexRichString rgxstr(str);
rgxstr.fg("InstAddr|Code|StackFrame|DBG BRK|INT Handler|BIOS Mode|SubRoutine", "Magenta");
rgxstr.fg("IP|SP|FP|RV|PP|FL|ACC", "Cyan");
rgxstr.fg("R10|R2|R3|R4|R5|R6|R7|R8|R9|R1", "BrightGreen");
rgxstr.fg("S1|S2|S3", "BrightRed");
rgxstr.fg("PREV", "Red");
rgxstr.fg("CURR", "Green");
out.pStyled(rgxstr);
out.nl().nl().fg(ostd::ConsoleColors::Yellow).p("Pres <Escape> to go back...").nl().reset();
Utils::isEscapeKeyPressed(true);
}
void Debugger::Display::printTrackedAddresses(void)
{
out.clear();
out.fg(ostd::ConsoleColors::Yellow).p("Tracked Data: ").reset().nl();
const int32_t symbol_len = 24;
const int32_t size_len = 8;
const int32_t addr_len = 10;
const int32_t map_len = 8;
const int32_t prev_len = 35;
const dragon::DragonRuntime::tMachineDebugInfo& minfo = dragon::DragonRuntime::getMachineInfoDiff();
if (minfo.trackedAddresses.size() == 0) return;
int32_t cw = ostd::Utils::getConsoleWidth();
ostd::String header = "|Symbol";
header.addRightPadding(symbol_len);
header.add("|Bytes");
header.addRightPadding(header.len() + size_len - 6);
header.add("|Addr");
header.addRightPadding(header.len() + addr_len - 5);
header.add("|Map");
header.addRightPadding(header.len() + map_len - 4);
header.add("|Previous");
header.addRightPadding(header.len() + prev_len - 9);
header.add("|Current");
header.fixedLength(cw - 1);
header.addChar('|');
ostd::String border = ostd::Utils::duplicateChar('=', cw);
out.fg(ostd::ConsoleColors::Blue).p(border).nl();
ostd::RegexRichString rgx(header);
rgx.fg("\\|", "blue");
rgx.fg("Symbol|Bytes|Addr|Map|Previous|Current", "yellow");
out.pStyled(rgx).reset().nl();
ostd::String h_sep = ostd::Utils::duplicateChar('=', cw);
h_sep.put(0, '|');
h_sep.put(symbol_len, '|');
h_sep.put(symbol_len + size_len, '|');
h_sep.put(symbol_len + size_len + addr_len, '|');
h_sep.put(symbol_len + size_len + addr_len + map_len, '|');
h_sep.put(symbol_len + size_len + addr_len + map_len + prev_len, '|');
h_sep.put(cw - 1, '|');
out.fg(ostd::ConsoleColors::Blue).p(h_sep).reset().nl();
for (int32_t i = 0; i < minfo.trackedAddresses.size(); i++)
{
uint16_t data_size = 1;
auto addr = minfo.trackedAddresses[i];
ostd::String symbol = Utils::findSymbol(debugger.data, addr, &data_size);
if (symbol == "")
symbol = Utils::findSymbol(debugger.labels, addr, &data_size);
bool no_symbol = false;
if (symbol == "")
{
symbol = "<no-symbol>";
no_symbol = true;
}
symbol.fixedLength(symbol_len - 1);
if (no_symbol)
out.fg(ostd::ConsoleColors::Blue).p("|").fg(ostd::ConsoleColors::Gray).p(symbol).reset();
else
out.fg(ostd::ConsoleColors::Blue).p("|").fg(ostd::ConsoleColors::Magenta).p(symbol).reset();
ostd::String tmp = "";
tmp.add(data_size);
tmp.fixedLength(size_len - 1);
if (no_symbol)
out.fg(ostd::ConsoleColors::Blue).p("|").fg(ostd::ConsoleColors::Cyan).p(tmp).reset();
else
out.fg(ostd::ConsoleColors::Blue).p("|").fg(ostd::ConsoleColors::BrightCyan).p(tmp).reset();
tmp = "";
tmp.add(ostd::Utils::getHexStr(addr, true, 2));
tmp.fixedLength(addr_len - 1);
if (no_symbol)
out.fg(ostd::ConsoleColors::Blue).p("|").fg(ostd::ConsoleColors::Gray).p(tmp).reset();
else
out.fg(ostd::ConsoleColors::Blue).p("|").fg(ostd::ConsoleColors::BrightGray).p(tmp).reset();
tmp = "";
if (addr >= (uint16_t)DragonRuntime::cpu.readRegister(data::Registers::SP))
tmp.add("STACK");
else
tmp.add(DragonRuntime::memMap.getMemoryRegionName(addr));
tmp.fixedLength(map_len - 1);
out.fg(ostd::ConsoleColors::Blue).p("|").fg(ostd::ConsoleColors::BrightYellow).p(tmp).reset();
tmp = "";
tmp.add(ostd::Utils::getHexStr(minfo.previousInstructionTrackedValues[i], false, 1));
for (int32_t j = 1; j < data_size; j++)
tmp.add(".").add(ostd::Utils::getHexStr(minfo.previousInstructionTrackedValues[i + j], false, 1));
tmp.fixedLength(prev_len - 1);
if (no_symbol)
out.fg(ostd::ConsoleColors::Blue).p("|").fg(ostd::ConsoleColors::Red).p(tmp).reset();
else
out.fg(ostd::ConsoleColors::Blue).p("|").fg(ostd::ConsoleColors::BrightRed).p(tmp).reset();
tmp = "";
tmp.add(ostd::Utils::getHexStr(minfo.currentInstructionTrackedValues[i], false, 1));
uint32_t tmp_i = i;
for (int32_t j = 1; j < data_size; j++, i++)
tmp.add(".").add(ostd::Utils::getHexStr(minfo.currentInstructionTrackedValues[i + 1], false, 1));
tmp.fixedLength(prev_len - 1);
bool data_different = false;
for (int32_t j = 0; j < data_size; j++)
{
if (minfo.currentInstructionTrackedValues[tmp_i + j] != minfo.previousInstructionTrackedValues[tmp_i + j])
{
data_different = true;
break;
}
}
if (no_symbol)
{
if (data_different)
out.fg(ostd::ConsoleColors::Blue).p("|").fg(ostd::ConsoleColors::BrightGray).p(tmp).reset();
else
out.fg(ostd::ConsoleColors::Blue).p("|").fg(ostd::ConsoleColors::Green).p(tmp).reset();
}
else
{
if (data_different)
out.fg(ostd::ConsoleColors::Blue).p("|").fg(ostd::ConsoleColors::White).p(tmp).reset();
else
out.fg(ostd::ConsoleColors::Blue).p("|").fg(ostd::ConsoleColors::BrightGreen).p(tmp).reset();
}
tmp = "|";
tmp.addLeftPadding(cw - symbol_len - size_len - addr_len - map_len - prev_len - prev_len);
out.fg(ostd::ConsoleColors::Blue).p(tmp).reset();
}
out.nl();
out.fg(ostd::ConsoleColors::Blue).p(border).reset().nl();
out.nl().nl().fg(ostd::ConsoleColors::Yellow).p("Pres <Escape> to go back...").nl().reset();
Utils::isEscapeKeyPressed(true);
}
void Debugger::Display::printStack(uint16_t nrows)
{
if (nrows == 0) nrows = 8;
uint16_t ncols = 16;
uint16_t startAddr = (0xFFFF - (ncols * nrows) + 1);
out.clear();
out.nl();
out.fg(ostd::ConsoleColors::Yellow).p("Stack frames: ").reset().nl();
Utils::printFullLine('=', ostd::ConsoleColors::BrightBlue);
for (auto& frame : dragon::DragonRuntime::cpu.m_debug_stackFrameStrings)
{
ostd::RegexRichString rgxrstr(frame);
rgxrstr.fg("0x[0-9A-Fa-f]+|0b[0-1]+|(?<!\\w)[0-9]+(?!\\w)", "Red"); //Number Constants
rgxrstr.fg("(?<!\\w)(r[1-9]|r10|fl|pp|rv|fp|sp|ip|acc)(?!\\w)", "BrightGreen", true); //Registers
rgxrstr.fg("(?<!\\w)(args|argc|StackFrame|New FP)(?!\\w)", "Magenta", true); //Other
out.pStyled(rgxrstr);
out.nl();
Utils::printFullLine('=', ostd::ConsoleColors::BrightBlue);
}
out.nl();
out.fg(ostd::ConsoleColors::Yellow).p("Stack view: ").reset().nl();
uint16_t stack_ptr = DragonRuntime::cpu.readRegister(data::Registers::SP);
ostd::Utils::printByteStream(*DragonRuntime::ram.getByteStream(), startAddr, ncols, nrows, out, stack_ptr, 2, "Stack");
out.nl().nl().fg(ostd::ConsoleColors::Yellow).p("Pres <Escape> to go back...").nl().reset();
Utils::isEscapeKeyPressed(true);
}
void Debugger::Display::printCallStack(void)
{
out.clear();
out.fg(ostd::ConsoleColors::Yellow).p("Subroutine/Interrupt call stack: ").reset().nl();
Utils::printFullLine('=', ostd::ConsoleColors::Yellow);
const dragon::DragonRuntime::tMachineDebugInfo& minfo = dragon::DragonRuntime::getMachineInfoDiff();
auto& callStack = minfo.callStack;
int32_t level = -1;
ostd::String ch_ang_u = "";
ch_ang_u.addChar((unsigned char)218);
ostd::String ch_ang_l = "|";
ostd::String ch_ang_d = "";
ch_ang_d.addChar((unsigned char)192);
for (auto& call : callStack)
{
ostd::String call_info = call.info.new_trim().toLower();
ostd::String subroutine_addr = ostd::Utils::getHexStr(call.addr, true, 2);
ostd::String subroutine_name = Utils::findSymbol(debugger.labels, call.addr);
ostd::String call_str = "";
bool dec_lvl = false;
if (call_info == "int")
{
call_str = ch_ang_u + "int " + ostd::Utils::getHexStr(call.addr, true, 1);
level++;
}
else if (call_info == "hw int")
{
call_str = ch_ang_u + "hwi " + ostd::Utils::getHexStr(call.addr, true, 1);
level++;
}
else if (call_info == "ret")
{
call_str = ch_ang_d + "ret";
dec_lvl = true;
}
else if (call_info == "ret int")
{
call_str = ch_ang_d + "rti";
dec_lvl = true;
}
else
{
if (call_info == "call reg")
subroutine_addr = "*" + subroutine_addr;
if (subroutine_name != "")
call_str = ch_ang_u + "call " + subroutine_name + " (" + subroutine_addr + ")";
else
call_str = ch_ang_u + "call " + subroutine_addr;
level++;
}
ostd::String line_str = "";
for (int32_t i = 0; i < level; i++)
line_str.add("| ");
line_str.add(call_str);
ostd::RegexRichString rgx(line_str);
rgx.fg("\\(|\\)|\\*", "Cyan"); //Operators
rgx.fg("(?<![a-zA-Z\\_\\$\\.])int|rti(?! [a-zA-Z\\_\\$\\.])", "Blue");
rgx.fg("(?<![a-zA-Z\\_\\$\\.])hwi(?! [a-zA-Z\\_\\$\\.])", "Magenta");
rgx.fg("(?<![a-zA-Z\\_\\$\\.])call|ret(?! [a-zA-Z\\_\\$\\.])", "Red");
rgx.fg("0x[0-9A-Fa-f]+|0b[0-1]+|(?<!\\w)[0-9]+(?!\\w)", "BrightYellow"); //Number Constants
rgx.fg(ostd::String("[\\").add(ch_ang_u).add("\\|\\").add(ch_ang_d).add("]"), "darkgray");
rgx.fg("\\$\\w+", "Green"); //Labels
out.fg(ostd::ConsoleColors::BrightGray).p("|").reset();
out.fg(ostd::ConsoleColors::Magenta).p(ostd::Utils::getHexStr(call.inst_addr, true, 2));
out.fg(ostd::ConsoleColors::BrightGray).p("| > ").reset();
out.pStyled(rgx).nl().reset();
if (dec_lvl)
level--;
}
Utils::printFullLine('=', ostd::ConsoleColors::Yellow);
out.nl().nl().fg(ostd::ConsoleColors::Yellow).p("Pres <Escape> to go back...").nl().reset();
Utils::isEscapeKeyPressed(true);
}
void Debugger::Display::printHelp(void)
{
out.clear();
int32_t commandLength = 34;
Utils::printFullLine('#', ostd::ConsoleColors::Black, ostd::ConsoleColors::Red);
out.nl().fg(ostd::ConsoleColors::Yellow).p("List of available commands:").reset().nl();
ostd::String tmpCommand = "(d)iff-view";
tmpCommand.addRightPadding(commandLength);
out.fg(ostd::ConsoleColors::Blue).p(tmpCommand).fg(ostd::ConsoleColors::Green).p("Used to show the state of the machine, comparing the current cycle with the last.").reset().nl();
tmpCommand = "(q)uit";
tmpCommand.addRightPadding(commandLength);
out.fg(ostd::ConsoleColors::Blue).p(tmpCommand).fg(ostd::ConsoleColors::Green).p("Used to close the program and exit the debugger. (<Escape> key can also be used.)").reset().nl();
tmpCommand = "(h)elp";
tmpCommand.addRightPadding(commandLength);
out.fg(ostd::ConsoleColors::Blue).p(tmpCommand).fg(ostd::ConsoleColors::Green).p("Used to show this dialog.").reset().nl();
tmpCommand = "(t)racker";
tmpCommand.addRightPadding(commandLength);
out.fg(ostd::ConsoleColors::Blue).p(tmpCommand).fg(ostd::ConsoleColors::Green).p("Used to show manually tracked values.").reset().nl();
tmpCommand = "(s)tack [rows=8]";
tmpCommand.addRightPadding(commandLength);
out.fg(ostd::ConsoleColors::Blue).p(tmpCommand).fg(ostd::ConsoleColors::Green).p("Used to show the stack and a description of every stack-frame saved.").reset().nl();
tmpCommand = "(ca)ll-stack";
tmpCommand.addRightPadding(commandLength);
out.fg(ostd::ConsoleColors::Blue).p(tmpCommand).fg(ostd::ConsoleColors::Green).p("Used to show information about all subroutine/interrupt calls.").reset().nl();
tmpCommand = "(c)ontinue";
tmpCommand.addRightPadding(commandLength);
out.fg(ostd::ConsoleColors::Blue).p(tmpCommand).fg(ostd::ConsoleColors::Green).p("Used exit step-execution mode and resume the normal execution of the program.").reset().nl();
tmpCommand = "(p)rint [word] <addr/symbol>";
tmpCommand.addRightPadding(commandLength);
out.fg(ostd::ConsoleColors::Blue).p(tmpCommand).fg(ostd::ConsoleColors::Green).p("Used to print values from memory. Valid [size] values are: byte/word/dword/qword.").reset().nl();
out.nl().fg(ostd::ConsoleColors::Cyan).p("The letters in parenthesis can be used as the short version of the command.").nl();
out.p("Square brackets represent optional parameters. If they have an '=' and a value, that is the default if not specified.").reset().nl();
out.nl();
Utils::printFullLine('#', ostd::ConsoleColors::Black, ostd::ConsoleColors::Red);
out.nl().nl().fg(ostd::ConsoleColors::Yellow).p("Pres <Escape> to go back...").nl().reset();
Utils::isEscapeKeyPressed(true);
}
ostd::String Debugger::Display::changeScreen(void)
{
if (debugger.command == "diff-view" || debugger.command == "d")
{
printDiff();
printStep();
printPrompt();
return getCommandInput();
}
else if (debugger.command == "tracker" || debugger.command == "t")
{
printTrackedAddresses();
printStep();
printPrompt();
return getCommandInput();
}
else if (debugger.command.startsWith("stack") || debugger.command.startsWith("s"))
{
uint16_t default_stack_rows = 8;
ostd::String params = debugger.command.new_trim();
if (params == "stack" || params == "s")
printStack(default_stack_rows);
else if (params.contains(" "))
{
params.substr(params.indexOf(" ") + 1).trim();
if (!params.isNumeric()) return "";
default_stack_rows = (uint16_t)params.toInt();
if (default_stack_rows > 0xFFFF / 16) default_stack_rows = 8;
printStack(default_stack_rows);
}
else return "";
printStep();
printPrompt();
return getCommandInput();
}
else if (debugger.command == "call-stack" || debugger.command == "ca")
{
printCallStack();
printStep();
printPrompt();
return getCommandInput();
}
else if (debugger.command == "help" || debugger.command == "h")
{
printHelp();
printStep();
printPrompt();
return getCommandInput();
}
return "";
}
//Debugger
void Debugger::processErrors(void)
{
if (!dragon::DragonRuntime::hasError()) return;
while (dragon::data::ErrorHandler::hasError())
{
auto err = dragon::data::ErrorHandler::popError();
out.nl().fg(ostd::ConsoleColors::Red).p("Error ").p(ostd::Utils::getHexStr(err.code, true, 8).cpp_str()).p(": ").p(err.text.cpp_str()).nl();
}
debugger.args.step_exec = true;
}
int32_t Debugger::loadArguments(int argc, char** argv)
{
if (argc < 2)
{
out.fg(ostd::ConsoleColors::Red).p("Error: too few arguments.").nl();
out.fg(ostd::ConsoleColors::Red).p("Use the --help option for more info.").reset().nl();
return DragonRuntime::RETURN_VAL_TOO_FEW_ARGUMENTS;
}
else
{
debugger.args.machine_config_path = argv[1];
if (debugger.args.machine_config_path == "--help")
{
print_application_help();
return DragonRuntime::RETURN_VAL_CLOSE_DEBUGGER;
}
for (int32_t i = 2; i < argc; i++)
{
ostd::String edit(argv[i]);
if (edit == "--verbose-load")
debugger.args.verbose_load = true;
else if (edit == "--step-exec")
debugger.args.step_exec = true;
else if (edit == "--track-step-diff-off")
debugger.args.track_step_diff = false;
else if (edit == "--auto-track-data-off")
debugger.args.auto_track_all_data_symbols = false;
else if (edit == "--hide-vdisplay")
debugger.args.hide_virtual_display = true;
else if (edit == "--auto-start")
debugger.args.auto_start_debug = true;
else if (edit == "--force-load")
{
if ((argc - 1) - i < 2)
return DragonRuntime::RETURN_VAL_MISSING_PARAM;
i++;
debugger.args.force_load_file = argv[i];
i++;
edit = argv[i];
if (!edit.isNumeric())
return DragonRuntime::RETURN_VAL_PARAMETER_NOT_NUMERIC;
debugger.args.force_load_mem_offset = (uint16_t)edit.toInt();
debugger.args.force_load = true;
}
else if (edit == "--help")
{
print_application_help();
return DragonRuntime::RETURN_VAL_CLOSE_DEBUGGER;
}
}
}
return DragonRuntime::RETURN_VAL_EXIT_SUCCESS;
}
int32_t Debugger::initRuntime(void)
{
int32_t init_state = dragon::DragonRuntime::initMachine(debugger.args.machine_config_path,
debugger.args.verbose_load,
debugger.args.track_step_diff,
debugger.args.hide_virtual_display,
debugger.args.track_call_stack,
true); //CPU Debug Mode Enabled
closeEventListener.init();
if (init_state != 0) return init_state; //TODO: Error
if (debugger.args.force_load)
dragon::DragonRuntime::forceLoad(debugger.args.force_load_file, debugger.args.force_load_mem_offset);
dragon::DisassemblyLoader::loadDirectory(debugger.disassemblyDirectory);
debugger.code = dragon::DisassemblyLoader::getCodeTable();
debugger.labels = dragon::DisassemblyLoader::getLabelTable();
debugger.data = dragon::DisassemblyLoader::getDataTable();
return DragonRuntime::RETURN_VAL_EXIT_SUCCESS;
}
ostd::String Debugger::getCommandInput(void)
{
ostd::String cmd;
ostd::KeyboardController kbc;
ostd::eKeys key = ostd::eKeys::NoKeyPressed;
while ((key = kbc.getPressedKey()) != ostd::eKeys::Enter)
{
if (key == ostd::eKeys::Escape)
return InputCommandQuit;
}
return kbc.getInputString();
// ostd::String cmd;
// std::getline(std::cin, cmd.cpp_str_ref());
// return cmd;
}
int32_t Debugger::topLevelPrompt(void)
{
if (!data().args.auto_start_debug)
{
bool exit_loop = false;
bool done_with_auto_data_track = false;
DragonRuntime::vDisplay.hide();
while (!exit_loop)
{
if (!done_with_auto_data_track)
{
data().command = "track ";
for (auto& sym : debugger.data)
data().command.add(sym.code).add(" ");
done_with_auto_data_track = true;
}
else
{
Display::printPrompt();
data().command = getCommandInput();
}
data().command.trim().toLower();
if (data().command == "r" || data().command == "run")
{
output().p("Starting program...").nl();
exit_loop = true;
}
else if (data().command == "q" || data().command == "quit" || data().command == InputCommandQuit)
{
output().nl().p("Exiting debugger...").nl();
return DragonRuntime::RETURN_VAL_CLOSE_DEBUGGER;
}
else if (data().command.startsWith("t ") || data().command.startsWith("track "))
{
data().command.substr(data().command.indexOf(" ") + 1).trim();
exec_watch_command();
}
else if (data().command == "h" || data().command == "help")
{
print_top_level_prompt_help();
}
else if (data().command == "s" || data().command == "step")
{
data().args.step_exec = !data().args.step_exec;
output().p("Step execution = ").p(STR_BOOL(data().args.step_exec)).nl();
}
else if (data().command == "display")
{
data().args.hide_virtual_display = !data().args.hide_virtual_display;
output().p("Virtual Display Hidden = ").p(STR_BOOL(data().args.hide_virtual_display)).nl();
}
}
}
if (!data().args.hide_virtual_display)
DragonRuntime::vDisplay.show();
data().currentAddress = DragonRuntime::cpu.readRegister(data::Registers::IP);
return DragonRuntime::RETURN_VAL_EXIT_SUCCESS;
}
int32_t Debugger::executeRuntime(void)
{
int32_t rValue = 0;
bool userQuit = false;
output().clear().fg(ostd::ConsoleColors::Green).p("Program running...").nl();
if (!data().args.step_exec)
output().fg(ostd::ConsoleColors::Yellow).p("Press <Escape> to enter in step-execution mode...").reset().nl();
while (!userQuit)
{
ostd::SignalHandler::refresh();
if (closeEventListener.hasHappened())
userQuit = true;
data().command.clr();
if (!userQuit && data().args.step_exec)
rValue = step_execution(userQuit, true);
else if (!userQuit)
rValue = normal_runtime(userQuit);
data().currentAddress = DragonRuntime::cpu.readRegister(data::Registers::IP);
}
output().nl().fg(ostd::ConsoleColors::Yellow).p("Execution terminated.").nl().nl().reset();
return rValue;
}
int32_t Debugger::step_execution(bool& outUserQuit, bool exec_first_step)
{
if (exec_first_step && !DragonRuntime::cpu.isHalted())
DragonRuntime::runStep(data().trackedAddresses);
Display::printStep();
processErrors();
if (DragonRuntime::cpu.isInDebugBreakPoint())
output().fg(ostd::ConsoleColors::Red).p("Reached Debug Break Point.").reset().nl();
Display::printPrompt();
data().command = getCommandInput();
data().command.trim().toLower();
while (data().command != "")
{
if (data().command == "q" || data().command == "quit" || data().command == InputCommandQuit)
{
output().nl();
outUserQuit = true;
data().command = "";
}
else if (data().command == "c" || data().command == "continue")
{
data().args.step_exec = false;
data().command = "";
output().clear().fg(ostd::ConsoleColors::Green).p("Program running...").nl();
output().fg(ostd::ConsoleColors::Yellow).p("Press <Escape> to enter in step-execution mode...").reset().nl();
}
else if (data().command.startsWith("p ") || data().command.startsWith("print "))
{
data().command.substr(data().command.indexOf(" ") + 1).trim();
const uint8_t TYPE_STRING = 0;
const uint8_t TYPE_BYTE = 1;
const uint8_t TYPE_WORD = 2;
const uint8_t TYPE_DWORD = 4;
const uint8_t TYPE_QWORD = 8;
uint8_t type = TYPE_WORD;
if (data().command.contains(" "))
{
ostd::String size_str = data().command.new_substr(0, data().command.indexOf(" ")).trim();
data().command.substr(data().command.indexOf(" ") + 1).trim();
if (size_str == "byte") type = TYPE_BYTE;
else if (size_str == "word") type = TYPE_WORD;
else if (size_str == "dword") type = TYPE_DWORD;
else if (size_str == "qword") type = TYPE_QWORD;
else if (size_str == "string") type = TYPE_STRING;
}
if (data().command.isNumeric())
{
if (type == TYPE_STRING)
type = TYPE_WORD;
uint16_t addr = data().command.toInt();
uint16_t end_addr = addr;
ostd::String tmp = "";
tmp.add("*(").add(ostd::Utils::getHexStr(addr, true, 2));
if (type != TYPE_BYTE)
{
end_addr = addr + type - 1;
if (end_addr < addr)
end_addr = addr;
else
tmp.add("-").add(ostd::Utils::getHexStr(end_addr, true, 2));
}
tmp.add(")");
ostd::RegexRichString rgx(tmp);
rgx.fg("\\(|\\)|-", "darkgray");
rgx.fg("\\*", "red");
rgx.fg("0x[0-9A-Fa-f]+|0b[0-1]+|(?<!\\w)[0-9]+(?!\\w)", "cyan"); //Number Constants
output().pStyled(rgx);
output().fg(ostd::ConsoleColors::White).p(" = ");
output().fg(ostd::ConsoleColors::Gray).p("[");
for (uint16_t a = addr; a <= end_addr; a++)
{
uint8_t value = DragonRuntime::memMap.read8(a);
output().fg(ostd::ConsoleColors::BrightRed).p(ostd::Utils::getHexStr(value, true, 1));
if (a < end_addr)
output().p(" ");
}
output().fg(ostd::ConsoleColors::Gray).p("]");
output().reset().nl();
}
else if (data().command.startsWith("$"))
{
uint16_t size = 0;
uint16_t addr = Utils::findSymbol(debugger.data, data().command, &size);
if (addr == 0)
addr = Utils::findSymbol(debugger.labels, data().command, &size);
if (addr == 0)
output().fg(ostd::ConsoleColors::Red).p("Unknown symbol for <print> command.").reset().nl();
else
{
ostd::String tmp = "";
tmp.add("*(").add(ostd::Utils::getHexStr(addr, true, 2));
if (size > 1)
tmp.add("-").add(ostd::Utils::getHexStr((uint16_t)(addr + size - 1), true, 2));
tmp.add(")");
ostd::RegexRichString rgx(tmp);
rgx.fg("\\(|\\)|-", "darkgray");
rgx.fg("\\*", "red");
rgx.fg("0x[0-9A-Fa-f]+|0b[0-1]+|(?<!\\w)[0-9]+(?!\\w)", "cyan"); //Number Constants
output().pStyled(rgx);
output().fg(ostd::ConsoleColors::White).p(" = ");
output().fg(ostd::ConsoleColors::Gray).p("[");
if (type == TYPE_STRING)
output().fg(ostd::ConsoleColors::BrightRed).p("\"");
for (uint16_t a = addr; a < addr + size; a++)
{
uint8_t value = DragonRuntime::memMap.read8(a);
if (type == TYPE_STRING)
{
output().fg(ostd::ConsoleColors::BrightRed).pChar((char)value);
continue;
}
output().fg(ostd::ConsoleColors::BrightRed).p(ostd::Utils::getHexStr(value, true, 1));
if (a < addr + size - 1)
output().p(" ");
}
if (type == TYPE_STRING)
output().fg(ostd::ConsoleColors::BrightRed).p("\"");
output().fg(ostd::ConsoleColors::Gray).p("]");
output().reset().nl();
}
}
else
{
output().fg(ostd::ConsoleColors::Red).p("Invalid value for <print> command.").reset().nl();
}
Display::printPrompt();
data().command = getCommandInput();
}
else
data().command = Display::changeScreen();
}
return DragonRuntime::RETURN_VAL_EXIT_SUCCESS;
}
int32_t Debugger::normal_runtime(bool& outUserQuit)
{
bool result = DragonRuntime::runStep(data().trackedAddresses);
bool hasError = DragonRuntime::hasError();
bool enableStepExec = !result || hasError || Utils::isEscapeKeyPressed() || DragonRuntime::cpu.isInDebugBreakPoint();
data().args.step_exec = enableStepExec;
if (enableStepExec)
return step_execution(outUserQuit, false);
return DragonRuntime::RETURN_VAL_EXIT_SUCCESS;
}
void Debugger::exec_watch_command(void)
{
auto tokens = data().command.tokenize();
for (auto& addr : tokens)
{
data().command = addr;
if (data().command.isNumeric())
{
data().trackedAddresses.push_back((uint16_t)data().command.toInt());
}
else if (data().command.startsWith("$"))
{
uint16_t nbytes = 1;
uint16_t addr = Utils::findSymbol(data().data, data().command, &nbytes);
if (addr > 0)
{
for (int32_t i = 0; i < nbytes; i++)
data().trackedAddresses.push_back(addr + i);
}
else
{
addr = Utils::findSymbol(data().labels, data().command, &nbytes);
if (addr > 0)
{
for (int32_t i = 0; i < nbytes; i++)
data().trackedAddresses.push_back(addr + i);
}
}
}
else if (data().command.contains("[") && data().command.endsWith("]"))
{
uint16_t nbytes = 1;
ostd::String str_nbytes = data().command.new_substr(data().command.indexOf("[") + 1).trim();
str_nbytes.substr(0, str_nbytes.len() - 1);
data().command.substr(0, data().command.indexOf("[")).trim();
if (str_nbytes.isNumeric())
nbytes = str_nbytes.toInt();
if (nbytes < 1) nbytes = 1;
if (data().command.isNumeric())
{
uint16_t addr = data().command.toInt();
for (int32_t i = 0; i < nbytes; i++)
data().trackedAddresses.push_back(addr + i);
}
}
}
output().p("Tracking ").p((int)data().trackedAddresses.size()).p(" addresses.").nl();
}
void Debugger::print_top_level_prompt_help(void)
{
int32_t commandLength = 40;
Utils::printFullLine('#', ostd::ConsoleColors::Black, ostd::ConsoleColors::Red);
out.nl().fg(ostd::ConsoleColors::Yellow).p("List of available commands:").reset().nl();
ostd::String tmpCommand = "(r)un";
tmpCommand.addRightPadding(commandLength);
out.fg(ostd::ConsoleColors::Blue).p(tmpCommand).fg(ostd::ConsoleColors::Green).p("Used to start the runtime.").reset().nl();
tmpCommand = "(q)uit";
tmpCommand.addRightPadding(commandLength);
out.fg(ostd::ConsoleColors::Blue).p(tmpCommand).fg(ostd::ConsoleColors::Green).p("Used to exit the debugger. (<Escape> key can also be used here.)").reset().nl();
tmpCommand = "(h)elp";
tmpCommand.addRightPadding(commandLength);
out.fg(ostd::ConsoleColors::Blue).p(tmpCommand).fg(ostd::ConsoleColors::Green).p("Used to show this dialog.").reset().nl();
tmpCommand = "(s)tep";
tmpCommand.addRightPadding(commandLength);
out.fg(ostd::ConsoleColors::Blue).p(tmpCommand).fg(ostd::ConsoleColors::Green).p("Used to enable/disable step-execution for the runtime.").reset().nl();
tmpCommand = "(t)rack <address[bytes=1]/symbol>";
tmpCommand.addRightPadding(commandLength);
out.fg(ostd::ConsoleColors::Blue).p(tmpCommand).fg(ostd::ConsoleColors::Green).p("Used to track specific addresses during execution.").reset().nl();
tmpCommand = "display";
tmpCommand.addRightPadding(commandLength);
out.fg(ostd::ConsoleColors::Blue).p(tmpCommand).fg(ostd::ConsoleColors::Green).p("Used to enable/disable the Virtual Display for the runtime.").reset().nl();
out.nl().fg(ostd::ConsoleColors::Cyan).p("The letters in parenthesis can be used as the short version of the command.").nl();
out.p("Square brackets represent optional parameters. If they have an '=' and a value, that is the default if not specified.").reset().nl();
out.nl();
Utils::printFullLine('#', ostd::ConsoleColors::Black, ostd::ConsoleColors::Red);
}
void Debugger::print_application_help(void)
{
int32_t commandLength = 46;
out.nl().fg(ostd::ConsoleColors::Yellow).p("List of available parameters:").reset().nl();
ostd::String tmpCommand = "--verbose-load";
tmpCommand.addRightPadding(commandLength);
out.fg(ostd::ConsoleColors::Blue).p(tmpCommand).fg(ostd::ConsoleColors::Green).p("Used to show more information while loading the virtual machine.").reset().nl();
tmpCommand = "--step-exec";
tmpCommand.addRightPadding(commandLength);
out.fg(ostd::ConsoleColors::Blue).p(tmpCommand).fg(ostd::ConsoleColors::Green).p("Launches the debugger directly in step-execution mode.").reset().nl();
tmpCommand = "--track-step-diff-off";
tmpCommand.addRightPadding(commandLength);
out.fg(ostd::ConsoleColors::Blue).p(tmpCommand).fg(ostd::ConsoleColors::Green).p("Disables the tracking of most machine data used for differential-view.").reset().nl();
tmpCommand = "--auto-track-data-off";
tmpCommand.addRightPadding(commandLength);
out.fg(ostd::ConsoleColors::Blue).p(tmpCommand).fg(ostd::ConsoleColors::Green).p("Disables the automatic tracking of all data-symbols.").reset().nl();
tmpCommand = "--hide-vdisplay";
tmpCommand.addRightPadding(commandLength);
out.fg(ostd::ConsoleColors::Blue).p(tmpCommand).fg(ostd::ConsoleColors::Green).p("Hides the Virtual Display during the execution of the program.").reset().nl();
tmpCommand = "--auto-start";
tmpCommand.addRightPadding(commandLength);
out.fg(ostd::ConsoleColors::Blue).p(tmpCommand).fg(ostd::ConsoleColors::Green).p("Launches the runtime directly, skipping the top-level prompt of the debugger.").reset().nl();
tmpCommand = "--force-load <binary-file> <ram-offset>";
tmpCommand.addRightPadding(commandLength);
out.fg(ostd::ConsoleColors::Blue).p(tmpCommand).fg(ostd::ConsoleColors::Green).p("Injects the specified binary into RAM at the specified offset.").reset().nl();
tmpCommand = "--help";
tmpCommand.addRightPadding(commandLength);
out.fg(ostd::ConsoleColors::Blue).p(tmpCommand).fg(ostd::ConsoleColors::Green).p("Displays this help message.").reset().nl();
out.nl().fg(ostd::ConsoleColors::Magenta).p("Usage: ./ddb <machine-config-file> [...options...]").reset().nl();
out.nl();
}
}
Reference in a new issue View git blame Copy permalink