mirror of
https://github.com/RetroDECK/Supermodel.git
synced 2024-11-22 22:05:38 +00:00
308 lines
8 KiB
C++
308 lines
8 KiB
C++
/**
|
|
** Supermodel
|
|
** A Sega Model 3 Arcade Emulator.
|
|
** Copyright 2011 Bart Trzynadlowski, Nik Henson
|
|
**
|
|
** This file is part of Supermodel.
|
|
**
|
|
** Supermodel is free software: you can redistribute it and/or modify it under
|
|
** the terms of the GNU General Public License as published by the Free
|
|
** Software Foundation, either version 3 of the License, or (at your option)
|
|
** any later version.
|
|
**
|
|
** Supermodel is distributed in the hope that it will be useful, but WITHOUT
|
|
** ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
** FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
** more details.
|
|
**
|
|
** You should have received a copy of the GNU General Public License along
|
|
** with Supermodel. If not, see <http://www.gnu.org/licenses/>.
|
|
**/
|
|
|
|
/*
|
|
* Watch.cpp
|
|
*/
|
|
|
|
#ifdef SUPERMODEL_DEBUGGER
|
|
|
|
#include "CPUDebug.h"
|
|
#include "Debugger.h"
|
|
#include "DebuggerIO.h"
|
|
#include "Watch.h"
|
|
#include <string>
|
|
|
|
using namespace std;
|
|
|
|
namespace Debugger
|
|
{
|
|
UINT32 CWatch::GetIOAddress(CIO *io)
|
|
{
|
|
CMappedIO *mappedIO = dynamic_cast<CMappedIO*>(io);
|
|
return (mappedIO != NULL ? mappedIO->addr : 0);
|
|
}
|
|
|
|
CWatch::CWatch(CCPUDebug *wCPU, UINT32 wAddr, unsigned wSize, char wSymbol, const char *wType, bool wTrigRead, bool wTrigWrite) :
|
|
CAddressRef(wCPU, wAddr, wSize), io(NULL), symbol(wSymbol), type(wType), trigRead(wTrigRead), trigWrite(wTrigWrite), active(true),
|
|
readCount(0), writeCount(0)
|
|
{
|
|
//
|
|
}
|
|
|
|
CWatch::CWatch(CCPUDebug *wCPU, CIO *wIO, char wSymbol, const char *wType, bool wTrigInput, bool mTrigOutput) :
|
|
CAddressRef(wCPU, GetIOAddress(wIO), wIO->dataSize), io(wIO), symbol(wSymbol), type(wType), trigRead(wTrigInput), trigWrite(mTrigOutput), active(true),
|
|
readCount(0), writeCount(0)
|
|
{
|
|
//
|
|
}
|
|
|
|
bool CWatch::HasValue()
|
|
{
|
|
if (io != NULL)
|
|
return io->inCount + io->outCount > 0;
|
|
else
|
|
return true;
|
|
}
|
|
|
|
UINT64 CWatch::GetValue()
|
|
{
|
|
if (io != NULL)
|
|
return *io->last;
|
|
else
|
|
return cpu->ReadMem(addr, size);
|
|
}
|
|
|
|
bool CWatch::CheckRead(UINT32 cAddr, unsigned cDataSize, UINT64 data)
|
|
{
|
|
if (!active || !trigRead)
|
|
return false;
|
|
// Take care with read that was not aligned with watch address and size
|
|
UINT64 sData = CDebugger::GetSlottedData(cAddr, cDataSize, data, addr, size);
|
|
return CheckBreak(true, sData);
|
|
}
|
|
|
|
bool CWatch::CheckWrite(UINT32 cAddr, unsigned cDataSize, UINT64 data)
|
|
{
|
|
if (!active || !trigWrite)
|
|
return false;
|
|
// Take care with write that was not aligned with watch address and size
|
|
UINT64 sData = CDebugger::GetSlottedData(cAddr, cDataSize, data, addr, size);
|
|
return CheckBreak(false, sData);
|
|
}
|
|
|
|
bool CWatch::CheckInput(CIO *cIO, UINT64 data)
|
|
{
|
|
// No need to align data as already aligned by CIO
|
|
return active && trigRead && CheckBreak(true, data);
|
|
}
|
|
|
|
bool CWatch::CheckOutput(CIO *cIO, UINT64 data)
|
|
{
|
|
// No need to align data as already aligned by CIO
|
|
return active && trigWrite && CheckBreak(false, data);
|
|
}
|
|
|
|
void CWatch::Reset()
|
|
{
|
|
//
|
|
}
|
|
|
|
bool CWatch::GetInfo(char *str)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
CSimpleWatch::CSimpleWatch(CCPUDebug *wCPU, UINT32 wAddr, unsigned wSize, bool wTrigRead, bool wTrigWrite) :
|
|
CWatch(wCPU, wAddr, wSize, '*', "simple", wTrigRead, wTrigWrite)
|
|
{
|
|
//
|
|
}
|
|
|
|
CSimpleWatch::CSimpleWatch(CCPUDebug *wCPU, CIO *wIO, bool wTrigInput, bool mTrigOutput) :
|
|
CWatch(wCPU, wIO, '*', "simple", wTrigInput, mTrigOutput)
|
|
{
|
|
//
|
|
}
|
|
|
|
|
|
bool CSimpleWatch::CheckBreak(bool isRead, UINT64 data)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
CCountWatch::CCountWatch(CCPUDebug *wCPU, UINT32 wAddr, unsigned wSize, bool wTrigRead, bool wTrigWrite, unsigned count) :
|
|
CWatch(wCPU, wAddr, wSize, '+', "count", wTrigRead, wTrigWrite), m_count(count), m_counter(0)
|
|
{
|
|
//
|
|
}
|
|
|
|
CCountWatch::CCountWatch(CCPUDebug *wCPU, CIO *wIO, bool wTrigInput, bool mTrigOutput, unsigned count) :
|
|
CWatch(wCPU, wIO, '+', "count", wTrigInput, mTrigOutput), m_count(count), m_counter(0)
|
|
{
|
|
//
|
|
}
|
|
|
|
bool CCountWatch::CheckBreak(bool isRead, UINT64 data)
|
|
{
|
|
return ++m_counter == m_count;
|
|
}
|
|
|
|
void CCountWatch::Reset()
|
|
{
|
|
m_counter = 0;
|
|
}
|
|
|
|
bool CCountWatch::GetInfo(char *str)
|
|
{
|
|
sprintf(str, "%d / %d", m_counter, m_count);
|
|
return true;
|
|
}
|
|
|
|
CMatchWatch::CMatchWatch(CCPUDebug *wCPU, UINT32 wAddr, unsigned wSize, bool wTrigRead, bool wTrigWrite, vector<UINT64> &dataSeq) :
|
|
CWatch(wCPU, wAddr, wSize, 'M', "match", wTrigRead, wTrigWrite), m_dataLen(dataSeq.size()), m_counter(0)
|
|
{
|
|
m_dataArray = new UINT64[m_dataLen];
|
|
copy(dataSeq.begin(), dataSeq.end(), m_dataArray);
|
|
}
|
|
|
|
CMatchWatch::CMatchWatch(CCPUDebug *wCPU, CIO *wIO, bool wTrigInput, bool mTrigOutput, vector<UINT64> &dataSeq) :
|
|
CWatch(wCPU, wIO, 'M', "match", wTrigInput, mTrigOutput), m_dataLen(dataSeq.size()), m_counter(0)
|
|
{
|
|
m_dataArray = new UINT64[m_dataLen];
|
|
copy(dataSeq.begin(), dataSeq.end(), m_dataArray);
|
|
}
|
|
|
|
CMatchWatch::~CMatchWatch()
|
|
{
|
|
delete m_dataArray;
|
|
}
|
|
|
|
bool CMatchWatch::CheckBreak(bool isRead, UINT64 data)
|
|
{
|
|
if (m_dataArray[m_counter] == data)
|
|
m_counter++;
|
|
else
|
|
m_counter = 0;
|
|
return m_counter == m_dataLen;
|
|
}
|
|
|
|
void CMatchWatch::Reset()
|
|
{
|
|
m_counter = 0;
|
|
}
|
|
|
|
bool CMatchWatch::GetInfo(char *str)
|
|
{
|
|
sprintf(str, "%d / %d matched", m_counter, m_dataLen);
|
|
return true;
|
|
}
|
|
|
|
CCaptureWatch::CCaptureWatch(CCPUDebug *wCPU, UINT32 wAddr, unsigned wSize, bool wTrigRead, bool wTrigWrite, unsigned wMaxLen) :
|
|
CWatch(wCPU, wAddr, wSize, 'C', "capture", wTrigRead, wTrigWrite), m_maxLen(min<unsigned>(255, wMaxLen)), m_len(0), m_index(0)
|
|
{
|
|
//
|
|
}
|
|
|
|
CCaptureWatch::CCaptureWatch(CCPUDebug *wCPU, CIO *wIO, bool wTrigInput, bool mTrigOutput, unsigned wMaxLen) :
|
|
CWatch(wCPU, wIO, 'C', "capture", wTrigInput, mTrigOutput), m_maxLen(min<unsigned>(255, wMaxLen)), m_len(0), m_index(0)
|
|
{
|
|
//
|
|
}
|
|
|
|
bool CCaptureWatch::CheckBreak(bool isRead, UINT64 data)
|
|
{
|
|
if (m_len < m_maxLen)
|
|
{
|
|
m_dataVals[m_len] = data;
|
|
m_dataRW[m_len] = isRead;
|
|
m_len++;
|
|
m_index = 0;
|
|
}
|
|
else
|
|
{
|
|
m_dataVals[m_index] = data;
|
|
m_dataRW[m_index] = isRead;
|
|
m_index++;
|
|
if (m_index >= m_maxLen)
|
|
m_index = 0;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void CCaptureWatch::Reset()
|
|
{
|
|
m_len = 0;
|
|
m_index = 0;
|
|
}
|
|
|
|
bool CCaptureWatch::GetInfo(char *str)
|
|
{
|
|
char dataStr[25];
|
|
unsigned ind, len;
|
|
str[0] = '\0';
|
|
if (m_len == 0)
|
|
return true;
|
|
else if (m_len < m_maxLen)
|
|
{
|
|
ind = m_len - 1;
|
|
len = m_len;
|
|
}
|
|
else
|
|
{
|
|
if (m_index == 0)
|
|
ind = m_maxLen - 1;
|
|
else
|
|
ind = m_index - 1;
|
|
len = m_maxLen;
|
|
}
|
|
for (unsigned i = 0; i < len; i++)
|
|
{
|
|
UINT64 data = m_dataVals[ind];
|
|
bool isRead = m_dataRW[ind];
|
|
cpu->FormatData(dataStr, size, data);
|
|
if (i > 0)
|
|
strcat(str, " ");
|
|
strcat(str, (isRead ? "<" : ">"));
|
|
strcat(str, dataStr);
|
|
if (ind == 0)
|
|
ind = m_maxLen - 1;
|
|
else
|
|
ind--;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
CPrintWatch::CPrintWatch(CCPUDebug *wCPU, UINT32 wAddr, unsigned wSize, bool wTrigRead, bool wTrigWrite) :
|
|
CWatch(wCPU, wAddr, wSize, 'P', "print", wTrigRead, wTrigWrite)
|
|
{
|
|
//
|
|
}
|
|
|
|
CPrintWatch::CPrintWatch(CCPUDebug *wCPU, CIO *io, bool wTrigInput, bool mTrigOutput) :
|
|
CWatch(wCPU, io, 'P', "print", wTrigInput, mTrigOutput)
|
|
{
|
|
//
|
|
}
|
|
|
|
bool CPrintWatch::CheckBreak(bool isRead, UINT64 data)
|
|
{
|
|
const char *sizeStr = CDebugger::GetSizeString(size);
|
|
const char *rwStr = (isRead ? "Read" : "Wrote");
|
|
const char *tfStr = (isRead ? "from" : "to");
|
|
char dataStr[50];
|
|
char addrStr[50];
|
|
char locStr[50];
|
|
cpu->FormatData(dataStr, size, data);
|
|
cpu->FormatAddress(addrStr, addr, true);
|
|
if (io != NULL)
|
|
{
|
|
io->GetLocation(locStr);
|
|
cpu->debugger->PrintEvent(cpu, "%s %s data (%s) %s I/O %s.\n", rwStr, sizeStr, dataStr, tfStr, locStr);
|
|
}
|
|
else
|
|
cpu->debugger->PrintEvent(cpu, "%s %s data (%s) %s memory %s.\n", rwStr, sizeStr, dataStr, tfStr, addrStr);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
#endif // SUPERMODEL_DEBUGGER
|