mirror of
https://github.com/RetroDECK/Supermodel.git
synced 2024-11-26 07:35:40 +00:00
e8e02ba685
- updated debugger classes to compile again with all recent changes. - improved debugger classes to allow them to work in multi-threaded emulator and be able to handle CPUs on different threads. - added debug classes for new Z80 and Musashi 68K CPU cores. - added logging of cycle counts and frames. - moved all Supermodel specific code & configuration to CSupermodelDebugger. - added all Model 3 CPUs (PPC, sound board 68K, DSB 68K/Z80 and drive board Z80) to CSupermodelDebugger. - added persisting of custom entry points in saved debug state to CCodeAnalyser. - fixed bug with listing I/O ports in CConsoleDebugger and added displaying of cycle counts and CPU speeds when listing CPUs.
713 lines
20 KiB
C++
713 lines
20 KiB
C++
#ifdef SUPERMODEL_DEBUGGER
|
|
|
|
#include "CodeAnalyser.h"
|
|
#include "CPUDebug.h"
|
|
#include "Label.h"
|
|
|
|
#include <ctype.h>
|
|
#include <string.h>
|
|
|
|
namespace Debugger
|
|
{
|
|
CEntryPoint::CEntryPoint(const CEntryPoint &other) : addr(other.addr), autoFlag(other.autoFlag)
|
|
{
|
|
if (other.autoLabel != NULL)
|
|
{
|
|
strncpy(autoLabelStr, other.autoLabel, 254);
|
|
autoLabelStr[254] = '\0';
|
|
autoLabel = autoLabelStr;
|
|
}
|
|
else
|
|
autoLabel = NULL;
|
|
}
|
|
|
|
CEntryPoint::CEntryPoint(UINT32 eAddr, ELabelFlags eAutoFlag, const char *eAutoLabel) :
|
|
addr(eAddr), autoFlag(eAutoFlag)
|
|
{
|
|
if (eAutoLabel != NULL)
|
|
{
|
|
strncpy(autoLabelStr, eAutoLabel, 254);
|
|
autoLabelStr[254] = '\0';
|
|
autoLabel = autoLabelStr;
|
|
}
|
|
else
|
|
autoLabel = NULL;
|
|
}
|
|
|
|
CEntryPoint &CEntryPoint::operator=(const CEntryPoint &other)
|
|
{
|
|
addr = other.addr;
|
|
autoFlag = other.autoFlag;
|
|
if (other.autoLabel != NULL)
|
|
{
|
|
strncpy(autoLabelStr, other.autoLabel, 254);
|
|
autoLabelStr[254] = '\0';
|
|
autoLabel = autoLabelStr;
|
|
}
|
|
else
|
|
autoLabel = NULL;
|
|
return *this;
|
|
}
|
|
|
|
bool CEntryPoint::operator==(const CEntryPoint &other)
|
|
{
|
|
return addr == other.addr && autoFlag == other.autoFlag;
|
|
}
|
|
|
|
bool CEntryPoint::operator!=(const CEntryPoint &other)
|
|
{
|
|
return addr != other.addr || autoFlag != other.autoFlag;
|
|
}
|
|
|
|
const char *CAutoLabel::s_defaultLabelFmts[] = { "Entry%s", "Ex%s", "Int%s", "Jmp%s", "Loop%s", "Sub%s", NULL };
|
|
|
|
const unsigned CAutoLabel::numLabelFlags = sizeof(s_defaultLabelFmts) / sizeof(char*);
|
|
|
|
ELabelFlags CAutoLabel::GetLabelFlag(int index)
|
|
{
|
|
if (index < 0 || index >= numLabelFlags)
|
|
return LFNone;
|
|
return (ELabelFlags)(1 << index);
|
|
}
|
|
|
|
int CAutoLabel::GetFlagIndex(ELabelFlags flag)
|
|
{
|
|
switch (flag)
|
|
{
|
|
case LFEntryPoint: return 0;
|
|
case LFExcepHandler: return 1;
|
|
case LFInterHandler: return 2;
|
|
case LFJumpTarget: return 3;
|
|
case LFLoopPoint: return 4;
|
|
case LFSubroutine: return 5;
|
|
case LFUnseenCode: return 6;
|
|
default: return -1;
|
|
}
|
|
}
|
|
|
|
const char *CAutoLabel::GetFlagString(ELabelFlags flag)
|
|
{
|
|
switch (flag)
|
|
{
|
|
case LFEntryPoint: return "Entry Point";
|
|
case LFExcepHandler: return "Exception Handler";
|
|
case LFInterHandler: return "Interrupt Handler";
|
|
case LFJumpTarget: return "Jump Target";
|
|
case LFLoopPoint: return "Loop Point";
|
|
case LFSubroutine: return "Subroutine";
|
|
case LFUnseenCode: return "Unseen Code";
|
|
default: return "";
|
|
}
|
|
}
|
|
|
|
CAutoLabel::CAutoLabel(CCPUDebug *lCPU, UINT32 lAddr) : CAddressRef(lCPU, lAddr), flags(LFNone), m_acquired(0)
|
|
{
|
|
memset(m_subLabels, NULL, sizeof(m_subLabels));
|
|
}
|
|
|
|
CAutoLabel::~CAutoLabel()
|
|
{
|
|
// Delete all sub-labels
|
|
for (int index = 0; index < numLabelFlags; index++)
|
|
{
|
|
if (m_subLabels[index] != NULL)
|
|
{
|
|
delete[] m_subLabels[index];
|
|
m_subLabels[index] = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CAutoLabel::Acquire()
|
|
{
|
|
m_acquired++;
|
|
}
|
|
|
|
void CAutoLabel::Release()
|
|
{
|
|
if (--m_acquired == 0)
|
|
delete this;
|
|
}
|
|
|
|
void CAutoLabel::AddFlag(ELabelFlags flag, const char *subLabel)
|
|
{
|
|
int index = GetFlagIndex(flag);
|
|
if (index == -1)
|
|
return;
|
|
flags = (ELabelFlags)((unsigned)flags | (unsigned)flag);
|
|
if (subLabel != NULL)
|
|
{
|
|
size_t len = strlen(subLabel);
|
|
char *label = new char[len + 1];
|
|
strncpy(label, subLabel, len);
|
|
label[len] = '\0';
|
|
m_subLabels[index] = label;
|
|
}
|
|
else
|
|
m_subLabels[index] = CreateDefaultSubLabel(flag);
|
|
}
|
|
|
|
bool CAutoLabel::GetLabel(char *labelStr, ELabelFlags subFlags)
|
|
{
|
|
char *p = labelStr;
|
|
*p = '\0';
|
|
for (int index = 0; index < numLabelFlags; index++)
|
|
{
|
|
ELabelFlags flag = GetLabelFlag(index);
|
|
if (!(subFlags & flag))
|
|
continue;
|
|
const char *subLabel = m_subLabels[index];
|
|
if (subLabel == NULL)
|
|
continue;
|
|
if (p > labelStr)
|
|
{
|
|
(*p++) = '/';
|
|
*p = '\0';
|
|
}
|
|
strcat(p, subLabel);
|
|
p += strlen(subLabel);
|
|
*p = '\0';
|
|
}
|
|
return p > labelStr;
|
|
}
|
|
|
|
bool CAutoLabel::ContainsSubLabel(const char *subLabel)
|
|
{
|
|
for (int i = 0; i < numLabelFlags; i++)
|
|
{
|
|
if (m_subLabels[i] != NULL && stricmp(subLabel, m_subLabels[i]) == 0)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
const char *CAutoLabel::CreateDefaultSubLabel(ELabelFlags flag)
|
|
{
|
|
int index = GetFlagIndex(flag);
|
|
if (index == -1)
|
|
return NULL;
|
|
const char *labelFmt = s_defaultLabelFmts[index];
|
|
if (labelFmt == NULL)
|
|
return NULL;
|
|
char addrStr[50];
|
|
cpu->debugger->FormatData(addrStr, Hex, (unsigned)(cpu->memBusWidth / 8), (UINT64)addr);
|
|
char *label = new char[255];
|
|
sprintf(label, labelFmt, addrStr);
|
|
return label;
|
|
}
|
|
|
|
CCodeAnalysis::CCodeAnalysis(CCodeAnalyser *aAnalyser) : analyser(aAnalyser)
|
|
{
|
|
//
|
|
}
|
|
|
|
CCodeAnalysis::CCodeAnalysis(CCodeAnalyser *aAnalyser, unsigned aTotalIndices, vector<CEntryPoint> &entryPoints, vector<UINT32> &unseenEntryAddrs) :
|
|
analyser(aAnalyser), m_entryPoints(entryPoints), m_unseenEntryAddrs(unseenEntryAddrs),
|
|
m_seenIndices(aTotalIndices), m_validIndices(aTotalIndices), m_acquired(0)
|
|
{
|
|
//
|
|
}
|
|
|
|
CCodeAnalysis::CCodeAnalysis(CCodeAnalysis *oldAnalysis, vector<CEntryPoint> &entryPoints, vector<UINT32> &unseenEntryAddrs) :
|
|
analyser(oldAnalysis->analyser), m_entryPoints(entryPoints), m_unseenEntryAddrs(unseenEntryAddrs),
|
|
m_seenIndices(oldAnalysis->m_seenIndices), m_validIndices(oldAnalysis->m_validIndices),
|
|
m_autoLabelsMap(oldAnalysis->m_autoLabelsMap), m_acquired(0), validIndexSet(oldAnalysis->validIndexSet)
|
|
{
|
|
for (map<unsigned,CAutoLabel*>::iterator it = m_autoLabelsMap.begin(); it != m_autoLabelsMap.end(); it++)
|
|
it->second->Acquire();
|
|
}
|
|
|
|
CCodeAnalysis::~CCodeAnalysis()
|
|
{
|
|
for (vector<CAutoLabel*>::iterator it = autoLabels.begin(); it != autoLabels.end(); it++)
|
|
(*it)->Release();
|
|
autoLabels.clear();
|
|
m_autoLabelsMap.clear();
|
|
}
|
|
|
|
void CCodeAnalysis::Acquire()
|
|
{
|
|
m_acquired++;
|
|
}
|
|
|
|
void CCodeAnalysis::Release()
|
|
{
|
|
if (--m_acquired == 0)
|
|
delete this;
|
|
}
|
|
|
|
void CCodeAnalysis::FinishAnalysis()
|
|
{
|
|
for (map<UINT32,CAutoLabel*>::iterator it = m_autoLabelsMap.begin(); it != m_autoLabelsMap.end(); it++)
|
|
autoLabels.push_back(it->second);
|
|
}
|
|
|
|
bool CCodeAnalysis::IsAddrValid(UINT32 addr)
|
|
{
|
|
unsigned index;
|
|
if (!analyser->GetIndexOfAddr(addr, index))
|
|
return false;
|
|
return IsIndexValid(index);
|
|
}
|
|
|
|
bool CCodeAnalysis::GetNextValidAddr(UINT32 &addr)
|
|
{
|
|
unsigned index;
|
|
if (!analyser->GetIndexOfAddr(addr, index))
|
|
return false;
|
|
if (IsIndexValid(index))
|
|
return true;
|
|
set<unsigned>::iterator it = validIndexSet.lower_bound(index);
|
|
if (it == validIndexSet.end())
|
|
return false;
|
|
return analyser->GetAddrOfIndex(*it, addr);
|
|
}
|
|
|
|
bool CCodeAnalysis::IsIndexValid(unsigned index)
|
|
{
|
|
return index < m_validIndices.size() && m_validIndices[index];
|
|
}
|
|
|
|
bool CCodeAnalysis::GetNextValidIndex(unsigned &index)
|
|
{
|
|
if (IsIndexValid(index))
|
|
return true;
|
|
set<unsigned>::iterator it = validIndexSet.lower_bound(index);
|
|
if (it == validIndexSet.end())
|
|
return false;
|
|
index = *it;
|
|
return true;
|
|
}
|
|
|
|
bool CCodeAnalysis::HasSeenAddr(UINT32 addr)
|
|
{
|
|
unsigned index;
|
|
if (!analyser->GetIndexOfAddr(addr, index))
|
|
return false;
|
|
return HaveSeenIndex(index);
|
|
}
|
|
|
|
bool CCodeAnalysis::HaveSeenIndex(unsigned index)
|
|
{
|
|
return index < m_seenIndices.size() && m_seenIndices[index];
|
|
}
|
|
|
|
CAutoLabel *CCodeAnalysis::GetAutoLabel(UINT32 addr)
|
|
{
|
|
map<UINT32,CAutoLabel*>::iterator it = m_autoLabelsMap.find(addr);
|
|
if (it == m_autoLabelsMap.end())
|
|
return NULL;
|
|
return it->second;
|
|
}
|
|
|
|
CAutoLabel *CCodeAnalysis::GetAutoLabel(const char *subLabel)
|
|
{
|
|
for (vector<CAutoLabel*>::iterator it = autoLabels.begin(); it != autoLabels.end(); it++)
|
|
{
|
|
if ((*it)->ContainsSubLabel(subLabel))
|
|
return *it;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
vector<CAutoLabel*> CCodeAnalysis::GetAutoLabels(ELabelFlags flag)
|
|
{
|
|
vector<CAutoLabel*> matched;
|
|
for (vector<CAutoLabel*>::iterator it = autoLabels.begin(); it != autoLabels.end(); it++)
|
|
{
|
|
if ((*it)->flags & flag)
|
|
matched.push_back(*it);
|
|
}
|
|
return matched;
|
|
}
|
|
|
|
CCodeAnalyser::CCodeAnalyser(CCPUDebug *aCPU) : cpu(aCPU), emptyAnalysis(this), analysis(&emptyAnalysis)
|
|
{
|
|
instrAlign = cpu->minInstrLen;
|
|
|
|
totalIndices = 0;
|
|
for (vector<CRegion*>::iterator it = cpu->regions.begin(); it != cpu->regions.end(); it++)
|
|
{
|
|
if (!(*it)->isCode)
|
|
continue;
|
|
m_codeRegions.push_back(*it);
|
|
totalIndices += (*it)->size / instrAlign;
|
|
m_indexBounds.push_back(totalIndices);
|
|
}
|
|
}
|
|
|
|
CCodeAnalyser::~CCodeAnalyser()
|
|
{
|
|
if (analysis != &emptyAnalysis)
|
|
analysis->Release();
|
|
}
|
|
|
|
void CCodeAnalyser::Reset()
|
|
{
|
|
CCodeAnalysis *oldAnalysis = analysis;
|
|
analysis = &emptyAnalysis;
|
|
if (oldAnalysis != &emptyAnalysis)
|
|
oldAnalysis->Release();
|
|
}
|
|
|
|
bool CCodeAnalyser::GetAddrOfIndex(unsigned index, UINT32 &addr)
|
|
{
|
|
unsigned regIndex = 0;
|
|
unsigned prevBound = 0;
|
|
for (vector<unsigned>::iterator it = m_indexBounds.begin(); it != m_indexBounds.end(); it++)
|
|
{
|
|
if (*it > index)
|
|
{
|
|
addr = m_codeRegions[regIndex]->addr + (UINT32)(index - prevBound) * instrAlign;
|
|
return true;
|
|
}
|
|
prevBound = *it;
|
|
regIndex++;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CCodeAnalyser::GetIndexOfAddr(UINT32 addr, unsigned &index)
|
|
{
|
|
unsigned regIndex = 0;
|
|
for (vector<CRegion*>::iterator it = m_codeRegions.begin(); it != m_codeRegions.end(); it++)
|
|
{
|
|
if ((*it)->addr <= addr && addr <= (*it)->addrEnd)
|
|
{
|
|
unsigned offset = (unsigned)((addr - (*it)->addr) / instrAlign);
|
|
index = (regIndex > 0 ? m_indexBounds[regIndex - 1] + offset : (unsigned)offset);
|
|
return true;
|
|
}
|
|
regIndex++;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void CCodeAnalyser::CheckEntryPoints(vector<CEntryPoint> &entryPoints, vector<UINT32> &unseenEntryAddrs, vector<CEntryPoint> &prevPoints,
|
|
bool &needsAnalysis, bool &reanalyse)
|
|
{
|
|
needsAnalysis = false;
|
|
|
|
// Gather entry points
|
|
GatherEntryPoints(entryPoints, unseenEntryAddrs, reanalyse);
|
|
if (reanalyse)
|
|
{
|
|
needsAnalysis = true;
|
|
return;
|
|
}
|
|
|
|
// Compare new entry points with previous ones
|
|
for (size_t i = 0; i < entryPoints.size(); i++)
|
|
{
|
|
// Check if have more than before
|
|
if (i >= prevPoints.size())
|
|
{
|
|
needsAnalysis = true;
|
|
return;
|
|
}
|
|
// Check if any have changed
|
|
if (entryPoints[i] != prevPoints[i])
|
|
{
|
|
// If entry points, exception handlers or interrupt handlers have changed, then force reanalysis
|
|
if (entryPoints[i].autoFlag == LFEntryPoint || prevPoints[i].autoFlag == LFEntryPoint ||
|
|
entryPoints[i].autoFlag == LFExcepHandler || prevPoints[i].autoFlag == LFExcepHandler ||
|
|
entryPoints[i].autoFlag == LFInterHandler || prevPoints[i].autoFlag == LFInterHandler)
|
|
reanalyse = true;
|
|
needsAnalysis = true;
|
|
return;
|
|
}
|
|
}
|
|
// Check if have less than before
|
|
if (entryPoints.size() < prevPoints.size())
|
|
{
|
|
// If so, force reanalysis
|
|
reanalyse = true;
|
|
needsAnalysis = true;
|
|
return;
|
|
}
|
|
}
|
|
|
|
void CCodeAnalyser::GatherEntryPoints(vector<CEntryPoint> &entryPoints, vector<UINT32> &unseenEntryAddrs, bool &reanalyse)
|
|
{
|
|
char labelStr[255];
|
|
UINT32 addr;
|
|
unsigned index;
|
|
|
|
entryPoints.clear();
|
|
reanalyse = false;
|
|
|
|
// Add reset address as main entry point
|
|
AddEntryPoint(entryPoints, cpu->GetResetAddr(), LFEntryPoint, "MainEntry");
|
|
|
|
// Add exception handlers as entry points
|
|
for (vector<CException*>::iterator it = cpu->exceps.begin(); it != cpu->exceps.end(); it++)
|
|
{
|
|
if (!cpu->GetHandlerAddr(*it, addr))
|
|
continue;
|
|
sprintf(labelStr, "Ex%s", (*it)->id);
|
|
AddEntryPoint(entryPoints, addr, LFExcepHandler, labelStr);
|
|
}
|
|
|
|
// Add interrupt handlers as entry points
|
|
for (vector<CInterrupt*>::iterator it = cpu->inters.begin(); it != cpu->inters.end(); it++)
|
|
{
|
|
if (!cpu->GetHandlerAddr(*it, addr))
|
|
continue;
|
|
sprintf(labelStr, "Int%s", (*it)->id);
|
|
AddEntryPoint(entryPoints, addr, LFInterHandler, labelStr);
|
|
}
|
|
|
|
// Add custom entry addresses
|
|
unsigned i = 0;
|
|
for (vector<UINT32>::iterator it = m_customEntryAddrs.begin(); it != m_customEntryAddrs.end(); it++)
|
|
{
|
|
sprintf(labelStr, "Custom%u", i++);
|
|
AddEntryPoint(entryPoints, *it, LFEntryPoint, labelStr);
|
|
}
|
|
|
|
// If current PC address is at an unseen location or at location that was previously invalid, then add address as unseen entry point
|
|
if (cpu->instrCount > 0 && GetIndexOfAddr(cpu->pc, index) && (!analysis->HaveSeenIndex(index) || !analysis->IsIndexValid(index)))
|
|
{
|
|
// If at location that was previously seen and was invalid, then force reanalysis (ie because code may have been modified)
|
|
if (analysis->HaveSeenIndex(index) && !analysis->IsIndexValid(index))
|
|
reanalyse = true;
|
|
|
|
// Check that address not already included in previous entry points
|
|
bool unseen = true;
|
|
for (vector<CEntryPoint>::iterator it = entryPoints.begin(); it != entryPoints.end(); it++)
|
|
{
|
|
if ((*it).addr == cpu->pc)
|
|
{
|
|
unseen = false;
|
|
break;
|
|
}
|
|
}
|
|
if (unseen && find(unseenEntryAddrs.begin(), unseenEntryAddrs.end(), cpu->pc) == unseenEntryAddrs.end())
|
|
unseenEntryAddrs.push_back(cpu->pc);
|
|
}
|
|
|
|
// Add unseen entry points
|
|
for (vector<UINT32>::iterator it = unseenEntryAddrs.begin(); it != unseenEntryAddrs.end(); it++)
|
|
AddEntryPoint(entryPoints, *it, LFUnseenCode, NULL);
|
|
}
|
|
|
|
void CCodeAnalyser::AddEntryPoint(vector<CEntryPoint> &entryPoints, UINT32 addr, ELabelFlags autoFlag, const char *autoLabel)
|
|
{
|
|
CEntryPoint entryPoint(addr, autoFlag, autoLabel);
|
|
if (find(entryPoints.begin(), entryPoints.end(), entryPoint) == entryPoints.end())
|
|
entryPoints.push_back(entryPoint);
|
|
}
|
|
|
|
bool CCodeAnalyser::NeedsAnalysis()
|
|
{
|
|
vector<CEntryPoint> entryPoints;
|
|
vector<UINT32> unseenEntryAddrs(analysis->m_unseenEntryAddrs);
|
|
bool needsAnalysis;
|
|
bool reanalyse;
|
|
CheckEntryPoints(entryPoints, unseenEntryAddrs, analysis->m_entryPoints, needsAnalysis, reanalyse);
|
|
return needsAnalysis;
|
|
}
|
|
|
|
bool CCodeAnalyser::AnalyseCode()
|
|
{
|
|
m_abortAnalysis = false;
|
|
|
|
CCodeAnalysis *oldAnalysis = analysis;
|
|
|
|
vector<CEntryPoint> entryPoints;
|
|
vector<UINT32> unseenEntryAddrs(oldAnalysis->m_unseenEntryAddrs);
|
|
bool needsAnalysis;
|
|
bool reanalyse;
|
|
CheckEntryPoints(entryPoints, unseenEntryAddrs, oldAnalysis->m_entryPoints, needsAnalysis, reanalyse);
|
|
if (!needsAnalysis)
|
|
return false;
|
|
|
|
CCodeAnalysis *newAnalysis;
|
|
if (reanalyse || oldAnalysis == &emptyAnalysis)
|
|
newAnalysis = new CCodeAnalysis(this, totalIndices, entryPoints, unseenEntryAddrs);
|
|
else
|
|
newAnalysis = new CCodeAnalysis(oldAnalysis, entryPoints, unseenEntryAddrs);
|
|
newAnalysis->Acquire();
|
|
|
|
for (vector<CEntryPoint>::iterator it = newAnalysis->m_entryPoints.begin(); it != newAnalysis->m_entryPoints.end(); it++)
|
|
{
|
|
AddFlagToAddr(newAnalysis->m_autoLabelsMap, it->addr, it->autoFlag, it->autoLabel);
|
|
AnalyseCode(newAnalysis->m_seenIndices, newAnalysis->m_validIndices, newAnalysis->validIndexSet, newAnalysis->m_autoLabelsMap, it->addr);
|
|
}
|
|
newAnalysis->FinishAnalysis();
|
|
|
|
if (m_abortAnalysis)
|
|
{
|
|
newAnalysis->Release();
|
|
return false;
|
|
}
|
|
|
|
analysis = newAnalysis;
|
|
if (oldAnalysis != &emptyAnalysis)
|
|
oldAnalysis->Release();
|
|
|
|
cpu->debugger->AnalysisUpdated(this);
|
|
return true;
|
|
}
|
|
|
|
void CCodeAnalyser::AnalyseCode(vector<bool> &seenIndices, vector<bool> &validIndices, set<unsigned> &validIndexSet,
|
|
map<UINT32,CAutoLabel*> &autoLabelsMap, UINT32 addr)
|
|
{
|
|
if (m_abortAnalysis)
|
|
return;
|
|
|
|
unsigned index;
|
|
if (!GetIndexOfAddr(addr, index) || seenIndices[index])
|
|
return;
|
|
|
|
CRegion *region = cpu->GetRegion(addr);
|
|
if (region == NULL || !region->isCode)
|
|
return;
|
|
|
|
set<unsigned>::iterator setIt = validIndexSet.end();
|
|
|
|
unsigned startIndex = index;
|
|
do
|
|
{
|
|
if (m_abortAnalysis)
|
|
return;
|
|
|
|
// Flag that have seen this address index
|
|
seenIndices[index] = true;
|
|
|
|
// If unit is not valid (ie doesn't disassemble) then code block must be invalid (TODO - invalidate whole code block?)
|
|
int codesLen = cpu->GetOpLength(addr);
|
|
if (codesLen <= 0)
|
|
return;
|
|
|
|
validIndices[index] = true;
|
|
if (setIt != validIndexSet.end())
|
|
setIt = validIndexSet.insert(setIt, index);
|
|
else
|
|
setIt = validIndexSet.insert(index).first;
|
|
|
|
UINT32 opcode = cpu->GetOpcode(addr);
|
|
EOpFlags opFlags = cpu->GetOpFlags(addr, opcode);
|
|
|
|
// See if instruction is jump
|
|
if (opFlags & (JumpSimple|JumpLoop|JumpSub))
|
|
{
|
|
// If so, see if address is valid (ie known at disassemble time)
|
|
UINT32 jumpAddr;
|
|
if (cpu->GetJumpAddr(addr, opcode, jumpAddr))
|
|
{
|
|
// If so, add flags to jump address and analyse destination code block too
|
|
if (opFlags & JumpSub) AddFlagToAddr(autoLabelsMap, jumpAddr, LFSubroutine, NULL);
|
|
else if (opFlags & JumpLoop) AddFlagToAddr(autoLabelsMap, jumpAddr, LFLoopPoint, NULL);
|
|
else AddFlagToAddr(autoLabelsMap, jumpAddr, LFJumpTarget, NULL);
|
|
AnalyseCode(seenIndices, validIndices, validIndexSet, autoLabelsMap, jumpAddr);
|
|
}
|
|
}
|
|
|
|
// Finish if instruction terminates code block (ie is not conditional and is either a non-returning jump, a return or some sort
|
|
// of reset/halting instruction)
|
|
if (!(opFlags & Conditional) && (opFlags & (JumpSimple|JumpLoop|ReturnEx|ReturnSub|HaltExec)))
|
|
return;
|
|
|
|
// Move to next index
|
|
index += (unsigned)codesLen / instrAlign;
|
|
|
|
// If reach end of address indices, code block must be invalid (TODO - invalidate whole code block?)
|
|
if (index >= totalIndices)
|
|
return;
|
|
|
|
// Move to next address
|
|
addr += (UINT32)codesLen;
|
|
|
|
// If move between regions, check new region is valid
|
|
if (addr > region->addrEnd)
|
|
{
|
|
region = cpu->GetRegion(addr);
|
|
if (region == NULL || !region->isCode) // (TODO - invalidate whole code block?)
|
|
return;
|
|
}
|
|
}
|
|
while (!seenIndices[index]);
|
|
}
|
|
|
|
void CCodeAnalyser::AddFlagToAddr(map<UINT32,CAutoLabel*> &autoLabelsMap, UINT32 addr, ELabelFlags flag, const char *subLabel)
|
|
{
|
|
if (flag == LFNone)
|
|
return;
|
|
map<UINT32,CAutoLabel*>::iterator it = autoLabelsMap.find(addr);
|
|
CAutoLabel *label;
|
|
if (it == autoLabelsMap.end())
|
|
{
|
|
label = new CAutoLabel(cpu, addr);
|
|
label->Acquire();
|
|
autoLabelsMap[addr] = label;
|
|
}
|
|
else
|
|
label = it->second;
|
|
label->AddFlag(flag, subLabel);
|
|
}
|
|
|
|
void CCodeAnalyser::AbortAnalysis()
|
|
{
|
|
m_abortAnalysis = true;
|
|
}
|
|
|
|
void CCodeAnalyser::ClearCustomEntryAddrs()
|
|
{
|
|
m_customEntryAddrs.clear();
|
|
}
|
|
|
|
void CCodeAnalyser::AddCustomEntryAddr(UINT32 entryAddr)
|
|
{
|
|
if (find(m_customEntryAddrs.begin(), m_customEntryAddrs.end(), entryAddr) == m_customEntryAddrs.end())
|
|
m_customEntryAddrs.push_back(entryAddr);
|
|
}
|
|
|
|
bool CCodeAnalyser::RemoveCustomEntryAddr(UINT32 entryAddr)
|
|
{
|
|
vector<UINT32>::iterator it = find(m_customEntryAddrs.begin(), m_customEntryAddrs.end(), entryAddr);
|
|
if (it == m_customEntryAddrs.end())
|
|
return false;
|
|
m_customEntryAddrs.erase(it);
|
|
return true;
|
|
}
|
|
|
|
#ifdef DEBUGGER_HASBLOCKFILE
|
|
bool CCodeAnalyser::LoadState(CBlockFile *state)
|
|
{
|
|
// Load custom entry addresses
|
|
char blockStr[255];
|
|
sprintf(blockStr, "%s.entryaddrs", cpu->name);
|
|
if (state->FindBlock(blockStr) == OKAY)
|
|
{
|
|
m_customEntryAddrs.clear();
|
|
UINT32 numAddrs;
|
|
state->Read(&numAddrs, sizeof(numAddrs));
|
|
for (UINT32 i = 0; i < numAddrs; i++)
|
|
{
|
|
UINT32 addr;
|
|
state->Read(&addr, sizeof(addr));
|
|
m_customEntryAddrs.push_back(addr);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CCodeAnalyser::SaveState(CBlockFile *state)
|
|
{
|
|
// Save custom entry addresses
|
|
char blockStr[255];
|
|
sprintf(blockStr, "%s.entryaddrs", cpu->name);
|
|
state->NewBlock(blockStr, __FILE__);
|
|
UINT32 numAddrs = m_customEntryAddrs.size();
|
|
state->Write(&numAddrs, sizeof(numAddrs));
|
|
for (UINT32 i = 0; i < numAddrs; i++)
|
|
{
|
|
UINT32 addr = m_customEntryAddrs[i];
|
|
state->Write(&addr, sizeof(addr));
|
|
}
|
|
return true;
|
|
}
|
|
#endif // DEBUGGER_HASBLOCKFILE
|
|
}
|
|
#endif // SUPERMODEL_DEBUGGER
|