static void updateEvents(PluginData* plugin, PDWriter* writer)
{
char* res = 0;
int len = 0;
if (!plugin->conn)
return;
// Fetch the data that has been sent from VICE
if (!getData(plugin, &res, &len))
return;
plugin->state = PDDebugState_stopException;
// do data parsing here
stopOnExec(plugin, res);
parseRegisters(plugin, res, len);
parseStep(plugin, res);
parseBreakpoint(plugin, res, writer);
parseDisassembly(writer, res, len);
parseForCallstack(writer, res, len);
}
void TbTrace::printDisassembly(const std::string &module, uint64_t relPc, unsigned tbSize)
{
Disassembly::iterator it = m_disassembly.find(module);
if (it == m_disassembly.end()) {
llvm::sys::Path disassemblyListing;
if (!m_library->findDisassemblyListing(module, disassemblyListing)) {
std::cerr << "Could not find disassembly listing for module "
<< module << std::endl;
return;
}
if (!parseDisassembly(disassemblyListing.str(), m_disassembly)) {
return;
}
it = m_disassembly.find(module);
assert(it != m_disassembly.end());
}
//Fetch the basic blocks for our module
ModuleBasicBlocks::iterator bbit = m_basicBlocks.find(module);
if (bbit == m_basicBlocks.end()) {
llvm::sys::Path basicBlockList;
if (!m_library->findBasicBlockList(module, basicBlockList)) {
std::cerr << "TbTrace: could not find basic block list for "
<< module << std::endl;
exit(-1);
}
TbTraceBbs moduleBbs;
if (!BasicBlockListParser::parseListing(basicBlockList, moduleBbs)) {
std::cerr << "TbTrace: could not parse basic block list in file "
<< basicBlockList.str() << std::endl;
exit(-1);
}
m_basicBlocks[module] = moduleBbs;
bbit = m_basicBlocks.find(module);
assert(bbit != m_basicBlocks.end());
}
while((int)tbSize > 0) {
//Fetch the right basic block
BasicBlock bbToFetch(relPc, 1);
TbTraceBbs::iterator mybb = (*bbit).second.find(bbToFetch);
if (mybb == (*bbit).second.end()) {
m_output << "Could not find basic block 0x" << std::hex << relPc << " in the list" << std::endl;
return;
}
//Found the basic block, compute the range of program counters
//whose disassembly we are going to print.
const BasicBlock &bb = *mybb;
uint64_t asmStartPc = relPc;
uint64_t asmEndPc;
if (relPc + tbSize >= bb.start + bb.size) {
asmEndPc = bb.start + bb.size;
}else {
asmEndPc = relPc + tbSize;
}
assert(relPc >= bb.start && relPc < bb.start + bb.size);
//Grab the vector of strings for the program counter
ModuleDisassembly::iterator modIt = (*it).second.find(asmStartPc);
if (modIt == (*it).second.end()) {
return;
}
//Fetch the range of program counters from the disassembly file
ModuleDisassembly::iterator modItEnd = (*it).second.lower_bound(asmEndPc);
for (ModuleDisassembly::iterator it = modIt; it != modItEnd; ++it) {
//Print the vector we've got
for(DisassemblyEntry::const_iterator asmIt = (*it).second.begin();
asmIt != (*it).second.end(); ++asmIt) {
m_output << "\033[1;33m" << *asmIt << "\033[0m" << std::endl;
}
}
tbSize -= asmEndPc - asmStartPc;
relPc += asmEndPc - asmStartPc;
if ((int)tbSize < 0) {
assert(false && "Cannot be negative");
}
}
}
