Merge pull request #8732 from dreamsyntax/debugger-function-differencing

Qt/Debugger CodeWidget: Record and find specific functions by differencing

1 files changed, 517 insertions, 0 deletions

diff --git a/Source/Core/DolphinQt/Debugger/CodeDiffDialog.cpp b/Source/Core/DolphinQt/Debugger/CodeDiffDialog.cpp
new file mode 100644
index 0000000000..bb2fc03c1b
--- /dev/null
+++ b/Source/Core/DolphinQt/Debugger/CodeDiffDialog.cpp
@@ -0,0 +1,517 @@
+// Copyright 2022 Dolphin Emulator Project

+// SPDX-License-Identifier: GPL-2.0-or-later

+

+#include "DolphinQt/Debugger/CodeDiffDialog.h"

+

+#include <algorithm>

+#include <string>

+#include <vector>

+

+#include <QHBoxLayout>

+#include <QLabel>

+#include <QMenu>

+#include <QPushButton>

+#include <QTableWidget>

+#include <QVBoxLayout>

+

+#include "Common/StringUtil.h"

+#include "Core/Core.h"

+#include "Core/Debugger/PPCDebugInterface.h"

+#include "Core/HW/CPU.h"

+#include "Core/PowerPC/JitInterface.h"

+#include "Core/PowerPC/MMU.h"

+#include "Core/PowerPC/PPCSymbolDB.h"

+#include "Core/PowerPC/PowerPC.h"

+#include "Core/PowerPC/Profiler.h"

+

+#include "DolphinQt/Debugger/CodeWidget.h"

+#include "DolphinQt/Host.h"

+#include "DolphinQt/QtUtils/ModalMessageBox.h"

+#include "DolphinQt/Settings.h"

+

+CodeDiffDialog::CodeDiffDialog(CodeWidget* parent) : QDialog(parent), m_code_widget(parent)

+{

+  setWindowTitle(tr("Code Diff Tool"));

+  CreateWidgets();

+  auto& settings = Settings::GetQSettings();

+  restoreGeometry(settings.value(QStringLiteral("diffdialog/geometry")).toByteArray());

+  ConnectWidgets();

+}

+

+void CodeDiffDialog::reject()

+{

+  ClearData();

+  auto& settings = Settings::GetQSettings();

+  settings.setValue(QStringLiteral("diffdialog/geometry"), saveGeometry());

+  QDialog::reject();

+}

+

+void CodeDiffDialog::CreateWidgets()

+{

+  auto* btns_layout = new QGridLayout;

+  m_exclude_btn = new QPushButton(tr("Code did not get executed"));

+  m_include_btn = new QPushButton(tr("Code has been executed"));

+  m_record_btn = new QPushButton(tr("Start Recording"));

+  m_record_btn->setCheckable(true);

+  m_record_btn->setStyleSheet(

+      QStringLiteral("QPushButton:checked { background-color: rgb(150, 0, 0); border-style: solid; "

+                     "border-width: 3px; border-color: rgb(150,0,0); color: rgb(255, 255, 255);}"));

+

+  m_exclude_btn->setEnabled(false);

+  m_include_btn->setEnabled(false);

+

+  btns_layout->addWidget(m_exclude_btn, 0, 0);

+  btns_layout->addWidget(m_include_btn, 0, 1);

+  btns_layout->addWidget(m_record_btn, 0, 2);

+

+  auto* labels_layout = new QHBoxLayout;

+  m_exclude_size_label = new QLabel(tr("Excluded: 0"));

+  m_include_size_label = new QLabel(tr("Included: 0"));

+

+  btns_layout->addWidget(m_exclude_size_label, 1, 0);

+  btns_layout->addWidget(m_include_size_label, 1, 1);

+

+  m_matching_results_table = new QTableWidget();

+  m_matching_results_table->setColumnCount(5);

+  m_matching_results_table->setHorizontalHeaderLabels(

+      {tr("Address"), tr("Total Hits"), tr("Hits"), tr("Symbol"), tr("Inspected")});

+  m_matching_results_table->setSelectionMode(QAbstractItemView::SingleSelection);

+  m_matching_results_table->setSelectionBehavior(QAbstractItemView::SelectRows);

+  m_matching_results_table->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);

+  m_matching_results_table->setContextMenuPolicy(Qt::CustomContextMenu);

+  m_matching_results_table->setColumnWidth(0, 60);

+  m_matching_results_table->setColumnWidth(1, 60);

+  m_matching_results_table->setColumnWidth(2, 4);

+  m_matching_results_table->setColumnWidth(3, 210);

+  m_matching_results_table->setColumnWidth(4, 65);

+  m_reset_btn = new QPushButton(tr("Reset All"));

+  m_reset_btn->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);

+  m_help_btn = new QPushButton(tr("Help"));

+  m_help_btn->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);

+  auto* help_reset_layout = new QHBoxLayout;

+  help_reset_layout->addWidget(m_reset_btn, 0, Qt::AlignLeft);

+  help_reset_layout->addWidget(m_help_btn, 0, Qt::AlignRight);

+

+  auto* layout = new QVBoxLayout();

+  layout->addLayout(btns_layout);

+  layout->addLayout(labels_layout);

+  layout->addWidget(m_matching_results_table);

+  layout->addLayout(help_reset_layout);

+

+  setLayout(layout);

+  resize(515, 400);

+}

+

+void CodeDiffDialog::ConnectWidgets()

+{

+  connect(m_record_btn, &QPushButton::toggled, this, &CodeDiffDialog::OnRecord);

+  connect(m_include_btn, &QPushButton::pressed, [this]() { Update(true); });

+  connect(m_exclude_btn, &QPushButton::pressed, [this]() { Update(false); });

+  connect(m_matching_results_table, &QTableWidget::itemClicked, [this]() { OnClickItem(); });

+  connect(m_reset_btn, &QPushButton::pressed, this, &CodeDiffDialog::ClearData);

+  connect(m_help_btn, &QPushButton::pressed, this, &CodeDiffDialog::InfoDisp);

+  connect(m_matching_results_table, &CodeDiffDialog::customContextMenuRequested, this,

+          &CodeDiffDialog::OnContextMenu);

+}

+

+void CodeDiffDialog::OnClickItem()

+{

+  UpdateItem();

+  auto address = m_matching_results_table->currentItem()->data(Qt::UserRole).toUInt();

+  m_code_widget->SetAddress(address, CodeViewWidget::SetAddressUpdate::WithDetailedUpdate);

+}

+

+void CodeDiffDialog::ClearData()

+{

+  if (m_record_btn->isChecked())

+    m_record_btn->toggle();

+  ClearBlockCache();

+  m_matching_results_table->clear();

+  m_matching_results_table->setRowCount(0);

+  m_matching_results_table->setHorizontalHeaderLabels(

+      {tr("Address"), tr("Total Hits"), tr("Hits"), tr("Symbol"), tr("Inspected")});

+  m_matching_results_table->setEditTriggers(QAbstractItemView::EditTrigger::NoEditTriggers);

+  m_exclude_size_label->setText(tr("Excluded: %1").arg(0));

+  m_include_size_label->setText(tr("Included: %1").arg(0));

+  m_exclude_btn->setEnabled(false);

+  m_include_btn->setEnabled(false);

+  m_include_active = false;

+  // Swap is used instead of clear for efficiency in the case of huge m_include/m_exclude

+  std::vector<Diff>().swap(m_include);

+  std::vector<Diff>().swap(m_exclude);

+  JitInterface::SetProfilingState(JitInterface::ProfilingState::Disabled);

+}

+

+void CodeDiffDialog::ClearBlockCache()

+{

+  Core::State old_state = Core::GetState();

+

+  if (old_state == Core::State::Running)

+    Core::SetState(Core::State::Paused);

+

+  JitInterface::ClearCache();

+

+  if (old_state == Core::State::Running)

+    Core::SetState(Core::State::Running);

+}

+

+void CodeDiffDialog::OnRecord(bool enabled)

+{

+  if (m_failed_requirements)

+  {

+    m_failed_requirements = false;

+    return;

+  }

+

+  if (Core::GetState() == Core::State::Uninitialized)

+  {

+    ModalMessageBox::information(this, tr("Code Diff Tool"),

+                                 tr("Emulation must be started to record."));

+    m_failed_requirements = true;

+    m_record_btn->setChecked(false);

+    return;

+  }

+

+  if (g_symbolDB.IsEmpty())

+  {

+    ModalMessageBox::warning(

+        this, tr("Code Diff Tool"),

+        tr("Symbol map not found.\n\nIf one does not exist, you can generate one from "

+           "the Menu bar:\nSymbols -> Generate Symbols From ->\n\tAddress | Signature "

+           "Database | RSO Modules"));

+    m_failed_requirements = true;

+    m_record_btn->setChecked(false);

+    return;

+  }

+

+  JitInterface::ProfilingState state;

+

+  if (enabled)

+  {

+    ClearBlockCache();

+    m_record_btn->setText(tr("Stop Recording"));

+    state = JitInterface::ProfilingState::Enabled;

+    m_exclude_btn->setEnabled(true);

+    m_include_btn->setEnabled(true);

+  }

+  else

+  {

+    ClearBlockCache();

+    m_record_btn->setText(tr("Start Recording"));

+    state = JitInterface::ProfilingState::Disabled;

+    m_exclude_btn->setEnabled(false);

+    m_include_btn->setEnabled(false);

+  }

+

+  m_record_btn->update();

+  JitInterface::SetProfilingState(state);

+}

+

+void CodeDiffDialog::OnInclude()

+{

+  const auto recorded_symbols = CalculateSymbolsFromProfile();

+

+  if (recorded_symbols.empty())

+    return;

+

+  if (m_include.empty() && m_exclude.empty())

+  {

+    m_include = recorded_symbols;

+    m_include_active = true;

+  }

+  else if (m_include.empty())

+  {

+    // If include becomes empty after having items on it, don't refill it until after a reset.

+    if (m_include_active)

+      return;

+

+    // If we are building include for the first time and we have an exlcude list, then include =

+    // recorded - excluded.

+    m_include = recorded_symbols;

+    RemoveMatchingSymbolsFromIncludes(m_exclude);

+    m_include_active = true;

+  }

+  else

+  {

+    // If include already exists, keep items that are in both include and recorded. Exclude list

+    // becomes irrelevant.

+    RemoveMissingSymbolsFromIncludes(recorded_symbols);

+  }

+}

+

+void CodeDiffDialog::OnExclude()

+{

+  const auto recorded_symbols = CalculateSymbolsFromProfile();

+  if (m_include.empty() && m_exclude.empty())

+  {

+    m_exclude = recorded_symbols;

+  }

+  else if (m_include.empty())

+  {

+    // If there is only an exclude list, update it.

+    for (auto& iter : recorded_symbols)

+    {

+      auto pos = std::lower_bound(m_exclude.begin(), m_exclude.end(), iter.symbol);

+

+      if (pos == m_exclude.end() || pos->symbol != iter.symbol)

+        m_exclude.insert(pos, iter);

+    }

+  }

+  else

+  {

+    // If include already exists, the exclude list will have been used to trim it, so the exclude

+    // list is now irrelevant, as anythng not on the include list is effectively excluded.

+    // Exclude/subtract recorded items from the include list.

+    RemoveMatchingSymbolsFromIncludes(recorded_symbols);

+  }

+}

+

+std::vector<Diff> CodeDiffDialog::CalculateSymbolsFromProfile()

+{

+  Profiler::ProfileStats prof_stats;

+  auto& blockstats = prof_stats.block_stats;

+  JitInterface::GetProfileResults(&prof_stats);

+  std::vector<Diff> current;

+  current.reserve(20000);

+

+  // Convert blockstats to smaller struct Diff. Exclude repeat functions via symbols.

+  for (auto& iter : blockstats)

+  {

+    Diff tmp_diff;

+    std::string symbol = g_symbolDB.GetDescription(iter.addr);

+    if (!std::any_of(current.begin(), current.end(),

+                     [&symbol](Diff& v) { return v.symbol == symbol; }))

+    {

+      tmp_diff.symbol = symbol;

+      tmp_diff.addr = iter.addr;

+      tmp_diff.hits = iter.run_count;

+      tmp_diff.total_hits = iter.run_count;

+      current.push_back(tmp_diff);

+    }

+  }

+

+  sort(current.begin(), current.end(),

+       [](const Diff& v1, const Diff& v2) { return (v1.symbol < v2.symbol); });

+

+  return current;

+}

+

+void CodeDiffDialog::RemoveMissingSymbolsFromIncludes(const std::vector<Diff>& symbol_diff)

+{

+  m_include.erase(std::remove_if(m_include.begin(), m_include.end(),

+                                 [&](const Diff& v) {

+                                   auto arg = std::none_of(

+                                       symbol_diff.begin(), symbol_diff.end(), [&](const Diff& p) {

+                                         return p.symbol == v.symbol || p.addr == v.addr;

+                                       });

+                                   return arg;

+                                 }),

+                  m_include.end());

+  for (auto& original_includes : m_include)

+  {

+    auto pos = std::lower_bound(symbol_diff.begin(), symbol_diff.end(), original_includes.symbol);

+    if (pos != symbol_diff.end() &&

+        (pos->symbol == original_includes.symbol || pos->addr == original_includes.addr))

+    {

+      original_includes.total_hits += pos->hits;

+      original_includes.hits = pos->hits;

+    }

+  }

+}

+

+void CodeDiffDialog::RemoveMatchingSymbolsFromIncludes(const std::vector<Diff>& symbol_list)

+{

+  m_include.erase(std::remove_if(m_include.begin(), m_include.end(),

+                                 [&](const Diff& i) {

+                                   return std::any_of(

+                                       symbol_list.begin(), symbol_list.end(), [&](const Diff& s) {

+                                         return i.symbol == s.symbol || i.addr == s.addr;

+                                       });

+                                 }),

+                  m_include.end());

+}

+

+void CodeDiffDialog::Update(bool include)

+{

+  // Wrap everything in a pause

+  Core::State old_state = Core::GetState();

+  if (old_state == Core::State::Running)

+    Core::SetState(Core::State::Paused);

+

+  // Main process

+  if (include)

+  {

+    OnInclude();

+  }

+  else

+  {

+    OnExclude();

+  }

+

+  const auto create_item = [](const QString string = {}, const u32 address = 0x00000000) {

+    QTableWidgetItem* item = new QTableWidgetItem(string);

+    item->setData(Qt::UserRole, address);

+    item->setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable);

+    return item;

+  };

+

+  int i = 0;

+  m_matching_results_table->clear();

+  m_matching_results_table->setRowCount(i);

+  m_matching_results_table->setHorizontalHeaderLabels(

+      {tr("Address"), tr("Total Hits"), tr("Hits"), tr("Symbol"), tr("Inspected")});

+

+  for (auto& iter : m_include)

+  {

+    m_matching_results_table->setRowCount(i + 1);

+

+    QString fix_sym = QString::fromStdString(iter.symbol);

+    fix_sym.replace(QStringLiteral("\t"), QStringLiteral("  "));

+

+    m_matching_results_table->setItem(

+        i, 0, create_item(QStringLiteral("%1").arg(iter.addr, 1, 16), iter.addr));

+    m_matching_results_table->setItem(

+        i, 1, create_item(QStringLiteral("%1").arg(iter.total_hits), iter.addr));

+    m_matching_results_table->setItem(i, 2,

+                                      create_item(QStringLiteral("%1").arg(iter.hits), iter.addr));

+    m_matching_results_table->setItem(i, 3,

+                                      create_item(QStringLiteral("%1").arg(fix_sym), iter.addr));

+    m_matching_results_table->setItem(i, 4, create_item(QStringLiteral(""), iter.addr));

+    i++;

+  }

+

+  // If we have ruled out all functions from being included.

+  if (m_include_active && m_include.empty())

+  {

+    m_matching_results_table->setRowCount(1);

+    m_matching_results_table->setItem(0, 3, create_item(tr("No possible functions left. Reset.")));

+  }

+

+  m_exclude_size_label->setText(tr("Excluded: %1").arg(m_exclude.size()));

+  m_include_size_label->setText(tr("Included: %1").arg(m_include.size()));

+

+  JitInterface::ClearCache();

+  if (old_state == Core::State::Running)

+    Core::SetState(Core::State::Running);

+}

+

+void CodeDiffDialog::InfoDisp()

+{

+  ModalMessageBox::information(

+      this, tr("Code Diff Tool Help"),

+      tr("Used to find functions based on when they should be running.\nSimilar to Cheat Engine "

+         "Ultimap.\n"

+         "A symbol map must be loaded prior to use.\n"

+         "Include/Exclude lists will persist on ending/restarting emulation.\nThese lists "

+         "will not persist on Dolphin close."

+         "\n\n'Start Recording': "

+         "keeps track of what functions run.\n'Stop Recording': erases current "

+         "recording without any change to the lists.\n'Code did not get executed': click while "

+         "recording, will add recorded functions to an exclude "

+         "list, then reset the recording list.\n'Code has been executed': click while recording, "

+         "will add recorded function to an include list, then reset the recording list.\n\nAfter "

+         "you use "

+         "both exclude and include once, the exclude list will be subtracted from the include "

+         "list "

+         "and any includes left over will be displayed.\nYou can continue to use "

+         "'Code did not get executed'/'Code has been executed' to narrow down the "

+         "results."));

+  ModalMessageBox::information(

+      this, tr("Code Diff Tool Help"),

+      tr("Example:\n"

+         "You want to find a function that runs when HP is modified.\n1. Start recording and "

+         "play the game without letting HP be modified, then press 'Code did not get "

+         "executed'.\n2. Immediately gain/lose HP and press 'Code has been executed'.\n3. Repeat "

+         "1 or 2 to "

+         "narrow down the results.\nIncludes (Code has been executed) should "

+         "have short recordings focusing on what you want.\n\nPressing 'Code has been "

+         "executed' twice will only keep functions that ran for both recordings. Hits will update "

+         "to reflect the last recording's "

+         "number of Hits. Total Hits will reflect the total number of "

+         "times a function has been executed until the lists are cleared with Reset.\n\nRight "

+         "click -> 'Set blr' will place a "

+         "blr at the top of the symbol.\n"));

+}

+

+void CodeDiffDialog::OnContextMenu()

+{

+  if (m_matching_results_table->currentItem() == nullptr)

+    return;

+  UpdateItem();

+  QMenu* menu = new QMenu(this);

+  menu->addAction(tr("&Go to start of function"), this, &CodeDiffDialog::OnGoTop);

+  menu->addAction(tr("Set &blr"), this, &CodeDiffDialog::OnSetBLR);

+  menu->addAction(tr("&Delete"), this, &CodeDiffDialog::OnDelete);

+  menu->exec(QCursor::pos());

+}

+

+void CodeDiffDialog::OnGoTop()

+{

+  auto item = m_matching_results_table->currentItem();

+  if (!item)

+    return;

+  Common::Symbol* symbol = g_symbolDB.GetSymbolFromAddr(item->data(Qt::UserRole).toUInt());

+  if (!symbol)

+    return;

+  m_code_widget->SetAddress(symbol->address, CodeViewWidget::SetAddressUpdate::WithDetailedUpdate);

+}

+

+void CodeDiffDialog::OnDelete()

+{

+  // Delete from include list and qtable widget

+  auto item = m_matching_results_table->currentItem();

+  if (!item)

+    return;

+  int row = m_matching_results_table->row(item);

+  if (row == -1)

+    return;

+  // TODO: If/when sorting is ever added, .erase needs to find item position instead; leaving as is

+  // for performance

+  if (!m_include.empty())

+  {

+    m_include.erase(m_include.begin() + row);

+  }

+  m_matching_results_table->removeRow(row);

+}

+

+void CodeDiffDialog::OnSetBLR()

+{

+  auto item = m_matching_results_table->currentItem();

+  if (!item)

+    return;

+

+  Common::Symbol* symbol = g_symbolDB.GetSymbolFromAddr(item->data(Qt::UserRole).toUInt());

+  if (!symbol)

+    return;

+  PowerPC::debug_interface.SetPatch(symbol->address, 0x4E800020);

+

+  int row = item->row();

+  m_matching_results_table->item(row, 0)->setForeground(QBrush(Qt::red));

+  m_matching_results_table->item(row, 1)->setForeground(QBrush(Qt::red));

+  m_matching_results_table->item(row, 2)->setForeground(QBrush(Qt::red));

+  m_matching_results_table->item(row, 3)->setForeground(QBrush(Qt::red));

+  m_matching_results_table->item(row, 4)->setForeground(QBrush(Qt::red));

+  m_matching_results_table->item(row, 4)->setText(QStringLiteral("X"));

+

+  m_code_widget->Update();

+}

+

+void CodeDiffDialog::UpdateItem()

+{

+  QTableWidgetItem* item = m_matching_results_table->currentItem();

+  if (!item)

+    return;

+

+  int row = m_matching_results_table->row(item);

+  if (row == -1)

+    return;

+  uint address = item->data(Qt::UserRole).toUInt();

+

+  auto symbolName = g_symbolDB.GetDescription(address);

+  if (symbolName == " --- ")

+    return;

+

+  QString newName =

+      QString::fromStdString(symbolName).replace(QStringLiteral("\t"), QStringLiteral("  "));

+  m_matching_results_table->item(row, 3)->setText(newName);

+}