diff --git a/Source/Core/Common/Debug/Watches.cpp b/Source/Core/Common/Debug/Watches.cpp
index 3668af1626..9114f2e83d 100644
--- a/Source/Core/Common/Debug/Watches.cpp
+++ b/Source/Core/Common/Debug/Watches.cpp
@@ -9,12 +9,12 @@
 
 namespace Common::Debug
 {
-Watch::Watch(u32 address_, const std::string& name_, Watch::State is_enabled_)
-    : address(address_), name(name_), is_enabled(is_enabled_)
+Watch::Watch(u32 address_, std::string name_, State is_enabled_)
+    : address(address_), name(std::move(name_)), is_enabled(is_enabled_)
 {
 }
 
-std::size_t Watches::SetWatch(u32 address, const std::string& name)
+std::size_t Watches::SetWatch(u32 address, std::string name)
 {
   const std::size_t size = m_watches.size();
   for (std::size_t index = 0; index < size; index++)
@@ -25,7 +25,7 @@ std::size_t Watches::SetWatch(u32 address, const std::string& name)
       return index;
     }
   }
-  m_watches.emplace_back(address, name, Watch::State::Enabled);
+  m_watches.emplace_back(address, std::move(name), Watch::State::Enabled);
   return size;
 }
 
@@ -46,10 +46,10 @@ void Watches::UnsetWatch(u32 address)
                   m_watches.end());
 }
 
-void Watches::UpdateWatch(std::size_t index, u32 address, const std::string& name)
+void Watches::UpdateWatch(std::size_t index, u32 address, std::string name)
 {
   m_watches[index].address = address;
-  m_watches[index].name = name;
+  m_watches[index].name = std::move(name);
 }
 
 void Watches::UpdateWatchAddress(std::size_t index, u32 address)
@@ -57,9 +57,9 @@ void Watches::UpdateWatchAddress(std::size_t index, u32 address)
   m_watches[index].address = address;
 }
 
-void Watches::UpdateWatchName(std::size_t index, const std::string& name)
+void Watches::UpdateWatchName(std::size_t index, std::string name)
 {
-  m_watches[index].name = name;
+  m_watches[index].name = std::move(name);
 }
 
 void Watches::EnableWatch(std::size_t index)
diff --git a/Source/Core/Common/Debug/Watches.h b/Source/Core/Common/Debug/Watches.h
index 1134f20900..fcf5c795bf 100644
--- a/Source/Core/Common/Debug/Watches.h
+++ b/Source/Core/Common/Debug/Watches.h
@@ -24,19 +24,19 @@ struct Watch
   std::string name;
   State is_enabled;
 
-  Watch(u32 address, const std::string& name, State is_enabled);
+  Watch(u32 address, std::string name, State is_enabled);
 };
 
 class Watches
 {
 public:
-  std::size_t SetWatch(u32 address, const std::string& name);
+  std::size_t SetWatch(u32 address, std::string name);
   const Watch& GetWatch(std::size_t index) const;
   const std::vector<Watch>& GetWatches() const;
   void UnsetWatch(u32 address);
-  void UpdateWatch(std::size_t index, u32 address, const std::string& name);
+  void UpdateWatch(std::size_t index, u32 address, std::string name);
   void UpdateWatchAddress(std::size_t index, u32 address);
-  void UpdateWatchName(std::size_t index, const std::string& name);
+  void UpdateWatchName(std::size_t index, std::string name);
   void EnableWatch(std::size_t index);
   void DisableWatch(std::size_t index);
   bool HasEnabledWatch(u32 address) const;
diff --git a/Source/Core/Common/DebugInterface.h b/Source/Core/Common/DebugInterface.h
index e73c44ee28..fd9d93f8f9 100644
--- a/Source/Core/Common/DebugInterface.h
+++ b/Source/Core/Common/DebugInterface.h
@@ -5,30 +5,33 @@
 #pragma once
 
 #include <cstddef>
-#include <cstring>
 #include <string>
 #include <vector>
 
 #include "Common/CommonTypes.h"
-#include "Common/Debug/MemoryPatches.h"
-#include "Common/Debug/Watches.h"
+
+namespace Common::Debug
+{
+struct MemoryPatch;
+struct Watch;
+}  // namespace Common::Debug
 
 namespace Common
 {
 class DebugInterface
 {
 protected:
-  virtual ~DebugInterface() {}
+  virtual ~DebugInterface() = default;
 
 public:
   // Watches
-  virtual std::size_t SetWatch(u32 address, const std::string& name = "") = 0;
-  virtual const Common::Debug::Watch& GetWatch(std::size_t index) const = 0;
-  virtual const std::vector<Common::Debug::Watch>& GetWatches() const = 0;
+  virtual std::size_t SetWatch(u32 address, std::string name = "") = 0;
+  virtual const Debug::Watch& GetWatch(std::size_t index) const = 0;
+  virtual const std::vector<Debug::Watch>& GetWatches() const = 0;
   virtual void UnsetWatch(u32 address) = 0;
-  virtual void UpdateWatch(std::size_t index, u32 address, const std::string& name) = 0;
+  virtual void UpdateWatch(std::size_t index, u32 address, std::string name) = 0;
   virtual void UpdateWatchAddress(std::size_t index, u32 address) = 0;
-  virtual void UpdateWatchName(std::size_t index, const std::string& name) = 0;
+  virtual void UpdateWatchName(std::size_t index, std::string name) = 0;
   virtual void EnableWatch(std::size_t index) = 0;
   virtual void DisableWatch(std::size_t index) = 0;
   virtual bool HasEnabledWatch(u32 address) const = 0;
@@ -40,7 +43,7 @@ public:
   // Memory Patches
   virtual void SetPatch(u32 address, u32 value) = 0;
   virtual void SetPatch(u32 address, std::vector<u8> value) = 0;
-  virtual const std::vector<Common::Debug::MemoryPatch>& GetPatches() const = 0;
+  virtual const std::vector<Debug::MemoryPatch>& GetPatches() const = 0;
   virtual void UnsetPatch(u32 address) = 0;
   virtual void EnablePatch(std::size_t index) = 0;
   virtual void DisablePatch(std::size_t index) = 0;
@@ -48,33 +51,30 @@ public:
   virtual void RemovePatch(std::size_t index) = 0;
   virtual void ClearPatches() = 0;
 
-  virtual std::string Disassemble(unsigned int /*address*/) { return "NODEBUGGER"; }
-  virtual std::string GetRawMemoryString(int /*memory*/, unsigned int /*address*/)
+  virtual std::string Disassemble(u32 /*address*/) const { return "NODEBUGGER"; }
+  virtual std::string GetRawMemoryString(int /*memory*/, u32 /*address*/) const
   {
     return "NODEBUGGER";
   }
-  virtual int GetInstructionSize(int /*instruction*/) { return 1; }
-  virtual bool IsAlive() { return true; }
-  virtual bool IsBreakpoint(unsigned int /*address*/) { return false; }
-  virtual void SetBreakpoint(unsigned int /*address*/) {}
-  virtual void ClearBreakpoint(unsigned int /*address*/) {}
+  virtual bool IsAlive() const { return true; }
+  virtual bool IsBreakpoint(u32 /*address*/) const { return false; }
+  virtual void SetBreakpoint(u32 /*address*/) {}
+  virtual void ClearBreakpoint(u32 /*address*/) {}
   virtual void ClearAllBreakpoints() {}
-  virtual void ToggleBreakpoint(unsigned int /*address*/) {}
+  virtual void ToggleBreakpoint(u32 /*address*/) {}
   virtual void ClearAllMemChecks() {}
-  virtual bool IsMemCheck(unsigned int /*address*/, size_t /*size*/) { return false; }
-  virtual void ToggleMemCheck(unsigned int /*address*/, bool /*read*/, bool /*write*/, bool /*log*/)
-  {
-  }
-  virtual unsigned int ReadMemory(unsigned int /*address*/) { return 0; }
-  virtual void WriteExtraMemory(int /*memory*/, unsigned int /*value*/, unsigned int /*address*/) {}
-  virtual unsigned int ReadExtraMemory(int /*memory*/, unsigned int /*address*/) { return 0; }
-  virtual unsigned int ReadInstruction(unsigned int /*address*/) { return 0; }
-  virtual unsigned int GetPC() { return 0; }
-  virtual void SetPC(unsigned int /*address*/) {}
+  virtual bool IsMemCheck(u32 /*address*/, size_t /*size*/) const { return false; }
+  virtual void ToggleMemCheck(u32 /*address*/, bool /*read*/, bool /*write*/, bool /*log*/) {}
+  virtual u32 ReadMemory(u32 /*address*/) const { return 0; }
+  virtual void WriteExtraMemory(int /*memory*/, u32 /*value*/, u32 /*address*/) {}
+  virtual u32 ReadExtraMemory(int /*memory*/, u32 /*address*/) const { return 0; }
+  virtual u32 ReadInstruction(u32 /*address*/) const { return 0; }
+  virtual u32 GetPC() const { return 0; }
+  virtual void SetPC(u32 /*address*/) {}
   virtual void Step() {}
   virtual void RunToBreakpoint() {}
-  virtual int GetColor(unsigned int /*address*/) { return 0xFFFFFFFF; }
-  virtual std::string GetDescription(unsigned int /*address*/) = 0;
+  virtual u32 GetColor(u32 /*address*/) const { return 0xFFFFFFFF; }
+  virtual std::string GetDescription(u32 /*address*/) const = 0;
   virtual void Clear() = 0;
 };
 }  // namespace Common
diff --git a/Source/Core/Core/Debugger/PPCDebugInterface.cpp b/Source/Core/Core/Debugger/PPCDebugInterface.cpp
index 394a8c4eb7..6dc34917a8 100644
--- a/Source/Core/Core/Debugger/PPCDebugInterface.cpp
+++ b/Source/Core/Core/Debugger/PPCDebugInterface.cpp
@@ -4,12 +4,14 @@
 
 #include "Core/Debugger/PPCDebugInterface.h"
 
+#include <array>
 #include <cstddef>
 #include <string>
 
+#include <fmt/format.h>
+
 #include "Common/Align.h"
 #include "Common/GekkoDisassembler.h"
-#include "Common/StringUtil.h"
 
 #include "Core/Core.h"
 #include "Core/HW/DSP.h"
@@ -44,9 +46,12 @@ void PPCPatches::Patch(std::size_t index)
   }
 }
 
-std::size_t PPCDebugInterface::SetWatch(u32 address, const std::string& name)
+PPCDebugInterface::PPCDebugInterface() = default;
+PPCDebugInterface::~PPCDebugInterface() = default;
+
+std::size_t PPCDebugInterface::SetWatch(u32 address, std::string name)
 {
-  return m_watches.SetWatch(address, name);
+  return m_watches.SetWatch(address, std::move(name));
 }
 
 const Common::Debug::Watch& PPCDebugInterface::GetWatch(std::size_t index) const
@@ -64,9 +69,9 @@ void PPCDebugInterface::UnsetWatch(u32 address)
   m_watches.UnsetWatch(address);
 }
 
-void PPCDebugInterface::UpdateWatch(std::size_t index, u32 address, const std::string& name)
+void PPCDebugInterface::UpdateWatch(std::size_t index, u32 address, std::string name)
 {
-  return m_watches.UpdateWatch(index, address, name);
+  return m_watches.UpdateWatch(index, address, std::move(name));
 }
 
 void PPCDebugInterface::UpdateWatchAddress(std::size_t index, u32 address)
@@ -74,9 +79,9 @@ void PPCDebugInterface::UpdateWatchAddress(std::size_t index, u32 address)
   return m_watches.UpdateWatchAddress(index, address);
 }
 
-void PPCDebugInterface::UpdateWatchName(std::size_t index, const std::string& name)
+void PPCDebugInterface::UpdateWatchName(std::size_t index, std::string name)
 {
-  return m_watches.UpdateWatchName(index, name);
+  return m_watches.UpdateWatchName(index, std::move(name));
 }
 
 void PPCDebugInterface::EnableWatch(std::size_t index)
@@ -121,7 +126,7 @@ void PPCDebugInterface::SetPatch(u32 address, u32 value)
 
 void PPCDebugInterface::SetPatch(u32 address, std::vector<u8> value)
 {
-  m_patches.SetPatch(address, value);
+  m_patches.SetPatch(address, std::move(value));
 }
 
 const std::vector<Common::Debug::MemoryPatch>& PPCDebugInterface::GetPatches() const
@@ -159,7 +164,7 @@ void PPCDebugInterface::ClearPatches()
   m_patches.ClearPatches();
 }
 
-std::string PPCDebugInterface::Disassemble(unsigned int address)
+std::string PPCDebugInterface::Disassemble(u32 address) const
 {
   // PowerPC::HostRead_U32 seemed to crash on shutdown
   if (!IsAlive())
@@ -189,14 +194,14 @@ std::string PPCDebugInterface::Disassemble(unsigned int address)
   }
 }
 
-std::string PPCDebugInterface::GetRawMemoryString(int memory, unsigned int address)
+std::string PPCDebugInterface::GetRawMemoryString(int memory, u32 address) const
 {
   if (IsAlive())
   {
     const bool is_aram = memory != 0;
 
     if (is_aram || PowerPC::HostIsRAMAddress(address))
-      return StringFromFormat("%08X%s", ReadExtraMemory(memory, address), is_aram ? " (ARAM)" : "");
+      return fmt::format("{:08X}{}", ReadExtraMemory(memory, address), is_aram ? " (ARAM)" : "");
 
     return is_aram ? "--ARAM--" : "--------";
   }
@@ -204,12 +209,12 @@ std::string PPCDebugInterface::GetRawMemoryString(int memory, unsigned int addre
   return "<unknwn>";  // bad spelling - 8 chars
 }
 
-unsigned int PPCDebugInterface::ReadMemory(unsigned int address)
+u32 PPCDebugInterface::ReadMemory(u32 address) const
 {
   return PowerPC::HostRead_U32(address);
 }
 
-unsigned int PPCDebugInterface::ReadExtraMemory(int memory, unsigned int address)
+u32 PPCDebugInterface::ReadExtraMemory(int memory, u32 address) const
 {
   switch (memory)
   {
@@ -223,27 +228,27 @@ unsigned int PPCDebugInterface::ReadExtraMemory(int memory, unsigned int address
   }
 }
 
-unsigned int PPCDebugInterface::ReadInstruction(unsigned int address)
+u32 PPCDebugInterface::ReadInstruction(u32 address) const
 {
   return PowerPC::HostRead_Instruction(address);
 }
 
-bool PPCDebugInterface::IsAlive()
+bool PPCDebugInterface::IsAlive() const
 {
   return Core::IsRunningAndStarted();
 }
 
-bool PPCDebugInterface::IsBreakpoint(unsigned int address)
+bool PPCDebugInterface::IsBreakpoint(u32 address) const
 {
   return PowerPC::breakpoints.IsAddressBreakPoint(address);
 }
 
-void PPCDebugInterface::SetBreakpoint(unsigned int address)
+void PPCDebugInterface::SetBreakpoint(u32 address)
 {
   PowerPC::breakpoints.Add(address);
 }
 
-void PPCDebugInterface::ClearBreakpoint(unsigned int address)
+void PPCDebugInterface::ClearBreakpoint(u32 address)
 {
   PowerPC::breakpoints.Remove(address);
 }
@@ -253,7 +258,7 @@ void PPCDebugInterface::ClearAllBreakpoints()
   PowerPC::breakpoints.Clear();
 }
 
-void PPCDebugInterface::ToggleBreakpoint(unsigned int address)
+void PPCDebugInterface::ToggleBreakpoint(u32 address)
 {
   if (PowerPC::breakpoints.IsAddressBreakPoint(address))
     PowerPC::breakpoints.Remove(address);
@@ -266,12 +271,12 @@ void PPCDebugInterface::ClearAllMemChecks()
   PowerPC::memchecks.Clear();
 }
 
-bool PPCDebugInterface::IsMemCheck(unsigned int address, size_t size)
+bool PPCDebugInterface::IsMemCheck(u32 address, size_t size) const
 {
   return PowerPC::memchecks.GetMemCheck(address, size) != nullptr;
 }
 
-void PPCDebugInterface::ToggleMemCheck(unsigned int address, bool read, bool write, bool log)
+void PPCDebugInterface::ToggleMemCheck(u32 address, bool read, bool write, bool log)
 {
   if (!IsMemCheck(address))
   {
@@ -296,13 +301,20 @@ void PPCDebugInterface::ToggleMemCheck(unsigned int address, bool read, bool wri
 // =======================================================
 // Separate the blocks with colors.
 // -------------
-int PPCDebugInterface::GetColor(unsigned int address)
+u32 PPCDebugInterface::GetColor(u32 address) const
 {
   if (!IsAlive())
     return 0xFFFFFF;
   if (!PowerPC::HostIsRAMAddress(address))
     return 0xeeeeee;
-  static const int colors[6] = {
+
+  Common::Symbol* symbol = g_symbolDB.GetSymbolFromAddr(address);
+  if (!symbol)
+    return 0xFFFFFF;
+  if (symbol->type != Common::Symbol::Type::Function)
+    return 0xEEEEFF;
+
+  static constexpr std::array<u32, 6> colors{
       0xd0FFFF,  // light cyan
       0xFFd0d0,  // light red
       0xd8d8FF,  // light blue
@@ -310,26 +322,21 @@ int PPCDebugInterface::GetColor(unsigned int address)
       0xd0FFd0,  // light green
       0xFFFFd0,  // light yellow
   };
-  Common::Symbol* symbol = g_symbolDB.GetSymbolFromAddr(address);
-  if (!symbol)
-    return 0xFFFFFF;
-  if (symbol->type != Common::Symbol::Type::Function)
-    return 0xEEEEFF;
-  return colors[symbol->index % 6];
+  return colors[symbol->index % colors.size()];
 }
 // =============
 
-std::string PPCDebugInterface::GetDescription(unsigned int address)
+std::string PPCDebugInterface::GetDescription(u32 address) const
 {
   return g_symbolDB.GetDescription(address);
 }
 
-unsigned int PPCDebugInterface::GetPC()
+u32 PPCDebugInterface::GetPC() const
 {
   return PowerPC::ppcState.pc;
 }
 
-void PPCDebugInterface::SetPC(unsigned int address)
+void PPCDebugInterface::SetPC(u32 address)
 {
   PowerPC::ppcState.pc = address;
 }
diff --git a/Source/Core/Core/Debugger/PPCDebugInterface.h b/Source/Core/Core/Debugger/PPCDebugInterface.h
index d0b9a9625d..54b4f7e867 100644
--- a/Source/Core/Core/Debugger/PPCDebugInterface.h
+++ b/Source/Core/Core/Debugger/PPCDebugInterface.h
@@ -7,6 +7,8 @@
 #include <cstddef>
 #include <string>
 
+#include "Common/Debug/MemoryPatches.h"
+#include "Common/Debug/Watches.h"
 #include "Common/DebugInterface.h"
 
 class PPCPatches : public Common::Debug::MemoryPatches
@@ -20,15 +22,17 @@ private:
 class PPCDebugInterface final : public Common::DebugInterface
 {
 public:
-  PPCDebugInterface() {}
+  PPCDebugInterface();
+  ~PPCDebugInterface() override;
+
   // Watches
-  std::size_t SetWatch(u32 address, const std::string& name = "") override;
+  std::size_t SetWatch(u32 address, std::string name = "") override;
   const Common::Debug::Watch& GetWatch(std::size_t index) const override;
   const std::vector<Common::Debug::Watch>& GetWatches() const override;
   void UnsetWatch(u32 address) override;
-  void UpdateWatch(std::size_t index, u32 address, const std::string& name) override;
+  void UpdateWatch(std::size_t index, u32 address, std::string name) override;
   void UpdateWatchAddress(std::size_t index, u32 address) override;
-  void UpdateWatchName(std::size_t index, const std::string& name) override;
+  void UpdateWatchName(std::size_t index, std::string name) override;
   void EnableWatch(std::size_t index) override;
   void DisableWatch(std::size_t index) override;
   bool HasEnabledWatch(u32 address) const override;
@@ -48,34 +52,32 @@ public:
   void RemovePatch(std::size_t index) override;
   void ClearPatches() override;
 
-  std::string Disassemble(unsigned int address) override;
-  std::string GetRawMemoryString(int memory, unsigned int address) override;
-  int GetInstructionSize(int /*instruction*/) override { return 4; }
-  bool IsAlive() override;
-  bool IsBreakpoint(unsigned int address) override;
-  void SetBreakpoint(unsigned int address) override;
-  void ClearBreakpoint(unsigned int address) override;
+  std::string Disassemble(u32 address) const override;
+  std::string GetRawMemoryString(int memory, u32 address) const override;
+  bool IsAlive() const override;
+  bool IsBreakpoint(u32 address) const override;
+  void SetBreakpoint(u32 address) override;
+  void ClearBreakpoint(u32 address) override;
   void ClearAllBreakpoints() override;
-  void ToggleBreakpoint(unsigned int address) override;
+  void ToggleBreakpoint(u32 address) override;
   void ClearAllMemChecks() override;
-  bool IsMemCheck(unsigned int address, size_t size = 1) override;
-  void ToggleMemCheck(unsigned int address, bool read = true, bool write = true,
-                      bool log = true) override;
-  unsigned int ReadMemory(unsigned int address) override;
+  bool IsMemCheck(u32 address, size_t size = 1) const override;
+  void ToggleMemCheck(u32 address, bool read = true, bool write = true, bool log = true) override;
+  u32 ReadMemory(u32 address) const override;
 
   enum
   {
     EXTRAMEM_ARAM = 1,
   };
 
-  unsigned int ReadExtraMemory(int memory, unsigned int address) override;
-  unsigned int ReadInstruction(unsigned int address) override;
-  unsigned int GetPC() override;
-  void SetPC(unsigned int address) override;
+  u32 ReadExtraMemory(int memory, u32 address) const override;
+  u32 ReadInstruction(u32 address) const override;
+  u32 GetPC() const override;
+  void SetPC(u32 address) override;
   void Step() override {}
   void RunToBreakpoint() override;
-  int GetColor(unsigned int address) override;
-  std::string GetDescription(unsigned int address) override;
+  u32 GetColor(u32 address) const override;
+  std::string GetDescription(u32 address) const override;
 
   void Clear() override;
 
diff --git a/Source/Core/Core/HW/DSPLLE/DSPDebugInterface.cpp b/Source/Core/Core/HW/DSPLLE/DSPDebugInterface.cpp
index a8a16554ed..ae2c567dc6 100644
--- a/Source/Core/Core/HW/DSPLLE/DSPDebugInterface.cpp
+++ b/Source/Core/Core/HW/DSPLLE/DSPDebugInterface.cpp
@@ -4,11 +4,13 @@
 
 #include "Core/HW/DSPLLE/DSPDebugInterface.h"
 
+#include <array>
 #include <cstddef>
 #include <string>
 
+#include <fmt/format.h>
+
 #include "Common/MsgHandler.h"
-#include "Common/StringUtil.h"
 #include "Core/DSP/DSPCore.h"
 #include "Core/DSP/DSPMemoryMap.h"
 #include "Core/HW/DSPLLE/DSPSymbols.h"
@@ -20,9 +22,12 @@ void DSPPatches::Patch(std::size_t index)
   PanicAlert("Patch functionality not supported in DSP module.");
 }
 
-std::size_t DSPDebugInterface::SetWatch(u32 address, const std::string& name)
+DSPDebugInterface::DSPDebugInterface() = default;
+DSPDebugInterface::~DSPDebugInterface() = default;
+
+std::size_t DSPDebugInterface::SetWatch(u32 address, std::string name)
 {
-  return m_watches.SetWatch(address, name);
+  return m_watches.SetWatch(address, std::move(name));
 }
 
 const Common::Debug::Watch& DSPDebugInterface::GetWatch(std::size_t index) const
@@ -40,9 +45,9 @@ void DSPDebugInterface::UnsetWatch(u32 address)
   m_watches.UnsetWatch(address);
 }
 
-void DSPDebugInterface::UpdateWatch(std::size_t index, u32 address, const std::string& name)
+void DSPDebugInterface::UpdateWatch(std::size_t index, u32 address, std::string name)
 {
-  return m_watches.UpdateWatch(index, address, name);
+  return m_watches.UpdateWatch(index, address, std::move(name));
 }
 
 void DSPDebugInterface::UpdateWatchAddress(std::size_t index, u32 address)
@@ -50,9 +55,9 @@ void DSPDebugInterface::UpdateWatchAddress(std::size_t index, u32 address)
   return m_watches.UpdateWatchAddress(index, address);
 }
 
-void DSPDebugInterface::UpdateWatchName(std::size_t index, const std::string& name)
+void DSPDebugInterface::UpdateWatchName(std::size_t index, std::string name)
 {
-  return m_watches.UpdateWatchName(index, name);
+  return m_watches.UpdateWatchName(index, std::move(name));
 }
 
 void DSPDebugInterface::EnableWatch(std::size_t index)
@@ -97,7 +102,7 @@ void DSPDebugInterface::SetPatch(u32 address, u32 value)
 
 void DSPDebugInterface::SetPatch(u32 address, std::vector<u8> value)
 {
-  m_patches.SetPatch(address, value);
+  m_patches.SetPatch(address, std::move(value));
 }
 
 const std::vector<Common::Debug::MemoryPatch>& DSPDebugInterface::GetPatches() const
@@ -135,13 +140,13 @@ void DSPDebugInterface::ClearPatches()
   m_patches.ClearPatches();
 }
 
-std::string DSPDebugInterface::Disassemble(unsigned int address)
+std::string DSPDebugInterface::Disassemble(u32 address) const
 {
   // we'll treat addresses as line numbers.
   return Symbols::GetLineText(address);
 }
 
-std::string DSPDebugInterface::GetRawMemoryString(int memory, unsigned int address)
+std::string DSPDebugInterface::GetRawMemoryString(int memory, u32 address) const
 {
   if (DSPCore_GetState() == State::Stopped)
     return "";
@@ -153,7 +158,7 @@ std::string DSPDebugInterface::GetRawMemoryString(int memory, unsigned int addre
     {
     case 0:
     case 0x8:
-      return StringFromFormat("%04x", dsp_imem_read(address));
+      return fmt::format("{:04x}", dsp_imem_read(address));
     default:
       return "--IMEM--";
     }
@@ -163,9 +168,9 @@ std::string DSPDebugInterface::GetRawMemoryString(int memory, unsigned int addre
     {
     case 0:
     case 1:
-      return StringFromFormat("%04x (DMEM)", dsp_dmem_read(address));
+      return fmt::format("{:04x} (DMEM)", dsp_dmem_read(address));
     case 0xf:
-      return StringFromFormat("%04x (MMIO)", g_dsp.ifx_regs[address & 0xFF]);
+      return fmt::format("{:04x} (MMIO)", g_dsp.ifx_regs[address & 0xFF]);
     default:
       return "--DMEM--";
     }
@@ -174,22 +179,22 @@ std::string DSPDebugInterface::GetRawMemoryString(int memory, unsigned int addre
   return "";
 }
 
-unsigned int DSPDebugInterface::ReadMemory(unsigned int address)
+u32 DSPDebugInterface::ReadMemory(u32 address) const
 {
   return 0;
 }
 
-unsigned int DSPDebugInterface::ReadInstruction(unsigned int address)
+u32 DSPDebugInterface::ReadInstruction(u32 address) const
 {
   return 0;
 }
 
-bool DSPDebugInterface::IsAlive()
+bool DSPDebugInterface::IsAlive() const
 {
   return true;
 }
 
-bool DSPDebugInterface::IsBreakpoint(unsigned int address)
+bool DSPDebugInterface::IsBreakpoint(u32 address) const
 {
   int real_addr = Symbols::Line2Addr(address);
   if (real_addr >= 0)
@@ -198,7 +203,7 @@ bool DSPDebugInterface::IsBreakpoint(unsigned int address)
   return false;
 }
 
-void DSPDebugInterface::SetBreakpoint(unsigned int address)
+void DSPDebugInterface::SetBreakpoint(u32 address)
 {
   int real_addr = Symbols::Line2Addr(address);
 
@@ -208,7 +213,7 @@ void DSPDebugInterface::SetBreakpoint(unsigned int address)
   }
 }
 
-void DSPDebugInterface::ClearBreakpoint(unsigned int address)
+void DSPDebugInterface::ClearBreakpoint(u32 address)
 {
   int real_addr = Symbols::Line2Addr(address);
 
@@ -223,7 +228,7 @@ void DSPDebugInterface::ClearAllBreakpoints()
   g_dsp_breakpoints.Clear();
 }
 
-void DSPDebugInterface::ToggleBreakpoint(unsigned int address)
+void DSPDebugInterface::ToggleBreakpoint(u32 address)
 {
   int real_addr = Symbols::Line2Addr(address);
   if (real_addr >= 0)
@@ -235,7 +240,7 @@ void DSPDebugInterface::ToggleBreakpoint(unsigned int address)
   }
 }
 
-bool DSPDebugInterface::IsMemCheck(unsigned int address, size_t size)
+bool DSPDebugInterface::IsMemCheck(u32 address, size_t size) const
 {
   return false;
 }
@@ -245,7 +250,7 @@ void DSPDebugInterface::ClearAllMemChecks()
   PanicAlert("MemCheck functionality not supported in DSP module.");
 }
 
-void DSPDebugInterface::ToggleMemCheck(unsigned int address, bool read, bool write, bool log)
+void DSPDebugInterface::ToggleMemCheck(u32 address, bool read, bool write, bool log)
 {
   PanicAlert("MemCheck functionality not supported in DSP module.");
 }
@@ -253,17 +258,8 @@ void DSPDebugInterface::ToggleMemCheck(unsigned int address, bool read, bool wri
 // =======================================================
 // Separate the blocks with colors.
 // -------------
-int DSPDebugInterface::GetColor(unsigned int address)
+u32 DSPDebugInterface::GetColor(u32 address) const
 {
-  static const int colors[6] = {
-      0xd0FFFF,  // light cyan
-      0xFFd0d0,  // light red
-      0xd8d8FF,  // light blue
-      0xFFd0FF,  // light purple
-      0xd0FFd0,  // light green
-      0xFFFFd0,  // light yellow
-  };
-
   // Scan backwards so we don't miss it. Hm, actually, let's not - it looks pretty good.
   int addr = -1;
   for (int i = 0; i < 1; i++)
@@ -280,21 +276,30 @@ int DSPDebugInterface::GetColor(unsigned int address)
     return 0xFFFFFF;
   if (symbol->type != Common::Symbol::Type::Function)
     return 0xEEEEFF;
-  return colors[symbol->index % 6];
+
+  static constexpr std::array<u32, 6> colors{
+      0xd0FFFF,  // light cyan
+      0xFFd0d0,  // light red
+      0xd8d8FF,  // light blue
+      0xFFd0FF,  // light purple
+      0xd0FFd0,  // light green
+      0xFFFFd0,  // light yellow
+  };
+  return colors[symbol->index % colors.size()];
 }
 // =============
 
-std::string DSPDebugInterface::GetDescription(unsigned int address)
+std::string DSPDebugInterface::GetDescription(u32 address) const
 {
   return "";  // g_symbolDB.GetDescription(address);
 }
 
-unsigned int DSPDebugInterface::GetPC()
+u32 DSPDebugInterface::GetPC() const
 {
   return Symbols::Addr2Line(DSP::g_dsp.pc);
 }
 
-void DSPDebugInterface::SetPC(unsigned int address)
+void DSPDebugInterface::SetPC(u32 address)
 {
   int new_pc = Symbols::Line2Addr(address);
   if (new_pc > 0)
diff --git a/Source/Core/Core/HW/DSPLLE/DSPDebugInterface.h b/Source/Core/Core/HW/DSPLLE/DSPDebugInterface.h
index e2d1a5242b..078b3299c6 100644
--- a/Source/Core/Core/HW/DSPLLE/DSPDebugInterface.h
+++ b/Source/Core/Core/HW/DSPLLE/DSPDebugInterface.h
@@ -8,6 +8,8 @@
 #include <string>
 
 #include "Common/CommonTypes.h"
+#include "Common/Debug/MemoryPatches.h"
+#include "Common/Debug/Watches.h"
 #include "Common/DebugInterface.h"
 
 namespace DSP::LLE
@@ -21,15 +23,17 @@ private:
 class DSPDebugInterface final : public Common::DebugInterface
 {
 public:
-  DSPDebugInterface() {}
+  DSPDebugInterface();
+  ~DSPDebugInterface() override;
+
   // Watches
-  std::size_t SetWatch(u32 address, const std::string& name = "") override;
+  std::size_t SetWatch(u32 address, std::string name = "") override;
   const Common::Debug::Watch& GetWatch(std::size_t index) const override;
   const std::vector<Common::Debug::Watch>& GetWatches() const override;
   void UnsetWatch(u32 address) override;
-  void UpdateWatch(std::size_t index, u32 address, const std::string& name) override;
+  void UpdateWatch(std::size_t index, u32 address, std::string name) override;
   void UpdateWatchAddress(std::size_t index, u32 address) override;
-  void UpdateWatchName(std::size_t index, const std::string& name) override;
+  void UpdateWatchName(std::size_t index, std::string name) override;
   void EnableWatch(std::size_t index) override;
   void DisableWatch(std::size_t index) override;
   bool HasEnabledWatch(u32 address) const override;
@@ -49,27 +53,25 @@ public:
   bool HasEnabledPatch(u32 address) const override;
   void ClearPatches() override;
 
-  std::string Disassemble(unsigned int address) override;
-  std::string GetRawMemoryString(int memory, unsigned int address) override;
-  int GetInstructionSize(int instruction) override { return 1; }
-  bool IsAlive() override;
-  bool IsBreakpoint(unsigned int address) override;
-  void SetBreakpoint(unsigned int address) override;
-  void ClearBreakpoint(unsigned int address) override;
+  std::string Disassemble(u32 address) const override;
+  std::string GetRawMemoryString(int memory, u32 address) const override;
+  bool IsAlive() const override;
+  bool IsBreakpoint(u32 address) const override;
+  void SetBreakpoint(u32 address) override;
+  void ClearBreakpoint(u32 address) override;
   void ClearAllBreakpoints() override;
-  void ToggleBreakpoint(unsigned int address) override;
+  void ToggleBreakpoint(u32 address) override;
   void ClearAllMemChecks() override;
-  bool IsMemCheck(unsigned int address, size_t size) override;
-  void ToggleMemCheck(unsigned int address, bool read = true, bool write = true,
-                      bool log = true) override;
-  unsigned int ReadMemory(unsigned int address) override;
-  unsigned int ReadInstruction(unsigned int address) override;
-  unsigned int GetPC() override;
-  void SetPC(unsigned int address) override;
+  bool IsMemCheck(u32 address, size_t size) const override;
+  void ToggleMemCheck(u32 address, bool read = true, bool write = true, bool log = true) override;
+  u32 ReadMemory(u32 address) const override;
+  u32 ReadInstruction(u32 address) const override;
+  u32 GetPC() const override;
+  void SetPC(u32 address) override;
   void Step() override {}
   void RunToBreakpoint() override;
-  int GetColor(unsigned int address) override;
-  std::string GetDescription(unsigned int address) override;
+  u32 GetColor(u32 address) const override;
+  std::string GetDescription(u32 address) const override;
 
   void Clear() override;
 
diff --git a/Source/Core/Core/PowerPC/PPCSymbolDB.cpp b/Source/Core/Core/PowerPC/PPCSymbolDB.cpp
index f5a84f2d07..1412533bf4 100644
--- a/Source/Core/Core/PowerPC/PPCSymbolDB.cpp
+++ b/Source/Core/Core/PowerPC/PPCSymbolDB.cpp
@@ -5,6 +5,7 @@
 #include "Core/PowerPC/PPCSymbolDB.h"
 
 #include <algorithm>
+#include <cstring>
 #include <map>
 #include <string>
 #include <utility>
diff --git a/Source/Core/DolphinQt/Debugger/CodeViewWidget.cpp b/Source/Core/DolphinQt/Debugger/CodeViewWidget.cpp
index d413bb0cd0..1934abde67 100644
--- a/Source/Core/DolphinQt/Debugger/CodeViewWidget.cpp
+++ b/Source/Core/DolphinQt/Debugger/CodeViewWidget.cpp
@@ -124,8 +124,8 @@ void CodeViewWidget::Update()
 
   for (int i = 0; i < rowCount(); i++)
   {
-    u32 addr = m_address - ((rowCount() / 2) * 4) + i * 4;
-    u32 color = PowerPC::debug_interface.GetColor(addr);
+    const u32 addr = m_address - ((rowCount() / 2) * 4) + i * 4;
+    const u32 color = PowerPC::debug_interface.GetColor(addr);
     auto* bp_item = new QTableWidgetItem;
     auto* addr_item = new QTableWidgetItem(QStringLiteral("%1").arg(addr, 8, 16, QLatin1Char('0')));