mirror of
https://github.com/dolphin-emu/dolphin.git
synced 2025-01-11 00:29:11 +01:00
7cecb28bdf
This fixes a problem I was having where using frame advance with the debugger open would frequently cause panic alerts about invalid addresses due to the CPU thread changing MSR.DR while the host thread was trying to access memory. To aid in tracking down all the places where we weren't properly locking the CPU, I've created a new type (in Core.h) that you have to pass as a reference or pointer to functions that require running as the CPU thread.
546 lines
16 KiB
C++
546 lines
16 KiB
C++
// Copyright 2017 Dolphin Emulator Project
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
#include "DolphinQt/Debugger/WatchWidget.h"
|
|
|
|
#include <QHeaderView>
|
|
#include <QInputDialog>
|
|
#include <QMenu>
|
|
#include <QTableWidget>
|
|
#include <QToolBar>
|
|
#include <QVBoxLayout>
|
|
|
|
#include "Common/FileUtil.h"
|
|
#include "Common/IniFile.h"
|
|
#include "Core/ConfigManager.h"
|
|
#include "Core/Core.h"
|
|
#include "Core/PowerPC/MMU.h"
|
|
#include "Core/PowerPC/PowerPC.h"
|
|
|
|
#include "DolphinQt/Host.h"
|
|
#include "DolphinQt/QtUtils/ModalMessageBox.h"
|
|
#include "DolphinQt/Resources.h"
|
|
#include "DolphinQt/Settings.h"
|
|
|
|
WatchWidget::WatchWidget(QWidget* parent) : QDockWidget(parent)
|
|
{
|
|
// i18n: This kind of "watch" is used for watching emulated memory.
|
|
// It's not related to timekeeping devices.
|
|
setWindowTitle(tr("Watch"));
|
|
setObjectName(QStringLiteral("watch"));
|
|
|
|
setHidden(!Settings::Instance().IsWatchVisible() || !Settings::Instance().IsDebugModeEnabled());
|
|
|
|
setAllowedAreas(Qt::AllDockWidgetAreas);
|
|
|
|
CreateWidgets();
|
|
|
|
auto& settings = Settings::GetQSettings();
|
|
|
|
restoreGeometry(settings.value(QStringLiteral("watchwidget/geometry")).toByteArray());
|
|
// macOS: setHidden() needs to be evaluated before setFloating() for proper window presentation
|
|
// according to Settings
|
|
setFloating(settings.value(QStringLiteral("watchwidget/floating")).toBool());
|
|
|
|
ConnectWidgets();
|
|
|
|
connect(&Settings::Instance(), &Settings::EmulationStateChanged, this, [this](Core::State state) {
|
|
UpdateButtonsEnabled();
|
|
if (state != Core::State::Starting)
|
|
Update();
|
|
});
|
|
|
|
connect(Host::GetInstance(), &Host::UpdateDisasmDialog, this, &WatchWidget::Update);
|
|
|
|
connect(&Settings::Instance(), &Settings::WatchVisibilityChanged, this,
|
|
[this](bool visible) { setHidden(!visible); });
|
|
|
|
connect(&Settings::Instance(), &Settings::DebugModeToggled, this,
|
|
[this](bool enabled) { setHidden(!enabled || !Settings::Instance().IsWatchVisible()); });
|
|
|
|
connect(&Settings::Instance(), &Settings::ThemeChanged, this, &WatchWidget::UpdateIcons);
|
|
UpdateIcons();
|
|
}
|
|
|
|
WatchWidget::~WatchWidget()
|
|
{
|
|
auto& settings = Settings::GetQSettings();
|
|
|
|
settings.setValue(QStringLiteral("watchwidget/geometry"), saveGeometry());
|
|
settings.setValue(QStringLiteral("watchwidget/floating"), isFloating());
|
|
}
|
|
|
|
void WatchWidget::CreateWidgets()
|
|
{
|
|
m_toolbar = new QToolBar;
|
|
m_toolbar->setContentsMargins(0, 0, 0, 0);
|
|
m_toolbar->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
|
|
|
|
m_table = new QTableWidget;
|
|
m_table->setTabKeyNavigation(false);
|
|
|
|
m_table->setContentsMargins(0, 0, 0, 0);
|
|
m_table->setColumnCount(NUM_COLUMNS);
|
|
m_table->verticalHeader()->setHidden(true);
|
|
m_table->setContextMenuPolicy(Qt::CustomContextMenu);
|
|
m_table->setSelectionMode(QAbstractItemView::ExtendedSelection);
|
|
m_table->setSelectionBehavior(QAbstractItemView::SelectRows);
|
|
|
|
m_new = m_toolbar->addAction(tr("New"), this, &WatchWidget::OnNewWatch);
|
|
m_delete = m_toolbar->addAction(tr("Delete"), this, &WatchWidget::OnDelete);
|
|
m_clear = m_toolbar->addAction(tr("Clear"), this, &WatchWidget::OnClear);
|
|
m_load = m_toolbar->addAction(tr("Load"), this, &WatchWidget::OnLoad);
|
|
m_save = m_toolbar->addAction(tr("Save"), this, &WatchWidget::OnSave);
|
|
|
|
m_new->setEnabled(false);
|
|
m_delete->setEnabled(false);
|
|
m_clear->setEnabled(false);
|
|
m_load->setEnabled(false);
|
|
m_save->setEnabled(false);
|
|
|
|
auto* layout = new QVBoxLayout;
|
|
layout->setContentsMargins(2, 2, 2, 2);
|
|
layout->setSpacing(0);
|
|
layout->addWidget(m_toolbar);
|
|
layout->addWidget(m_table);
|
|
|
|
QWidget* widget = new QWidget;
|
|
widget->setLayout(layout);
|
|
|
|
setWidget(widget);
|
|
}
|
|
|
|
void WatchWidget::ConnectWidgets()
|
|
{
|
|
connect(m_table, &QTableWidget::customContextMenuRequested, this, &WatchWidget::ShowContextMenu);
|
|
connect(m_table, &QTableWidget::itemChanged, this, &WatchWidget::OnItemChanged);
|
|
}
|
|
|
|
void WatchWidget::UpdateIcons()
|
|
{
|
|
// TODO: Create a "debugger_add_watch" icon
|
|
m_new->setIcon(Resources::GetScaledThemeIcon("debugger_add_breakpoint"));
|
|
m_delete->setIcon(Resources::GetScaledThemeIcon("debugger_delete"));
|
|
m_clear->setIcon(Resources::GetScaledThemeIcon("debugger_clear"));
|
|
m_load->setIcon(Resources::GetScaledThemeIcon("debugger_load"));
|
|
m_save->setIcon(Resources::GetScaledThemeIcon("debugger_save"));
|
|
}
|
|
|
|
void WatchWidget::UpdateButtonsEnabled()
|
|
{
|
|
if (!isVisible())
|
|
return;
|
|
|
|
const bool is_enabled = Core::IsRunning();
|
|
m_new->setEnabled(is_enabled);
|
|
m_delete->setEnabled(is_enabled);
|
|
m_clear->setEnabled(is_enabled);
|
|
m_load->setEnabled(is_enabled);
|
|
m_save->setEnabled(is_enabled);
|
|
}
|
|
|
|
void WatchWidget::Update()
|
|
{
|
|
if (!isVisible())
|
|
return;
|
|
|
|
m_updating = true;
|
|
|
|
m_table->clear();
|
|
|
|
int size = static_cast<int>(PowerPC::debug_interface.GetWatches().size());
|
|
|
|
m_table->setRowCount(size + 1);
|
|
|
|
m_table->setHorizontalHeaderLabels(
|
|
{tr("Label"), tr("Address"), tr("Hexadecimal"),
|
|
// i18n: The base 10 numeral system. Not related to non-integer numbers
|
|
tr("Decimal"),
|
|
// i18n: Data type used in computing
|
|
tr("String"),
|
|
// i18n: Floating-point (non-integer) number
|
|
tr("Float"), tr("Locked")});
|
|
|
|
Core::CPUThreadGuard guard;
|
|
|
|
for (int i = 0; i < size; i++)
|
|
{
|
|
const auto& entry = PowerPC::debug_interface.GetWatch(i);
|
|
|
|
auto* label = new QTableWidgetItem(QString::fromStdString(entry.name));
|
|
auto* address =
|
|
new QTableWidgetItem(QStringLiteral("%1").arg(entry.address, 8, 16, QLatin1Char('0')));
|
|
auto* hex = new QTableWidgetItem;
|
|
auto* decimal = new QTableWidgetItem;
|
|
auto* string = new QTableWidgetItem;
|
|
auto* floatValue = new QTableWidgetItem;
|
|
|
|
auto* lockValue = new QTableWidgetItem;
|
|
lockValue->setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsUserCheckable);
|
|
|
|
std::array<QTableWidgetItem*, NUM_COLUMNS> items = {label, address, hex, decimal,
|
|
string, floatValue, lockValue};
|
|
|
|
QBrush brush = QPalette().brush(QPalette::Text);
|
|
|
|
if (!Core::IsRunning() || !PowerPC::HostIsRAMAddress(guard, entry.address))
|
|
brush.setColor(Qt::red);
|
|
|
|
if (Core::IsRunning())
|
|
{
|
|
if (PowerPC::HostIsRAMAddress(guard, entry.address))
|
|
{
|
|
hex->setText(QStringLiteral("%1").arg(PowerPC::HostRead_U32(guard, entry.address), 8, 16,
|
|
QLatin1Char('0')));
|
|
decimal->setText(QString::number(PowerPC::HostRead_U32(guard, entry.address)));
|
|
string->setText(QString::fromStdString(PowerPC::HostGetString(guard, entry.address, 32)));
|
|
floatValue->setText(QString::number(PowerPC::HostRead_F32(guard, entry.address)));
|
|
lockValue->setCheckState(entry.locked ? Qt::Checked : Qt::Unchecked);
|
|
}
|
|
}
|
|
|
|
address->setForeground(brush);
|
|
string->setFlags(Qt::ItemIsEnabled);
|
|
|
|
for (int column = 0; column < NUM_COLUMNS; column++)
|
|
{
|
|
auto* item = items[column];
|
|
item->setData(Qt::UserRole, i);
|
|
item->setData(Qt::UserRole + 1, column);
|
|
m_table->setItem(i, column, item);
|
|
}
|
|
}
|
|
|
|
auto* label = new QTableWidgetItem;
|
|
label->setData(Qt::UserRole, -1);
|
|
|
|
m_table->setItem(size, 0, label);
|
|
|
|
for (int i = 1; i < NUM_COLUMNS; i++)
|
|
{
|
|
auto* no_edit = new QTableWidgetItem;
|
|
no_edit->setFlags(Qt::ItemIsEnabled);
|
|
m_table->setItem(size, i, no_edit);
|
|
}
|
|
|
|
m_updating = false;
|
|
}
|
|
|
|
void WatchWidget::closeEvent(QCloseEvent*)
|
|
{
|
|
Settings::Instance().SetWatchVisible(false);
|
|
}
|
|
|
|
void WatchWidget::showEvent(QShowEvent* event)
|
|
{
|
|
UpdateButtonsEnabled();
|
|
Update();
|
|
}
|
|
|
|
void WatchWidget::OnDelete()
|
|
{
|
|
if (m_table->selectedItems().empty())
|
|
return;
|
|
|
|
DeleteSelectedWatches();
|
|
}
|
|
|
|
void WatchWidget::OnClear()
|
|
{
|
|
PowerPC::debug_interface.ClearWatches();
|
|
Update();
|
|
}
|
|
|
|
void WatchWidget::OnNewWatch()
|
|
{
|
|
const QString text =
|
|
QInputDialog::getText(this, tr("Input"), tr("Enter address to watch:"), QLineEdit::Normal,
|
|
QString{}, nullptr, Qt::WindowCloseButtonHint);
|
|
bool good;
|
|
const uint address = text.toUInt(&good, 16);
|
|
|
|
if (!good)
|
|
{
|
|
ModalMessageBox::warning(this, tr("Error"), tr("Invalid watch address: %1").arg(text));
|
|
return;
|
|
}
|
|
|
|
const QString name = QStringLiteral("mem_%1").arg(address, 8, 16, QLatin1Char('0'));
|
|
AddWatch(name, address);
|
|
}
|
|
|
|
void WatchWidget::OnLoad()
|
|
{
|
|
IniFile ini;
|
|
|
|
std::vector<std::string> watches;
|
|
|
|
if (!ini.Load(File::GetUserPath(D_GAMESETTINGS_IDX) + SConfig::GetInstance().GetGameID() + ".ini",
|
|
false))
|
|
{
|
|
return;
|
|
}
|
|
|
|
Core::CPUThreadGuard guard;
|
|
|
|
if (ini.GetLines("Watches", &watches, false))
|
|
{
|
|
for (const auto& watch : PowerPC::debug_interface.GetWatches())
|
|
{
|
|
PowerPC::debug_interface.UnsetPatch(guard, watch.address);
|
|
}
|
|
PowerPC::debug_interface.ClearWatches();
|
|
PowerPC::debug_interface.LoadWatchesFromStrings(watches);
|
|
}
|
|
|
|
Update();
|
|
}
|
|
|
|
void WatchWidget::OnSave()
|
|
{
|
|
IniFile ini;
|
|
ini.Load(File::GetUserPath(D_GAMESETTINGS_IDX) + SConfig::GetInstance().GetGameID() + ".ini",
|
|
false);
|
|
ini.SetLines("Watches", PowerPC::debug_interface.SaveWatchesToStrings());
|
|
ini.Save(File::GetUserPath(D_GAMESETTINGS_IDX) + SConfig::GetInstance().GetGameID() + ".ini");
|
|
}
|
|
|
|
void WatchWidget::ShowContextMenu()
|
|
{
|
|
QMenu* menu = new QMenu(this);
|
|
|
|
if (!m_table->selectedItems().empty())
|
|
{
|
|
const std::size_t count = m_table->selectionModel()->selectedRows().count();
|
|
if (count > 1)
|
|
{
|
|
// i18n: This kind of "watch" is used for watching emulated memory.
|
|
// It's not related to timekeeping devices.
|
|
menu->addAction(tr("&Delete Watches"), this, [this] { DeleteSelectedWatches(); });
|
|
// i18n: This kind of "watch" is used for watching emulated memory.
|
|
// It's not related to timekeeping devices.
|
|
menu->addAction(tr("&Lock Watches"), this, [this] { LockSelectedWatches(); });
|
|
// i18n: This kind of "watch" is used for watching emulated memory.
|
|
// It's not related to timekeeping devices.
|
|
menu->addAction(tr("&Unlock Watches"), this, [this] { UnlockSelectedWatches(); });
|
|
}
|
|
else if (count == 1)
|
|
{
|
|
auto row_variant = m_table->selectedItems()[0]->data(Qt::UserRole);
|
|
|
|
if (!row_variant.isNull())
|
|
{
|
|
int row = row_variant.toInt();
|
|
|
|
if (row >= 0)
|
|
{
|
|
menu->addAction(tr("Show in Memory"), this, [this, row] { ShowInMemory(row); });
|
|
// i18n: This kind of "watch" is used for watching emulated memory.
|
|
// It's not related to timekeeping devices.
|
|
menu->addAction(tr("&Delete Watch"), this, [this, row] { DeleteWatchAndUpdate(row); });
|
|
menu->addAction(tr("&Add Memory Breakpoint"), this,
|
|
[this, row] { AddWatchBreakpoint(row); });
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
menu->addSeparator();
|
|
|
|
menu->addAction(tr("Update"), this, &WatchWidget::Update);
|
|
|
|
menu->exec(QCursor::pos());
|
|
}
|
|
|
|
void WatchWidget::OnItemChanged(QTableWidgetItem* item)
|
|
{
|
|
if (m_updating || item->data(Qt::UserRole).isNull())
|
|
return;
|
|
|
|
int row = item->data(Qt::UserRole).toInt();
|
|
int column = item->data(Qt::UserRole + 1).toInt();
|
|
|
|
if (row == -1)
|
|
{
|
|
if (!item->text().isEmpty())
|
|
{
|
|
AddWatch(item->text(), 0);
|
|
|
|
Update();
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch (column)
|
|
{
|
|
case COLUMN_INDEX_LABEL:
|
|
if (item->text().isEmpty())
|
|
DeleteWatchAndUpdate(row);
|
|
else
|
|
PowerPC::debug_interface.UpdateWatchName(row, item->text().toStdString());
|
|
break;
|
|
case COLUMN_INDEX_ADDRESS:
|
|
case COLUMN_INDEX_HEX:
|
|
case COLUMN_INDEX_DECIMAL:
|
|
{
|
|
bool good;
|
|
const bool column_uses_hex_formatting =
|
|
column == COLUMN_INDEX_ADDRESS || column == COLUMN_INDEX_HEX;
|
|
quint32 value = item->text().toUInt(&good, column_uses_hex_formatting ? 16 : 10);
|
|
|
|
if (good)
|
|
{
|
|
Core::CPUThreadGuard guard;
|
|
|
|
if (column == COLUMN_INDEX_ADDRESS)
|
|
{
|
|
const auto& watch = PowerPC::debug_interface.GetWatch(row);
|
|
PowerPC::debug_interface.UnsetPatch(guard, watch.address);
|
|
PowerPC::debug_interface.UpdateWatchAddress(row, value);
|
|
if (watch.locked)
|
|
LockWatchAddress(guard, value);
|
|
}
|
|
else
|
|
{
|
|
PowerPC::HostWrite_U32(guard, value, PowerPC::debug_interface.GetWatch(row).address);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ModalMessageBox::critical(this, tr("Error"), tr("Invalid input provided"));
|
|
}
|
|
break;
|
|
}
|
|
case COLUMN_INDEX_LOCK:
|
|
{
|
|
PowerPC::debug_interface.UpdateWatchLockedState(row, item->checkState() == Qt::Checked);
|
|
const auto& watch = PowerPC::debug_interface.GetWatch(row);
|
|
Core::CPUThreadGuard guard;
|
|
if (watch.locked)
|
|
LockWatchAddress(guard, watch.address);
|
|
else
|
|
PowerPC::debug_interface.UnsetPatch(guard, watch.address);
|
|
break;
|
|
}
|
|
}
|
|
|
|
Update();
|
|
}
|
|
}
|
|
|
|
void WatchWidget::LockWatchAddress(const Core::CPUThreadGuard& guard, u32 address)
|
|
{
|
|
const std::string memory_data_as_string = PowerPC::HostGetString(guard, address, 4);
|
|
|
|
std::vector<u8> bytes;
|
|
for (const char c : memory_data_as_string)
|
|
{
|
|
bytes.push_back(static_cast<u8>(c));
|
|
}
|
|
|
|
PowerPC::debug_interface.SetFramePatch(guard, address, bytes);
|
|
}
|
|
|
|
void WatchWidget::DeleteSelectedWatches()
|
|
{
|
|
{
|
|
Core::CPUThreadGuard guard;
|
|
std::vector<int> row_indices;
|
|
for (const auto& index : m_table->selectionModel()->selectedRows())
|
|
{
|
|
const auto* item = m_table->item(index.row(), index.column());
|
|
const auto row_variant = item->data(Qt::UserRole);
|
|
if (row_variant.isNull())
|
|
continue;
|
|
|
|
row_indices.push_back(row_variant.toInt());
|
|
}
|
|
|
|
// Sort greatest to smallest, so we don't stomp on existing indices
|
|
std::sort(row_indices.begin(), row_indices.end(), std::greater{});
|
|
for (const int row : row_indices)
|
|
{
|
|
DeleteWatch(guard, row);
|
|
}
|
|
}
|
|
|
|
Update();
|
|
}
|
|
|
|
void WatchWidget::DeleteWatch(const Core::CPUThreadGuard& guard, int row)
|
|
{
|
|
PowerPC::debug_interface.UnsetPatch(guard, PowerPC::debug_interface.GetWatch(row).address);
|
|
PowerPC::debug_interface.RemoveWatch(row);
|
|
}
|
|
|
|
void WatchWidget::DeleteWatchAndUpdate(int row)
|
|
{
|
|
{
|
|
Core::CPUThreadGuard guard;
|
|
DeleteWatch(guard, row);
|
|
}
|
|
|
|
Update();
|
|
}
|
|
|
|
void WatchWidget::AddWatchBreakpoint(int row)
|
|
{
|
|
emit RequestMemoryBreakpoint(PowerPC::debug_interface.GetWatch(row).address);
|
|
}
|
|
|
|
void WatchWidget::ShowInMemory(int row)
|
|
{
|
|
emit ShowMemory(PowerPC::debug_interface.GetWatch(row).address);
|
|
}
|
|
|
|
void WatchWidget::AddWatch(QString name, u32 addr)
|
|
{
|
|
PowerPC::debug_interface.SetWatch(addr, name.toStdString());
|
|
Update();
|
|
}
|
|
|
|
void WatchWidget::LockSelectedWatches()
|
|
{
|
|
{
|
|
Core::CPUThreadGuard guard;
|
|
for (const auto& index : m_table->selectionModel()->selectedRows())
|
|
{
|
|
const auto* item = m_table->item(index.row(), index.column());
|
|
const auto row_variant = item->data(Qt::UserRole);
|
|
if (row_variant.isNull())
|
|
continue;
|
|
const int row = row_variant.toInt();
|
|
const auto& watch = PowerPC::debug_interface.GetWatch(row);
|
|
if (watch.locked)
|
|
continue;
|
|
PowerPC::debug_interface.UpdateWatchLockedState(row, true);
|
|
LockWatchAddress(guard, watch.address);
|
|
}
|
|
}
|
|
|
|
Update();
|
|
}
|
|
|
|
void WatchWidget::UnlockSelectedWatches()
|
|
{
|
|
{
|
|
Core::CPUThreadGuard guard;
|
|
for (const auto& index : m_table->selectionModel()->selectedRows())
|
|
{
|
|
const auto* item = m_table->item(index.row(), index.column());
|
|
const auto row_variant = item->data(Qt::UserRole);
|
|
if (row_variant.isNull())
|
|
continue;
|
|
const int row = row_variant.toInt();
|
|
const auto& watch = PowerPC::debug_interface.GetWatch(row);
|
|
if (!watch.locked)
|
|
continue;
|
|
PowerPC::debug_interface.UpdateWatchLockedState(row, false);
|
|
PowerPC::debug_interface.UnsetPatch(guard, watch.address);
|
|
}
|
|
}
|
|
|
|
Update();
|
|
}
|