Qt/Debugger: Implement "Memory" widget

Source/Core/DolphinQt2/CMakeLists.txt

@@ -81,6 +81,8 @@ set(SRCS
   Debugger/BreakpointWidget.cpp
   Debugger/CodeViewWidget.cpp
   Debugger/CodeWidget.cpp
+  Debugger/MemoryViewWidget.cpp
+  Debugger/MemoryWidget.cpp
   Debugger/NewBreakpointDialog.cpp
   Debugger/RegisterColumn.cpp
   Debugger/RegisterWidget.cpp

Source/Core/DolphinQt2/Debugger/BreakpointWidget.h

@@ -27,6 +27,9 @@ public:
                     bool do_break = true);
   void Update();
 
+signals:
+  void BreakpointsChanged();
+
 protected:
   void closeEvent(QCloseEvent*) override;
 

Source/Core/DolphinQt2/Debugger/CodeWidget.h

@@ -32,13 +32,13 @@ public:
   void ToggleBreakpoint();
   void AddBreakpoint();
 
+  void Update();
 signals:
   void BreakpointsChanged();
 
 private:
   void CreateWidgets();
   void ConnectWidgets();
-  void Update();
   void UpdateCallstack();
   void UpdateSymbols();
   void UpdateFunctionCalls(Symbol* symbol);

Source/Core/DolphinQt2/Debugger/MemoryViewWidget.cpp

@@ -0,0 +1,411 @@
+// Copyright 2018 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#include "DolphinQt2/Debugger/MemoryViewWidget.h"
+
+#include <QApplication>
+#include <QClipboard>
+#include <QHeaderView>
+#include <QMenu>
+#include <QMouseEvent>
+#include <QScrollBar>
+#include <cmath>
+
+#include "Core/Core.h"
+#include "Core/PowerPC/BreakPoints.h"
+#include "Core/PowerPC/PowerPC.h"
+#include "DolphinQt2/QtUtils/ActionHelper.h"
+#include "DolphinQt2/Settings.h"
+
+MemoryViewWidget::MemoryViewWidget(QWidget* parent) : QTableWidget(parent)
+{
+  horizontalHeader()->hide();
+  verticalHeader()->hide();
+  verticalScrollBar()->setHidden(true);
+  setShowGrid(false);
+
+  setFont(Settings::Instance().GetDebugFont());
+
+  connect(&Settings::Instance(), &Settings::DebugFontChanged, this, &QWidget::setFont);
+  connect(&Settings::Instance(), &Settings::EmulationStateChanged, this, [this] { Update(); });
+  connect(this, &MemoryViewWidget::customContextMenuRequested, this,
+          &MemoryViewWidget::OnContextMenu);
+
+  setContextMenuPolicy(Qt::CustomContextMenu);
+
+  Update();
+}
+
+static int CalculateColumnCount(MemoryViewWidget::Type type)
+{
+  int column_count = 3;
+
+  switch (type)
+  {
+  case MemoryViewWidget::Type::ASCII:
+  case MemoryViewWidget::Type::U8:
+    column_count += 16;
+    break;
+  case MemoryViewWidget::Type::U16:
+    column_count += 8;
+    break;
+  case MemoryViewWidget::Type::U32:
+  case MemoryViewWidget::Type::Float32:
+    column_count += 4;
+    break;
+  }
+
+  return column_count;
+}
+
+void MemoryViewWidget::Update()
+{
+  clearSelection();
+
+  setColumnCount(CalculateColumnCount(m_type));
+
+  setColumnWidth(0, 24);
+
+  if (rowCount() == 0)
+    setRowCount(1);
+
+  setRowHeight(0, 24);
+
+  // Calculate (roughly) how many rows will fit in our table
+  int rows = std::round((height() / static_cast<float>(rowHeight(0))) - 0.25);
+
+  setRowCount(rows);
+
+  for (int i = 0; i < rows; i++)
+  {
+    setRowHeight(i, 24);
+
+    u32 addr = m_address - ((rowCount() / 2) * 16) + i * 16;
+
+    auto* bp_item = new QTableWidgetItem;
+    bp_item->setFlags(Qt::ItemIsEnabled);
+    bp_item->setData(Qt::UserRole, addr);
+
+    if (PowerPC::memchecks.OverlapsMemcheck(addr, 16))
+      bp_item->setBackground(Qt::red);
+
+    setItem(i, 0, bp_item);
+
+    auto* addr_item = new QTableWidgetItem(QStringLiteral("%1").arg(addr, 8, 16, QLatin1Char('0')));
+
+    addr_item->setData(Qt::UserRole, addr);
+    addr_item->setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable);
+
+    setItem(i, 1, addr_item);
+
+    if (addr == m_address)
+      addr_item->setSelected(true);
+
+    if (Core::GetState() != Core::State::Paused || !PowerPC::HostIsRAMAddress(addr))
+    {
+      for (int c = 2; c < columnCount(); c++)
+      {
+        auto* item = new QTableWidgetItem(QStringLiteral("-"));
+        item->setFlags(Qt::ItemIsEnabled);
+        item->setData(Qt::UserRole, addr);
+
+        setItem(i, c, item);
+      }
+
+      continue;
+    }
+
+    auto* description_item =
+        new QTableWidgetItem(QString::fromStdString(PowerPC::debug_interface.GetDescription(addr)));
+
+    description_item->setForeground(Qt::blue);
+    description_item->setFlags(Qt::ItemIsEnabled);
+
+    setItem(i, columnCount() - 1, description_item);
+
+    switch (m_type)
+    {
+    case Type::U8:
+      for (int c = 0; c < 16; c++)
+      {
+        auto* hex_item = new QTableWidgetItem;
+
+        if (PowerPC::HostIsRAMAddress(addr + c * sizeof(u8)))
+        {
+          u8 value = PowerPC::HostRead_U8(addr + c * sizeof(u8));
+          hex_item->setText(QStringLiteral("%1").arg(value, 2, 16, QLatin1Char('0')));
+
+          hex_item->setFlags(Qt::ItemIsEnabled);
+          hex_item->setData(Qt::UserRole, addr);
+        }
+        else
+        {
+          hex_item->setFlags(0);
+          hex_item->setText(QStringLiteral("-"));
+        }
+
+        setItem(i, 2 + c, hex_item);
+      }
+      break;
+    case Type::ASCII:
+      for (int c = 0; c < 16; c++)
+      {
+        auto* hex_item = new QTableWidgetItem;
+
+        if (PowerPC::HostIsRAMAddress(addr + c * sizeof(u8)))
+        {
+          char value = PowerPC::HostRead_U8(addr + c * sizeof(u8));
+          std::string s(1, std::isprint(value) ? value : '.');
+          hex_item->setText(QString::fromStdString(s));
+
+          hex_item->setFlags(Qt::ItemIsEnabled);
+          hex_item->setData(Qt::UserRole, addr);
+        }
+        else
+        {
+          hex_item->setFlags(0);
+          hex_item->setText(QStringLiteral("-"));
+        }
+
+        setItem(i, 2 + c, hex_item);
+      }
+      break;
+    case Type::U16:
+      for (int c = 0; c < 8; c++)
+      {
+        auto* hex_item = new QTableWidgetItem;
+
+        if (PowerPC::HostIsRAMAddress(addr + c * sizeof(u16)))
+        {
+          u16 value = PowerPC::HostRead_U16(addr + c * sizeof(u16));
+          hex_item->setText(QStringLiteral("%1").arg(value, 4, 16, QLatin1Char('0')));
+
+          hex_item->setFlags(Qt::ItemIsEnabled);
+          hex_item->setData(Qt::UserRole, addr);
+        }
+        else
+        {
+          hex_item->setFlags(0);
+          hex_item->setText(QStringLiteral("-"));
+        }
+
+        setItem(i, 2 + c, hex_item);
+      }
+      break;
+    case Type::U32:
+      for (int c = 0; c < 4; c++)
+      {
+        auto* hex_item = new QTableWidgetItem;
+
+        if (PowerPC::HostIsRAMAddress(addr + c * sizeof(u32)))
+        {
+          u32 value = PowerPC::HostRead_U32(addr + c * sizeof(u32));
+          hex_item->setText(QStringLiteral("%1").arg(value, 8, 16, QLatin1Char('0')));
+
+          hex_item->setFlags(Qt::ItemIsEnabled);
+          hex_item->setData(Qt::UserRole, addr);
+        }
+        else
+        {
+          hex_item->setFlags(0);
+          hex_item->setText(QStringLiteral("-"));
+        }
+
+        setItem(i, 2 + c, hex_item);
+      }
+      break;
+    case Type::Float32:
+      for (int c = 0; c < 4; c++)
+      {
+        auto* hex_item = new QTableWidgetItem;
+
+        if (PowerPC::HostIsRAMAddress(addr + c * sizeof(u32)))
+        {
+          float value = PowerPC::Read_F32(addr + c * sizeof(u32));
+          hex_item->setText(QString::number(value));
+
+          hex_item->setFlags(Qt::ItemIsEnabled);
+          hex_item->setData(Qt::UserRole, addr);
+        }
+        else
+        {
+          hex_item->setFlags(0);
+          hex_item->setText(QStringLiteral("-"));
+        }
+
+        setItem(i, 2 + c, hex_item);
+      }
+      break;
+    }
+  }
+
+  for (int i = 1; i < columnCount(); i++)
+  {
+    resizeColumnToContents(i);
+    // Add some extra spacing because the default width is too small in most cases
+    setColumnWidth(i, columnWidth(i) * 1.1);
+  }
+
+  viewport()->update();
+  update();
+}
+
+void MemoryViewWidget::SetType(Type type)
+{
+  if (m_type == type)
+    return;
+
+  m_type = type;
+  Update();
+}
+
+void MemoryViewWidget::SetBPType(BPType type)
+{
+  m_bp_type = type;
+}
+
+void MemoryViewWidget::SetAddress(u32 address)
+{
+  if (m_address == address)
+    return;
+
+  m_address = address;
+  Update();
+}
+
+void MemoryViewWidget::SetBPLoggingEnabled(bool enabled)
+{
+  m_do_log = enabled;
+}
+
+void MemoryViewWidget::resizeEvent(QResizeEvent*)
+{
+  Update();
+}
+
+void MemoryViewWidget::keyPressEvent(QKeyEvent* event)
+{
+  switch (event->key())
+  {
+  case Qt::Key_Up:
+    m_address -= 3 * 16;
+    Update();
+    return;
+  case Qt::Key_Down:
+    m_address += 3 * 16;
+    Update();
+    return;
+  case Qt::Key_PageUp:
+    m_address -= rowCount() * 16;
+    Update();
+    return;
+  case Qt::Key_PageDown:
+    m_address += rowCount() * 16;
+    Update();
+    return;
+  default:
+    QWidget::keyPressEvent(event);
+    break;
+  }
+}
+
+u32 MemoryViewWidget::GetContextAddress() const
+{
+  return m_context_address;
+}
+
+void MemoryViewWidget::ToggleBreakpoint()
+{
+  u32 addr = GetContextAddress();
+
+  if (!PowerPC::memchecks.OverlapsMemcheck(addr, 16))
+  {
+    TMemCheck check;
+
+    check.start_address = addr;
+    check.end_address = check.start_address + 15;
+    check.is_ranged = true;
+    check.is_break_on_read = (m_bp_type == BPType::ReadOnly || m_bp_type == BPType::ReadWrite);
+    check.is_break_on_write = (m_bp_type == BPType::WriteOnly || m_bp_type == BPType::ReadWrite);
+    check.log_on_hit = m_do_log;
+    check.break_on_hit = true;
+
+    PowerPC::memchecks.Add(check);
+  }
+  else
+  {
+    PowerPC::memchecks.Remove(addr);
+  }
+
+  emit BreakpointsChanged();
+  Update();
+}
+
+void MemoryViewWidget::wheelEvent(QWheelEvent* event)
+{
+  int delta = event->delta() > 0 ? -1 : 1;
+
+  m_address += delta * 3 * 16;
+  Update();
+}
+
+void MemoryViewWidget::mousePressEvent(QMouseEvent* event)
+{
+  auto* item = itemAt(event->pos());
+  if (item == nullptr)
+    return;
+
+  const u32 addr = item->data(Qt::UserRole).toUInt();
+
+  m_context_address = addr;
+
+  switch (event->button())
+  {
+  case Qt::LeftButton:
+    if (column(item) == 0)
+      ToggleBreakpoint();
+    else
+      SetAddress(addr);
+
+    Update();
+    break;
+  default:
+    break;
+  }
+}
+
+void MemoryViewWidget::OnCopyAddress()
+{
+  u32 addr = GetContextAddress();
+  QApplication::clipboard()->setText(QStringLiteral("%1").arg(addr, 8, 16, QLatin1Char('0')));
+}
+
+void MemoryViewWidget::OnCopyHex()
+{
+  u32 addr = GetContextAddress();
+
+  u64 a = PowerPC::HostRead_U64(addr);
+  u64 b = PowerPC::HostRead_U64(addr + sizeof(u64));
+
+  QApplication::clipboard()->setText(
+      QStringLiteral("%1%2").arg(a, 16, 16, QLatin1Char('0')).arg(b, 16, 16, QLatin1Char('0')));
+}
+
+void MemoryViewWidget::OnContextMenu()
+{
+  auto* menu = new QMenu(this);
+
+  AddAction(menu, tr("Copy Address"), this, &MemoryViewWidget::OnCopyAddress);
+
+  auto* copy_hex = AddAction(menu, tr("Copy Hex"), this, &MemoryViewWidget::OnCopyHex);
+
+  copy_hex->setEnabled(Core::GetState() != Core::State::Uninitialized &&
+                       PowerPC::HostIsRAMAddress(GetContextAddress()));
+
+  menu->addSeparator();
+
+  AddAction(menu, tr("Toggle Breakpoint"), this, &MemoryViewWidget::ToggleBreakpoint);
+
+  menu->exec(QCursor::pos());
+}

Source/Core/DolphinQt2/Debugger/MemoryViewWidget.h

@@ -0,0 +1,62 @@
+// Copyright 2018 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <QTableWidget>
+
+#include "Common/CommonTypes.h"
+
+class MemoryViewWidget : public QTableWidget
+{
+  Q_OBJECT
+public:
+  enum class Type
+  {
+    U8,
+    U16,
+    U32,
+    ASCII,
+    Float32
+  };
+
+  enum class BPType
+  {
+    ReadWrite,
+    ReadOnly,
+    WriteOnly
+  };
+
+  explicit MemoryViewWidget(QWidget* parent = nullptr);
+
+  void Update();
+  void ToggleBreakpoint();
+
+  void SetType(Type type);
+  void SetBPType(BPType type);
+  void SetAddress(u32 address);
+
+  void SetBPLoggingEnabled(bool enabled);
+
+  u32 GetContextAddress() const;
+
+  void resizeEvent(QResizeEvent*) override;
+  void keyPressEvent(QKeyEvent* event) override;
+  void mousePressEvent(QMouseEvent* event) override;
+  void wheelEvent(QWheelEvent* event) override;
+
+signals:
+  void BreakpointsChanged();
+
+private:
+  void OnContextMenu();
+  void OnCopyAddress();
+  void OnCopyHex();
+
+  Type m_type = Type::U8;
+  BPType m_bp_type = BPType::ReadWrite;
+  bool m_do_log = true;
+  u32 m_context_address;
+  u32 m_address = 0;
+};

Source/Core/DolphinQt2/Debugger/MemoryWidget.h

@@ -0,0 +1,88 @@
+// Copyright 2018 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <vector>
+
+#include <QDockWidget>
+
+#include "Common/CommonTypes.h"
+
+class MemoryViewWidget;
+class QCheckBox;
+class QLabel;
+class QLineEdit;
+class QPushButton;
+class QRadioButton;
+class QSplitter;
+
+class MemoryWidget : public QDockWidget
+{
+  Q_OBJECT
+public:
+  explicit MemoryWidget(QWidget* parent = nullptr);
+  ~MemoryWidget();
+
+  void Update();
+signals:
+  void BreakpointsChanged();
+
+private:
+  void CreateWidgets();
+  void ConnectWidgets();
+
+  void LoadSettings();
+  void SaveSettings();
+
+  void OnTypeChanged();
+  void OnBPLogChanged();
+  void OnBPTypeChanged();
+
+  void OnSearchAddress();
+  void OnFindNextValue();
+  void OnFindPreviousValue();
+  void ValidateSearchValue();
+
+  void OnSetValue();
+
+  void OnDumpMRAM();
+  void OnDumpExRAM();
+  void OnDumpFakeVMEM();
+
+  std::vector<u8> GetValueData() const;
+
+  void FindValue(bool next);
+
+  void closeEvent(QCloseEvent*) override;
+
+  MemoryViewWidget* m_memory_view;
+  QSplitter* m_splitter;
+  QLineEdit* m_search_address;
+  QLineEdit* m_data_edit;
+  QPushButton* m_set_value;
+  QPushButton* m_dump_mram;
+  QPushButton* m_dump_exram;
+  QPushButton* m_dump_fake_vmem;
+
+  // Search
+  QPushButton* m_find_next;
+  QPushButton* m_find_previous;
+  QRadioButton* m_find_ascii;
+  QRadioButton* m_find_hex;
+  QLabel* m_result_label;
+
+  // Datatypes
+  QRadioButton* m_type_u8;
+  QRadioButton* m_type_u16;
+  QRadioButton* m_type_u32;
+  QRadioButton* m_type_ascii;
+  QRadioButton* m_type_float;
+
+  // Breakpoint options
+  QRadioButton* m_bp_read_write;
+  QRadioButton* m_bp_read_only;
+  QRadioButton* m_bp_write_only;
+  QCheckBox* m_bp_log_check;
+};

Source/Core/DolphinQt2/DolphinQt2.vcxproj

@@ -96,6 +96,8 @@
     <QtMoc Include="Debugger\BreakpointWidget.h" />
     <QtMoc Include="Debugger\CodeWidget.h" />
     <QtMoc Include="Debugger\CodeViewWidget.h" />
+    <QtMoc Include="Debugger\MemoryWidget.h" />
+    <QtMoc Include="Debugger\MemoryViewWidget.h" />
     <QtMoc Include="Debugger\NewBreakpointDialog.h" />
     <QtMoc Include="Debugger\RegisterWidget.h" />
     <QtMoc Include="Debugger\WatchWidget.h" />
@@ -179,6 +181,8 @@
     <ClCompile Include="$(QtMocOutPrefix)MappingWidget.cpp" />
     <ClCompile Include="$(QtMocOutPrefix)MappingWindow.cpp" />
     <ClCompile Include="$(QtMocOutPrefix)MD5Dialog.cpp" />
+    <ClCompile Include="$(QtMocOutPrefix)MemoryWidget.cpp" />
+    <ClCompile Include="$(QtMocOutPrefix)MemoryViewWidget.cpp" />
     <ClCompile Include="$(QtMocOutPrefix)MenuBar.cpp" />
     <ClCompile Include="$(QtMocOutPrefix)NetPlayDialog.cpp" />
     <ClCompile Include="$(QtMocOutPrefix)NetPlaySetupDialog.cpp" />
@@ -247,6 +251,8 @@
     <ClCompile Include="Config\SettingsWindow.cpp" />
     <ClCompile Include="Debugger\CodeViewWidget.cpp" />
     <ClCompile Include="Debugger\CodeWidget.cpp" />
+    <ClCompile Include="Debugger\MemoryWidget.cpp" />
+    <ClCompile Include="Debugger\MemoryViewWidget.cpp" />
     <ClCompile Include="FIFOPlayerWindow.cpp" />
     <ClCompile Include="TAS\GCTASInputWindow.cpp" />
     <ClCompile Include="TAS\WiiTASInputWindow.cpp" />

Source/Core/DolphinQt2/MainWindow.cpp

@@ -54,6 +54,7 @@
 #include "DolphinQt2/Config/SettingsWindow.h"
 #include "DolphinQt2/Debugger/BreakpointWidget.h"
 #include "DolphinQt2/Debugger/CodeWidget.h"
+#include "DolphinQt2/Debugger/MemoryWidget.h"
 #include "DolphinQt2/Debugger/RegisterWidget.h"
 #include "DolphinQt2/Debugger/WatchWidget.h"
 #include "DolphinQt2/FIFOPlayerWindow.h"
@@ -195,6 +196,7 @@ void MainWindow::CreateComponents()
   m_log_widget = new LogWidget(this);
   m_log_config_widget = new LogConfigWidget(this);
   m_fifo_window = new FIFOPlayerWindow(this);
+  m_memory_widget = new MemoryWidget(this);
 
   connect(m_fifo_window, &FIFOPlayerWindow::LoadFIFORequested, this,
           [this](const QString& path) { StartGame(path); });
@@ -207,8 +209,16 @@ void MainWindow::CreateComponents()
           [this](u32 addr) { m_breakpoint_widget->AddAddressMBP(addr); });
   connect(m_register_widget, &RegisterWidget::RequestMemoryBreakpoint,
           [this](u32 addr) { m_breakpoint_widget->AddAddressMBP(addr); });
+
   connect(m_code_widget, &CodeWidget::BreakpointsChanged, m_breakpoint_widget,
           &BreakpointWidget::Update);
+  connect(m_memory_widget, &MemoryWidget::BreakpointsChanged, m_breakpoint_widget,
+          &BreakpointWidget::Update);
+
+  connect(m_breakpoint_widget, &BreakpointWidget::BreakpointsChanged, m_code_widget,
+          &CodeWidget::Update);
+  connect(m_breakpoint_widget, &BreakpointWidget::BreakpointsChanged, m_memory_widget,
+          &MemoryWidget::Update);
 
 #if defined(HAVE_XRANDR) && HAVE_XRANDR
   m_graphics_window = new GraphicsWindow(
@@ -410,12 +420,14 @@ void MainWindow::ConnectStack()
   addDockWidget(Qt::RightDockWidgetArea, m_register_widget);
   addDockWidget(Qt::RightDockWidgetArea, m_watch_widget);
   addDockWidget(Qt::RightDockWidgetArea, m_breakpoint_widget);
+  addDockWidget(Qt::RightDockWidgetArea, m_memory_widget);
 
   tabifyDockWidget(m_log_widget, m_log_config_widget);
   tabifyDockWidget(m_log_widget, m_code_widget);
   tabifyDockWidget(m_log_widget, m_register_widget);
   tabifyDockWidget(m_log_widget, m_watch_widget);
   tabifyDockWidget(m_log_widget, m_breakpoint_widget);
+  tabifyDockWidget(m_log_widget, m_memory_widget);
 }
 
 QString MainWindow::PromptFileName()

Source/Core/DolphinQt2/MainWindow.h

@@ -32,6 +32,7 @@ class HotkeyScheduler;
 class LogConfigWidget;
 class LogWidget;
 class MappingWindow;
+class MemoryWidget;
 class NetPlayClient;
 class NetPlayDialog;
 class NetPlayServer;
@@ -174,6 +175,7 @@ private:
   CodeWidget* m_code_widget;
   LogWidget* m_log_widget;
   LogConfigWidget* m_log_config_widget;
+  MemoryWidget* m_memory_widget;
   FIFOPlayerWindow* m_fifo_window;
   RegisterWidget* m_register_widget;
   WatchWidget* m_watch_widget;

Source/Core/DolphinQt2/MenuBar.cpp

@@ -120,6 +120,7 @@ void MenuBar::OnDebugModeToggled(bool enabled)
   m_show_registers->setVisible(enabled);
   m_show_watch->setVisible(enabled);
   m_show_breakpoints->setVisible(enabled);
+  m_show_memory->setVisible(enabled);
 
   if (enabled)
     addMenu(m_symbols);
@@ -377,6 +378,14 @@ void MenuBar::AddViewMenu()
   connect(&Settings::Instance(), &Settings::BreakpointsVisibilityChanged, m_show_breakpoints,
           &QAction::setChecked);
 
+  m_show_memory = view_menu->addAction(tr("&Memory"));
+  m_show_memory->setCheckable(true);
+  m_show_memory->setChecked(Settings::Instance().IsMemoryVisible());
+
+  connect(m_show_memory, &QAction::toggled, &Settings::Instance(), &Settings::SetMemoryVisible);
+  connect(&Settings::Instance(), &Settings::MemoryVisibilityChanged, m_show_memory,
+          &QAction::setChecked);
+
   view_menu->addSeparator();
 
   AddGameListTypeSection(view_menu);

Source/Core/DolphinQt2/MenuBar.h

@@ -201,6 +201,7 @@ private:
   QAction* m_show_registers;
   QAction* m_show_watch;
   QAction* m_show_breakpoints;
+  QAction* m_show_memory;
 
   // Symbols
   QMenu* m_symbols;

Source/Core/DolphinQt2/Settings.cpp

@@ -303,6 +303,20 @@ bool Settings::IsCodeVisible() const
   return GetQSettings().value(QStringLiteral("debugger/showcode")).toBool();
 }
 
+void Settings::SetMemoryVisible(bool enabled)
+{
+  if (IsMemoryVisible() == enabled)
+    return;
+  QSettings().setValue(QStringLiteral("debugger/showmemory"), enabled);
+
+  emit MemoryVisibilityChanged(enabled);
+}
+
+bool Settings::IsMemoryVisible() const
+{
+  return QSettings().value(QStringLiteral("debugger/showmemory")).toBool();
+}
+
 void Settings::SetDebugFont(QFont font)
 {
   if (GetDebugFont() != font)

Source/Core/DolphinQt2/Settings.h

@@ -97,6 +97,8 @@ public:
   bool IsBreakpointsVisible() const;
   void SetCodeVisible(bool enabled);
   bool IsCodeVisible() const;
+  void SetMemoryVisible(bool enabled);
+  bool IsMemoryVisible() const;
   QFont GetDebugFont() const;
   void SetDebugFont(QFont font);
 
@@ -127,6 +129,7 @@ signals:
   void WatchVisibilityChanged(bool visible);
   void BreakpointsVisibilityChanged(bool visible);
   void CodeVisibilityChanged(bool visible);
+  void MemoryVisibilityChanged(bool visible);
   void DebugModeToggled(bool enabled);
   void DebugFontChanged(QFont font);
   void AutoUpdateTrackChanged(const QString& mode);