Merge pull request #10085 from Pokechu22/C26495

Fix all uninitialized variable warnings (C26495)

Source/Core/AudioCommon/Mixer.h

@@ -99,7 +99,7 @@ private:
   bool m_is_stretching = false;
   AudioCommon::AudioStretcher m_stretcher;
   AudioCommon::SurroundDecoder m_surround_decoder;
-  std::array<short, MAX_SAMPLES * 2> m_scratch_buffer;
+  std::array<short, MAX_SAMPLES * 2> m_scratch_buffer{};
 
   WaveFileWriter m_wave_writer_dtk;
   WaveFileWriter m_wave_writer_dsp;

Source/Core/AudioCommon/OpenALStream.h

@@ -53,7 +53,7 @@ class OpenALStream final : public SoundStream
 {
 #ifdef _WIN32
 public:
-  OpenALStream() : m_source(0) {}
+  OpenALStream() = default;
   ~OpenALStream() override;
   bool Init() override;
   void SetVolume(int volume) override;
@@ -68,9 +68,9 @@ private:
   Common::Flag m_run_thread;
 
   std::vector<short> m_realtime_buffer;
-  std::array<ALuint, OAL_BUFFERS> m_buffers;
+  std::array<ALuint, OAL_BUFFERS> m_buffers{};
-  ALuint m_source;
+  ALuint m_source = 0;
-  ALfloat m_volume;
+  ALfloat m_volume = 1;
 
 #endif  // _WIN32
 };

Source/Core/Common/Config/ConfigInfo.h

@@ -23,7 +23,7 @@ using UnderlyingType = typename std::enable_if_t<std::is_enum<T>{}, std::underly
 
 struct Location
 {
-  System system;
+  System system{};
   std::string section;
   std::string key;
 

Source/Core/Common/FileUtil.h

@@ -85,11 +85,11 @@ enum
 
 namespace File
 {
-// FileSystem tree node/
+// FileSystem tree node
 struct FSTEntry
 {
-  bool isDirectory;
+  bool isDirectory = false;
-  u64 size;                  // File length, or for directories, recursive count of children
+  u64 size = 0;              // File length, or for directories, recursive count of children
   std::string physicalName;  // Name on disk
   std::string virtualName;   // Name in FST names table
   std::vector<FSTEntry> children;

Source/Core/Common/FixedSizeQueue.h

@@ -78,7 +78,7 @@ public:
   bool empty() const noexcept { return size() == 0; }
 
 private:
-  std::array<T, N> storage;
+  std::array<T, N> storage{};
   int head = 0;
   int tail = 0;
   // Sacrifice 4 bytes for a simpler implementation. may optimize away in the future.

Source/Core/Common/IOFile.h

@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include <array>
 #include <cstddef>
 #include <cstdio>
 #include <string>
@@ -57,6 +58,18 @@ public:
     return m_good;
   }
 
+  template <typename T, std::size_t N>
+  bool ReadArray(std::array<T, N>* elements, size_t* num_read = nullptr)
+  {
+    return ReadArray(elements->data(), elements->size(), num_read);
+  }
+
+  template <typename T, std::size_t N>
+  bool WriteArray(const std::array<T, N>& elements)
+  {
+    return WriteArray(elements.data(), elements.size());
+  }
+
   bool ReadBytes(void* data, size_t length)
   {
     return ReadArray(reinterpret_cast<char*>(data), length);

Source/Core/Common/LinearDiskCache.h

@@ -153,7 +153,7 @@ private:
                   std::min(Common::scm_rev_git_str.size(), sizeof(ver)));
     }
 
-    u32 id;
+    u32 id = 0;
     const u16 key_t_size = sizeof(K);
     const u16 value_t_size = sizeof(V);
     char ver[40] = {};
@@ -161,5 +161,5 @@ private:
   } m_header;
 
   File::IOFile m_file;
-  u32 m_num_entries;
+  u32 m_num_entries = 0;
 };

Source/Core/Common/Logging/ConsoleListener.h

@@ -14,5 +14,5 @@ public:
   void Log(Common::Log::LOG_LEVELS level, const char* text) override;
 
 private:
-  bool m_use_color;
+  bool m_use_color = false;
 };

Source/Core/Common/SPSCQueue.h

@@ -98,7 +98,7 @@ private:
         delete next_ptr;
     }
 
-    T current;
+    T current{};
     std::atomic<ElementPtr*> next;
   };
 

Source/Core/Core/ActionReplay.h

@@ -16,10 +16,10 @@ namespace ActionReplay
 {
 struct AREntry
 {
-  AREntry() {}
+  AREntry() = default;
   AREntry(u32 _addr, u32 _value) : cmd_addr(_addr), value(_value) {}
-  u32 cmd_addr;
+  u32 cmd_addr = 0;
-  u32 value;
+  u32 value = 0;
 };
 constexpr bool operator==(const AREntry& left, const AREntry& right)
 {

Source/Core/Core/BootManager.cpp

@@ -64,44 +64,44 @@ public:
 
   // These store if the relevant setting should be reset back later (true) or if it should be left
   // alone on restore (false)
-  bool bSetEmulationSpeed;
+  bool bSetEmulationSpeed = false;
-  bool bSetVolume;
+  bool bSetVolume = false;
-  std::array<bool, MAX_BBMOTES> bSetWiimoteSource;
+  std::array<bool, MAX_BBMOTES> bSetWiimoteSource{};
-  std::array<bool, SerialInterface::MAX_SI_CHANNELS> bSetPads;
+  std::array<bool, SerialInterface::MAX_SI_CHANNELS> bSetPads{};
-  std::array<bool, ExpansionInterface::MAX_EXI_CHANNELS> bSetEXIDevice;
+  std::array<bool, ExpansionInterface::MAX_EXI_CHANNELS> bSetEXIDevice{};
 
 private:
-  bool valid;
+  bool valid = false;
-  bool bCPUThread;
+  bool bCPUThread = false;
-  bool bJITFollowBranch;
+  bool bJITFollowBranch = false;
-  bool bSyncGPUOnSkipIdleHack;
+  bool bSyncGPUOnSkipIdleHack = false;
-  bool bFloatExceptions;
+  bool bFloatExceptions = false;
-  bool bDivideByZeroExceptions;
+  bool bDivideByZeroExceptions = false;
-  bool bFPRF;
+  bool bFPRF = false;
-  bool bAccurateNaNs;
+  bool bAccurateNaNs = false;
-  bool bMMU;
+  bool bMMU = false;
-  bool bLowDCBZHack;
+  bool bLowDCBZHack = false;
-  bool bDisableICache;
+  bool bDisableICache = false;
-  bool m_EnableJIT;
+  bool m_EnableJIT = false;
-  bool bSyncGPU;
+  bool bSyncGPU = false;
-  int iSyncGpuMaxDistance;
+  int iSyncGpuMaxDistance = 0;
-  int iSyncGpuMinDistance;
+  int iSyncGpuMinDistance = 0;
-  float fSyncGpuOverclock;
+  float fSyncGpuOverclock = 0;
-  bool bFastDiscSpeed;
+  bool bFastDiscSpeed = false;
-  bool bDSPHLE;
+  bool bDSPHLE = false;
-  bool bHLE_BS2;
+  bool bHLE_BS2 = false;
-  int iSelectedLanguage;
+  int iSelectedLanguage = 0;
-  PowerPC::CPUCore cpu_core;
+  PowerPC::CPUCore cpu_core = PowerPC::CPUCore::Interpreter;
-  int Volume;
+  int Volume = 0;
-  float m_EmulationSpeed;
+  float m_EmulationSpeed = 0;
-  float m_OCFactor;
+  float m_OCFactor = 0;
-  bool m_OCEnable;
+  bool m_OCEnable = false;
-  bool m_bt_passthrough_enabled;
+  bool m_bt_passthrough_enabled = false;
   std::string sBackend;
   std::string m_strGPUDeterminismMode;
-  std::array<WiimoteSource, MAX_BBMOTES> iWiimoteSource;
+  std::array<WiimoteSource, MAX_BBMOTES> iWiimoteSource{};
-  std::array<SerialInterface::SIDevices, SerialInterface::MAX_SI_CHANNELS> Pads;
+  std::array<SerialInterface::SIDevices, SerialInterface::MAX_SI_CHANNELS> Pads{};
-  std::array<ExpansionInterface::TEXIDevices, ExpansionInterface::MAX_EXI_CHANNELS> m_EXIDevice;
+  std::array<ExpansionInterface::TEXIDevices, ExpansionInterface::MAX_EXI_CHANNELS> m_EXIDevice{};
 };
 
 void ConfigCache::SaveConfig(const SConfig& config)

Source/Core/Core/CheatSearch.cpp

@@ -101,87 +101,87 @@ std::vector<u8> Cheats::GetValueAsByteVector(const Cheats::SearchValue& value)
 namespace
 {
 template <typename T>
-static PowerPC::TryReadResult<T>
+static std::optional<PowerPC::ReadResult<T>>
 TryReadValueFromEmulatedMemory(u32 addr, PowerPC::RequestedAddressSpace space);
 
 template <>
-PowerPC::TryReadResult<u8> TryReadValueFromEmulatedMemory(u32 addr,
+std::optional<PowerPC::ReadResult<u8>>
-                                                          PowerPC::RequestedAddressSpace space)
+TryReadValueFromEmulatedMemory(u32 addr, PowerPC::RequestedAddressSpace space)
 {
   return PowerPC::HostTryReadU8(addr, space);
 }
 
 template <>
-PowerPC::TryReadResult<u16> TryReadValueFromEmulatedMemory(u32 addr,
+std::optional<PowerPC::ReadResult<u16>>
-                                                           PowerPC::RequestedAddressSpace space)
+TryReadValueFromEmulatedMemory(u32 addr, PowerPC::RequestedAddressSpace space)
 {
   return PowerPC::HostTryReadU16(addr, space);
 }
 
 template <>
-PowerPC::TryReadResult<u32> TryReadValueFromEmulatedMemory(u32 addr,
+std::optional<PowerPC::ReadResult<u32>>
-                                                           PowerPC::RequestedAddressSpace space)
+TryReadValueFromEmulatedMemory(u32 addr, PowerPC::RequestedAddressSpace space)
 {
   return PowerPC::HostTryReadU32(addr, space);
 }
 
 template <>
-PowerPC::TryReadResult<u64> TryReadValueFromEmulatedMemory(u32 addr,
+std::optional<PowerPC::ReadResult<u64>>
-                                                           PowerPC::RequestedAddressSpace space)
+TryReadValueFromEmulatedMemory(u32 addr, PowerPC::RequestedAddressSpace space)
 {
   return PowerPC::HostTryReadU64(addr, space);
 }
 
 template <>
-PowerPC::TryReadResult<s8> TryReadValueFromEmulatedMemory(u32 addr,
+std::optional<PowerPC::ReadResult<s8>>
-                                                          PowerPC::RequestedAddressSpace space)
+TryReadValueFromEmulatedMemory(u32 addr, PowerPC::RequestedAddressSpace space)
 {
   auto tmp = PowerPC::HostTryReadU8(addr, space);
   if (!tmp)
-    return PowerPC::TryReadResult<s8>();
+    return std::nullopt;
-  return PowerPC::TryReadResult<s8>(tmp.translated, Common::BitCast<s8>(tmp.value));
+  return PowerPC::ReadResult<s8>(tmp->translated, Common::BitCast<s8>(tmp->value));
 }
 
 template <>
-PowerPC::TryReadResult<s16> TryReadValueFromEmulatedMemory(u32 addr,
+std::optional<PowerPC::ReadResult<s16>>
-                                                           PowerPC::RequestedAddressSpace space)
+TryReadValueFromEmulatedMemory(u32 addr, PowerPC::RequestedAddressSpace space)
 {
   auto tmp = PowerPC::HostTryReadU16(addr, space);
   if (!tmp)
-    return PowerPC::TryReadResult<s16>();
+    return std::nullopt;
-  return PowerPC::TryReadResult<s16>(tmp.translated, Common::BitCast<s16>(tmp.value));
+  return PowerPC::ReadResult<s16>(tmp->translated, Common::BitCast<s16>(tmp->value));
 }
 
 template <>
-PowerPC::TryReadResult<s32> TryReadValueFromEmulatedMemory(u32 addr,
+std::optional<PowerPC::ReadResult<s32>>
-                                                           PowerPC::RequestedAddressSpace space)
+TryReadValueFromEmulatedMemory(u32 addr, PowerPC::RequestedAddressSpace space)
 {
   auto tmp = PowerPC::HostTryReadU32(addr, space);
   if (!tmp)
-    return PowerPC::TryReadResult<s32>();
+    return std::nullopt;
-  return PowerPC::TryReadResult<s32>(tmp.translated, Common::BitCast<s32>(tmp.value));
+  return PowerPC::ReadResult<s32>(tmp->translated, Common::BitCast<s32>(tmp->value));
 }
 
 template <>
-PowerPC::TryReadResult<s64> TryReadValueFromEmulatedMemory(u32 addr,
+std::optional<PowerPC::ReadResult<s64>>
-                                                           PowerPC::RequestedAddressSpace space)
+TryReadValueFromEmulatedMemory(u32 addr, PowerPC::RequestedAddressSpace space)
 {
   auto tmp = PowerPC::HostTryReadU64(addr, space);
   if (!tmp)
-    return PowerPC::TryReadResult<s64>();
+    return std::nullopt;
-  return PowerPC::TryReadResult<s64>(tmp.translated, Common::BitCast<s64>(tmp.value));
+  return PowerPC::ReadResult<s64>(tmp->translated, Common::BitCast<s64>(tmp->value));
 }
 
 template <>
-PowerPC::TryReadResult<float> TryReadValueFromEmulatedMemory(u32 addr,
+std::optional<PowerPC::ReadResult<float>>
-                                                             PowerPC::RequestedAddressSpace space)
+TryReadValueFromEmulatedMemory(u32 addr, PowerPC::RequestedAddressSpace space)
 {
   return PowerPC::HostTryReadF32(addr, space);
 }
 
 template <>
-PowerPC::TryReadResult<double> TryReadValueFromEmulatedMemory(u32 addr,
+std::optional<PowerPC::ReadResult<double>>
-                                                              PowerPC::RequestedAddressSpace space)
+TryReadValueFromEmulatedMemory(u32 addr, PowerPC::RequestedAddressSpace space)
 {
   return PowerPC::HostTryReadF64(addr, space);
 }
@@ -230,11 +230,11 @@ Cheats::NewSearch(const std::vector<Cheats::MemoryRange>& memory_ranges,
         if (!current_value)
           continue;
 
-        if (validator(current_value.value))
+        if (validator(current_value->value))
         {
           auto& r = results.emplace_back();
-          r.m_value = current_value.value;
+          r.m_value = current_value->value;
-          r.m_value_state = current_value.translated ?
+          r.m_value_state = current_value->translated ?
                                 Cheats::SearchResultValueState::ValueFromVirtualMemory :
                                 Cheats::SearchResultValueState::ValueFromPhysicalMemory;
           r.m_address = addr;
@@ -284,11 +284,11 @@ Cheats::NextSearch(const std::vector<Cheats::SearchResult<T>>& previous_results,
       // if the previous state was invalid we always update the value to avoid getting stuck in an
       // invalid state
       if (!previous_result.IsValueValid() ||
-          validator(current_value.value, previous_result.m_value))
+          validator(current_value->value, previous_result.m_value))
       {
         auto& r = results.emplace_back();
-        r.m_value = current_value.value;
+        r.m_value = current_value->value;
-        r.m_value_state = current_value.translated ?
+        r.m_value_state = current_value->translated ?
                               Cheats::SearchResultValueState::ValueFromVirtualMemory :
                               Cheats::SearchResultValueState::ValueFromPhysicalMemory;
         r.m_address = addr;

Source/Core/Core/DSP/DSPCore.h

@@ -279,10 +279,10 @@ struct DSP_Regs
 struct DSPInitOptions
 {
   // DSP IROM blob, which is where the DSP boots from. Embedded into the DSP.
-  std::array<u16, DSP_IROM_SIZE> irom_contents;
+  std::array<u16, DSP_IROM_SIZE> irom_contents{};
 
   // DSP DROM blob, which contains resampling coefficients.
-  std::array<u16, DSP_COEF_SIZE> coef_contents;
+  std::array<u16, DSP_COEF_SIZE> coef_contents{};
 
   // Core used to emulate the DSP.
   // Default: JIT64.

Source/Core/Core/DSP/Jit/x64/DSPJitRegCache.cpp

@@ -100,8 +100,7 @@ static Gen::OpArg GetRegisterPointer(size_t reg)
 #define STATIC_REG_ACCS
 //#undef STATIC_REG_ACCS
 
-DSPJitRegCache::DSPJitRegCache(DSPEmitter& emitter)
+DSPJitRegCache::DSPJitRegCache(DSPEmitter& emitter) : m_emitter(emitter), m_is_temporary(false)
-    : m_emitter(emitter), m_is_temporary(false), m_is_merged(false)
 {
   for (X64CachedReg& xreg : m_xregs)
   {
@@ -188,13 +187,10 @@ DSPJitRegCache::DSPJitRegCache(DSPEmitter& emitter)
     m_regs[i + DSP_REG_AXL0].shift = 0;
     m_regs[i + DSP_REG_AXH0].shift = 16;
   }
-
-  m_use_ctr = 0;
 }
 
 DSPJitRegCache::DSPJitRegCache(const DSPJitRegCache& cache)
-    : m_regs(cache.m_regs), m_xregs(cache.m_xregs), m_emitter(cache.m_emitter),
+    : m_regs(cache.m_regs), m_xregs(cache.m_xregs), m_emitter(cache.m_emitter), m_is_temporary(true)
-      m_is_temporary(true), m_is_merged(false)
 {
 }
 

Source/Core/Core/DSP/Jit/x64/DSPJitRegCache.h

@@ -170,14 +170,14 @@ private:
   void MovToMemory(size_t reg);
   void FlushMemBackedRegs();
 
-  std::array<DynamicReg, 37> m_regs;
+  std::array<DynamicReg, 37> m_regs{};
-  std::array<X64CachedReg, 16> m_xregs;
+  std::array<X64CachedReg, 16> m_xregs{};
 
   DSPEmitter& m_emitter;
   bool m_is_temporary;
-  bool m_is_merged;
+  bool m_is_merged = false;
 
-  int m_use_ctr;
+  int m_use_ctr = 0;
 };
 
 }  // namespace DSP::JIT::x64

Source/Core/Core/Debugger/Debugger_SymbolMap.h

@@ -15,7 +15,7 @@ namespace Dolphin_Debugger
 struct CallstackEntry
 {
   std::string Name;
-  u32 vAddress;
+  u32 vAddress = 0;
 };
 
 bool GetCallstack(std::vector<CallstackEntry>& output);

Source/Core/Core/Debugger/Dump.cpp

@@ -9,7 +9,7 @@
 #include "Common/CommonTypes.h"
 #include "Common/IOFile.h"
 
-CDump::CDump(const std::string& filename) : m_pData(nullptr)
+CDump::CDump(const std::string& filename)
 {
   File::IOFile pStream(filename, "rb");
   if (pStream)

Source/Core/Core/Debugger/Dump.h

@@ -27,9 +27,9 @@ private:
     STRUCTUR_SIZE = 0x2BC
   };
 
-  u8* m_pData;
+  u8* m_pData = nullptr;
 
-  size_t m_size;
+  size_t m_size = 0;
 
   u32 Read32(u32 _pos);
 };

Source/Core/Core/Debugger/RSO.h

@@ -131,7 +131,7 @@ public:
   u32 GetImportsNameTable() const;
 
 private:
-  RSOHeader m_header;
+  RSOHeader m_header{};
   std::string m_name;
   u32 m_address = 0;
 };

Source/Core/Core/FifoPlayer/FifoAnalyzer.h

@@ -22,8 +22,8 @@ struct CPMemory
 {
   TVtxDesc vtxDesc;
   std::array<VAT, CP_NUM_VAT_REG> vtxAttr;
-  std::array<u32, CP_NUM_ARRAYS> arrayBases;
+  std::array<u32, CP_NUM_ARRAYS> arrayBases{};
-  std::array<u32, CP_NUM_ARRAYS> arrayStrides;
+  std::array<u32, CP_NUM_ARRAYS> arrayStrides{};
 };
 
 void LoadCPReg(u32 subCmd, u32 value, CPMemory& cpMem);

Source/Core/Core/FifoPlayer/FifoDataFile.cpp

@@ -120,19 +120,19 @@ bool FifoDataFile::Save(const std::string& filename)
   PadFile(m_Frames.size() * sizeof(FileFrameInfo), file);
 
   u64 bpMemOffset = file.Tell();
-  file.WriteArray(m_BPMem, BP_MEM_SIZE);
+  file.WriteArray(m_BPMem);
 
   u64 cpMemOffset = file.Tell();
-  file.WriteArray(m_CPMem, CP_MEM_SIZE);
+  file.WriteArray(m_CPMem);
 
   u64 xfMemOffset = file.Tell();
-  file.WriteArray(m_XFMem, XF_MEM_SIZE);
+  file.WriteArray(m_XFMem);
 
   u64 xfRegsOffset = file.Tell();
-  file.WriteArray(m_XFRegs, XF_REGS_SIZE);
+  file.WriteArray(m_XFRegs);
 
   u64 texMemOffset = file.Tell();
-  file.WriteArray(m_TexMem, TEX_MEM_SIZE);
+  file.WriteArray(m_TexMem);
 
   // Write header
   FileHeader header;
@@ -285,27 +285,27 @@ std::unique_ptr<FifoDataFile> FifoDataFile::Load(const std::string& filename, bo
 
   u32 size = std::min<u32>(BP_MEM_SIZE, header.bpMemSize);
   file.Seek(header.bpMemOffset, SEEK_SET);
-  file.ReadArray(dataFile->m_BPMem, size);
+  file.ReadArray(&dataFile->m_BPMem);
 
   size = std::min<u32>(CP_MEM_SIZE, header.cpMemSize);
   file.Seek(header.cpMemOffset, SEEK_SET);
-  file.ReadArray(dataFile->m_CPMem, size);
+  file.ReadArray(&dataFile->m_CPMem);
 
   size = std::min<u32>(XF_MEM_SIZE, header.xfMemSize);
   file.Seek(header.xfMemOffset, SEEK_SET);
-  file.ReadArray(dataFile->m_XFMem, size);
+  file.ReadArray(&dataFile->m_XFMem);
 
   size = std::min<u32>(XF_REGS_SIZE, header.xfRegsSize);
   file.Seek(header.xfRegsOffset, SEEK_SET);
-  file.ReadArray(dataFile->m_XFRegs, size);
+  file.ReadArray(&dataFile->m_XFRegs);
 
   // Texture memory saving was added in version 4.
-  std::memset(dataFile->m_TexMem, 0, TEX_MEM_SIZE);
+  dataFile->m_TexMem.fill(0);
   if (dataFile->m_Version >= 4)
   {
     size = std::min<u32>(TEX_MEM_SIZE, header.texMemSize);
     file.Seek(header.texMemOffset, SEEK_SET);
-    file.ReadArray(dataFile->m_TexMem, size);
+    file.ReadArray(&dataFile->m_TexMem);
   }
 
   if (!file.IsGood())

Source/Core/Core/FifoPlayer/FifoDataFile.h

@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include <array>
 #include <memory>
 #include <string>
 #include <vector>
@@ -25,18 +26,18 @@ struct MemoryUpdate
     TMEM = 0x08,
   };
 
-  u32 fifoPosition;
+  u32 fifoPosition = 0;
-  u32 address;
+  u32 address = 0;
   std::vector<u8> data;
-  Type type;
+  Type type{};
 };
 
 struct FifoFrameInfo
 {
   std::vector<u8> fifoData;
 
-  u32 fifoStart;
+  u32 fifoStart = 0;
-  u32 fifoEnd;
+  u32 fifoEnd = 0;
 
   // Must be sorted by fifoPosition
   std::vector<MemoryUpdate> memoryUpdates;
@@ -63,11 +64,11 @@ public:
   bool HasBrokenEFBCopies() const;
   bool ShouldGenerateFakeVIUpdates() const;
 
-  u32* GetBPMem() { return m_BPMem; }
+  u32* GetBPMem() { return m_BPMem.data(); }
-  u32* GetCPMem() { return m_CPMem; }
+  u32* GetCPMem() { return m_CPMem.data(); }
-  u32* GetXFMem() { return m_XFMem; }
+  u32* GetXFMem() { return m_XFMem.data(); }
-  u32* GetXFRegs() { return m_XFRegs; }
+  u32* GetXFRegs() { return m_XFRegs.data(); }
-  u8* GetTexMem() { return m_TexMem; }
+  u8* GetTexMem() { return m_TexMem.data(); }
   u32 GetRamSizeReal() { return m_ram_size_real; }
   u32 GetExRamSizeReal() { return m_exram_size_real; }
 
@@ -93,13 +94,13 @@ private:
   static void ReadMemoryUpdates(u64 fileOffset, u32 numUpdates,
                                 std::vector<MemoryUpdate>& memUpdates, File::IOFile& file);
 
-  u32 m_BPMem[BP_MEM_SIZE];
+  std::array<u32, BP_MEM_SIZE> m_BPMem{};
-  u32 m_CPMem[CP_MEM_SIZE];
+  std::array<u32, CP_MEM_SIZE> m_CPMem{};
-  u32 m_XFMem[XF_MEM_SIZE];
+  std::array<u32, XF_MEM_SIZE> m_XFMem{};
-  u32 m_XFRegs[XF_REGS_SIZE];
+  std::array<u32, XF_REGS_SIZE> m_XFRegs{};
-  u8 m_TexMem[TEX_MEM_SIZE];
+  std::array<u8, TEX_MEM_SIZE> m_TexMem{};
-  u32 m_ram_size_real;
+  u32 m_ram_size_real = 0;
-  u32 m_exram_size_real;
+  u32 m_exram_size_real = 0;
 
   u32 m_Flags = 0;
   u32 m_Version = 0;

Source/Core/Core/HW/AddressSpace.cpp

@@ -354,8 +354,8 @@ struct SmallBlockAccessors : Accessors
   }
 
 private:
-  u8** alloc_base;
+  u8** alloc_base = nullptr;
-  u32 size;
+  u32 size = 0;
 };
 
 struct NullAccessors : Accessors

Source/Core/Core/HW/DSPHLE/UCodes/AX.h

@@ -82,24 +82,24 @@ protected:
   };
 
   // 32 * 5 because 32 samples per millisecond, for max 5 milliseconds.
-  int m_samples_left[32 * 5];
+  int m_samples_left[32 * 5]{};
-  int m_samples_right[32 * 5];
+  int m_samples_right[32 * 5]{};
-  int m_samples_surround[32 * 5];
+  int m_samples_surround[32 * 5]{};
-  int m_samples_auxA_left[32 * 5];
+  int m_samples_auxA_left[32 * 5]{};
-  int m_samples_auxA_right[32 * 5];
+  int m_samples_auxA_right[32 * 5]{};
-  int m_samples_auxA_surround[32 * 5];
+  int m_samples_auxA_surround[32 * 5]{};
-  int m_samples_auxB_left[32 * 5];
+  int m_samples_auxB_left[32 * 5]{};
-  int m_samples_auxB_right[32 * 5];
+  int m_samples_auxB_right[32 * 5]{};
-  int m_samples_auxB_surround[32 * 5];
+  int m_samples_auxB_surround[32 * 5]{};
 
-  u16 m_cmdlist[512];
+  u16 m_cmdlist[512]{};
   u32 m_cmdlist_size = 0;
 
   // Table of coefficients for polyphase sample rate conversion.
   // The coefficients aren't always available (they are part of the DSP DROM)
   // so we also need to know if they are valid or not.
   std::optional<u32> m_coeffs_checksum = std::nullopt;
-  std::array<s16, 0x800> m_coeffs;
+  std::array<s16, 0x800> m_coeffs{};
 
   u16 m_compressor_pos = 0;
 

Source/Core/Core/HW/DSPHLE/UCodes/AXWii.h

@@ -21,27 +21,27 @@ public:
 
 protected:
   // Additional AUX buffers
-  int m_samples_auxC_left[32 * 3];
+  int m_samples_auxC_left[32 * 3]{};
-  int m_samples_auxC_right[32 * 3];
+  int m_samples_auxC_right[32 * 3]{};
-  int m_samples_auxC_surround[32 * 3];
+  int m_samples_auxC_surround[32 * 3]{};
 
   // Wiimote buffers
-  int m_samples_wm0[6 * 3];
+  int m_samples_wm0[6 * 3]{};
-  int m_samples_aux0[6 * 3];
+  int m_samples_aux0[6 * 3]{};
-  int m_samples_wm1[6 * 3];
+  int m_samples_wm1[6 * 3]{};
-  int m_samples_aux1[6 * 3];
+  int m_samples_aux1[6 * 3]{};
-  int m_samples_wm2[6 * 3];
+  int m_samples_wm2[6 * 3]{};
-  int m_samples_aux2[6 * 3];
+  int m_samples_aux2[6 * 3]{};
-  int m_samples_wm3[6 * 3];
+  int m_samples_wm3[6 * 3]{};
-  int m_samples_aux3[6 * 3];
+  int m_samples_aux3[6 * 3]{};
 
   // Are we implementing an old version of AXWii which still has updates?
-  bool m_old_axwii;
+  bool m_old_axwii = false;
 
   // Last volume values for MAIN and AUX. Used to generate volume ramps to
   // interpolate nicely between old and new volume values.
-  u16 m_last_main_volume;
+  u16 m_last_main_volume = 0;
-  u16 m_last_aux_volumes[3];
+  u16 m_last_aux_volumes[3]{};
 
   // If needed, extract the updates related fields from a PB. We need to
   // reinject them afterwards so that the correct PB typs is written to RAM.

Source/Core/Core/HW/DVD/DVDThread.cpp

@@ -37,26 +37,26 @@ namespace DVDThread
 {
 struct ReadRequest
 {
-  bool copy_to_ram;
+  bool copy_to_ram = false;
-  u32 output_address;
+  u32 output_address = 0;
-  u64 dvd_offset;
+  u64 dvd_offset = 0;
-  u32 length;
+  u32 length = 0;
-  DiscIO::Partition partition;
+  DiscIO::Partition partition{};
 
   // This determines which code DVDInterface will run to reply
   // to the emulated software. We can't use callbacks,
   // because function pointers can't be stored in savestates.
-  DVDInterface::ReplyType reply_type;
+  DVDInterface::ReplyType reply_type = DVDInterface::ReplyType::NoReply;
 
   // IDs are used to uniquely identify a request. They must not be
   // identical to IDs of any other requests that currently exist, but
   // it's fine to re-use IDs of requests that have existed in the past.
-  u64 id;
+  u64 id = 0;
 
   // Only used for logging
-  u64 time_started_ticks;
+  u64 time_started_ticks = 0;
-  u64 realtime_started_us;
+  u64 realtime_started_us = 0;
-  u64 realtime_done_us;
+  u64 realtime_done_us = 0;
 };
 
 using ReadResult = std::pair<ReadRequest, std::vector<u8>>;

Source/Core/Core/HW/EXI/EXI_Device.h

@@ -65,7 +65,7 @@ public:
   // For savestates. storing it here seemed cleaner than requiring each implementation to report its
   // type. I know this class is set up like an interface, but no code requires it to be strictly
   // such.
-  TEXIDevices m_device_type;
+  TEXIDevices m_device_type = TEXIDevices::EXIDEVICE_NONE;
 
 private:
   // Byte transfer function for this device

Source/Core/Core/HW/EXI/EXI_DeviceEthernet.h

@@ -404,8 +404,8 @@ private:
     defined(__OpenBSD__) || defined(__NetBSD__) || defined(__HAIKU__)
     sf::UdpSocket m_sf_socket;
     sf::IpAddress m_sf_recipient_ip;
-    char m_in_frame[9004];
+    char m_in_frame[9004]{};
-    char m_out_frame[9004];
+    char m_out_frame[9004]{};
     std::thread m_read_thread;
     Common::Flag m_read_enabled;
     Common::Flag m_read_thread_shutdown;

Source/Core/Core/HW/GCMemcard/GCIFile.h

@@ -25,7 +25,7 @@ public:
   DEntry m_gci_header;
   std::vector<GCMBlock> m_save_data;
   std::vector<u16> m_used_blocks;
-  bool m_dirty;
+  bool m_dirty = false;
   std::string m_filename;
 };
 }  // namespace Memcard

Source/Core/Core/HW/GCMemcard/GCMemcard.h

@@ -82,7 +82,7 @@ private:
 struct GCMemcardAnimationFrameRGBA8
 {
   std::vector<u32> image_data;
-  u8 delay;
+  u8 delay = 0;
 };
 
 // size of a single memory card block in bytes

Source/Core/Core/HW/GCMemcard/GCMemcardBase.h

@@ -23,10 +23,8 @@ public:
   virtual void ClearAll() = 0;
   virtual void DoState(PointerWrap& p) = 0;
   u32 GetCardId() const { return m_nintendo_card_id; }
-  bool IsAddressInBounds(u32 address) const { return address <= (m_memory_card_size - 1); }
 
 protected:
   int m_card_index;
   u16 m_nintendo_card_id;
-  u32 m_memory_card_size;
 };

Source/Core/Core/HW/GCMemcard/GCMemcardRaw.h

@@ -31,6 +31,8 @@ public:
   void DoState(PointerWrap& p) override;
 
 private:
+  bool IsAddressInBounds(u32 address) const { return address <= (m_memory_card_size - 1); }
+
   std::string m_filename;
   std::unique_ptr<u8[]> m_memcard_data;
   std::unique_ptr<u8[]> m_flush_buffer;
@@ -38,4 +40,5 @@ private:
   std::mutex m_flush_mutex;
   Common::Event m_flush_trigger;
   Common::Flag m_dirty;
+  u32 m_memory_card_size;
 };

Source/Core/Core/HW/SI/SI.cpp

@@ -96,9 +96,9 @@ union USIChannelIn_Lo
 // SI Channel
 struct SSIChannel
 {
-  USIChannelOut out;
+  USIChannelOut out{};
-  USIChannelIn_Hi in_hi;
+  USIChannelIn_Hi in_hi{};
-  USIChannelIn_Lo in_lo;
+  USIChannelIn_Lo in_lo{};
   std::unique_ptr<ISIDevice> device;
 
   bool has_recent_device_change = false;

Source/Core/Core/HW/SI/SI_DeviceGBA.h

@@ -60,7 +60,7 @@ private:
 
   GBASockServer m_sock_server;
   NextAction m_next_action = NextAction::SendCommand;
-  EBufferCommands m_last_cmd;
+  EBufferCommands m_last_cmd = EBufferCommands::CMD_STATUS;
   u64 m_timestamp_sent = 0;
 };
 }  // namespace SerialInterface

Source/Core/Core/HW/WiiSaveStructs.h

@@ -91,8 +91,9 @@ public:
       File = 1,
       Directory = 2,
     };
-    u8 mode, attributes;
+    u8 mode = 0;
-    Type type;
+    u8 attributes = 0;
+    Type type{};
     /// File name relative to the title data directory.
     std::string path;
     // Only valid for regular (i.e. non-directory) files.

Source/Core/Core/HW/WiimoteCommon/DataReport.h

@@ -49,7 +49,7 @@ public:
 
   virtual u32 GetDataSize() const = 0;
 
-  u8* data_ptr;
+  u8* data_ptr = nullptr;
 };
 
 std::unique_ptr<DataReportManipulator> MakeDataReportManipulator(InputReportID rpt_id,

Source/Core/Core/HW/WiimoteEmu/Camera.cpp

@@ -94,7 +94,7 @@ void CameraLogic::Update(const Common::Matrix44& transform, Common::Vec2 field_o
   struct CameraPoint
   {
     IRBasic::IRObject position;
-    u8 size;
+    u8 size = 0;
   };
 
   std::array<CameraPoint, leds.size()> camera_points;

Source/Core/Core/HW/WiimoteEmu/Camera.h

@@ -155,10 +155,10 @@ private:
   int BusRead(u8 slave_addr, u8 addr, int count, u8* data_out) override;
   int BusWrite(u8 slave_addr, u8 addr, int count, const u8* data_in) override;
 
-  Register m_reg_data;
+  Register m_reg_data{};
 
   // When disabled the camera does not respond on the bus.
   // Change is triggered by wiimote report 0x13.
-  bool m_is_enabled;
+  bool m_is_enabled = false;
 };
 }  // namespace WiimoteEmu

Source/Core/Core/HW/WiimoteEmu/Dynamics.cpp

@@ -79,10 +79,6 @@ Common::Quaternion ComplementaryFilter(const Common::Quaternion& gyroscope,
   }
 }
 
-IMUCursorState::IMUCursorState() : rotation{Common::Quaternion::Identity()}
-{
-}
-
 void EmulateShake(PositionalState* state, ControllerEmu::Shake* const shake_group,
                   float time_elapsed)
 {

Source/Core/Core/HW/WiimoteEmu/Dynamics.h

@@ -23,27 +23,25 @@ using MathUtil::GRAVITY_ACCELERATION;
 struct PositionalState
 {
   // meters
-  Common::Vec3 position;
+  Common::Vec3 position{};
   // meters/second
-  Common::Vec3 velocity;
+  Common::Vec3 velocity{};
   // meters/second^2
-  Common::Vec3 acceleration;
+  Common::Vec3 acceleration{};
 };
 
 struct RotationalState
 {
   // radians
-  Common::Vec3 angle;
+  Common::Vec3 angle{};
   // radians/second
-  Common::Vec3 angular_velocity;
+  Common::Vec3 angular_velocity{};
 };
 
 struct IMUCursorState
 {
-  IMUCursorState();
-
   // Rotation of world around device.
-  Common::Quaternion rotation;
+  Common::Quaternion rotation = Common::Quaternion::Identity();
 
   float recentered_pitch = {};
 };
@@ -51,6 +49,7 @@ struct IMUCursorState
 // Contains both positional and rotational state.
 struct MotionState : PositionalState, RotationalState
 {
+  MotionState() = default;
 };
 
 // Note that 'gyroscope' is rotation of world around device.

Source/Core/Core/HW/WiimoteEmu/Extension/Drums.h

@@ -112,10 +112,10 @@ private:
   ControllerEmu::SettingValue<double> m_hit_strength_setting;
 
   // Holds previous user input state to watch for "new" hits.
-  u8 m_prev_pad_input;
+  u8 m_prev_pad_input = 0;
   // Holds new drum pad hits that still need velocity data to be sent.
-  u8 m_new_pad_hits;
+  u8 m_new_pad_hits = 0;
   // Holds how many more frames to send each drum-pad bit.
-  std::array<u8, 6> m_pad_remaining_frames;
+  std::array<u8, 6> m_pad_remaining_frames{};
 };
 }  // namespace WiimoteEmu

Source/Core/Core/HW/WiimoteEmu/Speaker.h

@@ -64,11 +64,11 @@ private:
   int BusRead(u8 slave_addr, u8 addr, int count, u8* data_out) override;
   int BusWrite(u8 slave_addr, u8 addr, int count, const u8* data_in) override;
 
-  Register reg_data;
+  Register reg_data{};
 
   // TODO: What actions reset this state?
   // Is this actually in the register somewhere?
-  ADPCMState adpcm_state;
+  ADPCMState adpcm_state{};
 
   ControllerEmu::SettingValue<double> m_speaker_pan_setting;
 };

Source/Core/Core/HotkeyManager.h

@@ -232,8 +232,8 @@ public:
   void LoadDefaults(const ControllerInterface& ciface) override;
 
 private:
-  std::array<ControllerEmu::Buttons*, NUM_HOTKEY_GROUPS> m_keys;
+  std::array<ControllerEmu::Buttons*, NUM_HOTKEY_GROUPS> m_keys{};
-  std::array<ControllerEmu::ControlGroup*, NUM_HOTKEY_GROUPS> m_hotkey_groups;
+  std::array<ControllerEmu::ControlGroup*, NUM_HOTKEY_GROUPS> m_hotkey_groups{};
 };
 
 namespace HotkeyManagerEmu

Source/Core/Core/IOS/DI/DI.h

@@ -110,12 +110,9 @@ private:
   struct ExecutingCommandInfo
   {
     ExecutingCommandInfo() {}
-    ExecutingCommandInfo(u32 request_address)
+    ExecutingCommandInfo(u32 request_address) : m_request_address(request_address) {}
-        : m_request_address(request_address), m_copy_diimmbuf(false)
+    u32 m_request_address = 0;
-    {
+    bool m_copy_diimmbuf = false;
-    }
-    u32 m_request_address;
-    bool m_copy_diimmbuf;
   };
 
   friend class ::CBoot;

Source/Core/Core/IOS/ES/ES.h

@@ -377,9 +377,9 @@ private:
   struct OpenedContent
   {
     bool m_opened = false;
-    u64 m_fd;
+    u64 m_fd = 0;
     u64 m_title_id = 0;
-    ES::Content m_content;
+    ES::Content m_content{};
     u32 m_uid = 0;
   };
 

Source/Core/Core/IOS/IOSC.h

@@ -237,8 +237,8 @@ private:
     void DoState(PointerWrap& p);
 
     bool in_use = false;
-    ObjectType type;
+    ObjectType type{};
-    ObjectSubType subtype;
+    ObjectSubType subtype{};
     std::vector<u8> data;
     u32 misc_data = 0;
     u32 owner_mask = 0;

Source/Core/Core/IOS/Network/NCD/WiiNetConfig.h

@@ -137,7 +137,7 @@ private:
   };
 #pragma pack(pop)
 
-  ConfigData m_data;
+  ConfigData m_data{};
 };
 }  // namespace Net
 }  // namespace IOS::HLE

Source/Core/Core/IOS/Network/SSL.h

@@ -65,18 +65,18 @@ enum SSL_IOCTL
 
 struct WII_SSL
 {
-  mbedtls_ssl_context ctx;
+  mbedtls_ssl_context ctx{};
-  mbedtls_ssl_config config;
+  mbedtls_ssl_config config{};
-  mbedtls_ssl_session session;
+  mbedtls_ssl_session session{};
-  mbedtls_entropy_context entropy;
+  mbedtls_entropy_context entropy{};
-  mbedtls_ctr_drbg_context ctr_drbg;
+  mbedtls_ctr_drbg_context ctr_drbg{};
-  mbedtls_x509_crt cacert;
+  mbedtls_x509_crt cacert{};
-  mbedtls_x509_crt clicert;
+  mbedtls_x509_crt clicert{};
-  mbedtls_pk_context pk;
+  mbedtls_pk_context pk{};
   int sockfd = -1;
   int hostfd = -1;
   std::string hostname;
-  bool active;
+  bool active = false;
 };
 
 class NetSSLDevice : public Device

Source/Core/Core/IOS/Network/Socket.h

@@ -233,10 +233,10 @@ public:
 
   struct PollCommand
   {
-    u32 request_addr;
+    u32 request_addr = 0;
-    u32 buffer_out;
+    u32 buffer_out = 0;
     std::vector<pollfd_t> wii_fds;
-    s64 timeout;
+    s64 timeout = 0;
   };
 
   static s32 GetNetErrorCode(s32 ret, std::string_view caller, bool is_rw);
@@ -292,7 +292,7 @@ private:
   void UpdatePollCommands();
 
   std::unordered_map<s32, WiiSocket> WiiSockets;
-  s32 errno_last;
+  s32 errno_last = 0;
   std::vector<PollCommand> pending_polls;
   std::chrono::time_point<std::chrono::high_resolution_clock> last_time =
       std::chrono::high_resolution_clock::now();

Source/Core/Core/IOS/SDIO/SDIOSlot0.h

@@ -159,7 +159,7 @@ private:
   u32 m_block_length = 0;
   u32 m_bus_width = 0;
 
-  std::array<u32, 0x200 / sizeof(u32)> m_registers;
+  std::array<u32, 0x200 / sizeof(u32)> m_registers{};
 
   File::IOFile m_card;
 };

Source/Core/Core/IOS/WFS/WFSI.h

@@ -50,20 +50,20 @@ private:
 
   std::string m_device_name;
 
-  mbedtls_aes_context m_aes_ctx;
+  mbedtls_aes_context m_aes_ctx{};
   u8 m_aes_key[0x10] = {};
   u8 m_aes_iv[0x10] = {};
 
   ES::TMDReader m_tmd;
   std::string m_base_extract_path;
 
-  u64 m_current_title_id;
+  u64 m_current_title_id = 0;
   std::string m_current_title_id_str;
-  u16 m_current_group_id;
+  u16 m_current_group_id = 0;
   std::string m_current_group_id_str;
-  u64 m_import_title_id;
+  u64 m_import_title_id = 0;
   std::string m_import_title_id_str;
-  u16 m_import_group_id;
+  u16 m_import_group_id = 0;
   std::string m_import_group_id_str;
 
   // Set on IMPORT_TITLE_INIT when the next profile application should not delete

Source/Core/Core/IOS/WFS/WFSSRV.h

@@ -84,10 +84,10 @@ private:
 
   struct FileDescriptor
   {
-    bool in_use;
+    bool in_use = false;
     std::string path;
-    int mode;
+    int mode = 0;
-    size_t position;
+    size_t position = 0;
     File::IOFile file;
 
     bool Open();

Source/Core/Core/NetPlayClient.h

@@ -82,11 +82,11 @@ public:
 class Player
 {
 public:
-  PlayerId pid;
+  PlayerId pid{};
   std::string name;
   std::string revision;
-  u32 ping;
+  u32 ping = 0;
-  SyncIdentifierComparison game_status;
+  SyncIdentifierComparison game_status = SyncIdentifierComparison::Unknown;
 
   bool IsHost() const { return pid == 1; }
 };
@@ -153,7 +153,7 @@ protected:
   struct AsyncQueueEntry
   {
     sf::Packet packet;
-    u8 channel_id;
+    u8 channel_id = 0;
   };
 
   void ClearBuffers();

Source/Core/Core/NetPlayProto.h

@@ -28,84 +28,84 @@ namespace NetPlay
 {
 struct NetSettings
 {
-  bool m_CPUthread;
+  bool m_CPUthread = false;
-  PowerPC::CPUCore m_CPUcore;
+  PowerPC::CPUCore m_CPUcore{};
-  bool m_EnableCheats;
+  bool m_EnableCheats = false;
-  int m_SelectedLanguage;
+  int m_SelectedLanguage = 0;
-  bool m_OverrideRegionSettings;
+  bool m_OverrideRegionSettings = false;
-  bool m_DSPHLE;
+  bool m_DSPHLE = false;
-  bool m_DSPEnableJIT;
+  bool m_DSPEnableJIT = false;
-  bool m_WriteToMemcard;
+  bool m_WriteToMemcard = false;
-  bool m_RAMOverrideEnable;
+  bool m_RAMOverrideEnable = false;
-  u32 m_Mem1Size;
+  u32 m_Mem1Size = 0;
-  u32 m_Mem2Size;
+  u32 m_Mem2Size = 0;
-  DiscIO::Region m_FallbackRegion;
+  DiscIO::Region m_FallbackRegion{};
-  bool m_AllowSDWrites;
+  bool m_AllowSDWrites = false;
-  bool m_CopyWiiSave;
+  bool m_CopyWiiSave = false;
-  bool m_OCEnable;
+  bool m_OCEnable = false;
-  float m_OCFactor;
+  float m_OCFactor = 0;
-  std::array<ExpansionInterface::TEXIDevices, 3> m_EXIDevice;
+  std::array<ExpansionInterface::TEXIDevices, 3> m_EXIDevice{};
 
-  std::array<u32, Config::SYSCONF_SETTINGS.size()> m_SYSCONFSettings;
+  std::array<u32, Config::SYSCONF_SETTINGS.size()> m_SYSCONFSettings{};
 
-  bool m_EFBAccessEnable;
+  bool m_EFBAccessEnable = false;
-  bool m_BBoxEnable;
+  bool m_BBoxEnable = false;
-  bool m_ForceProgressive;
+  bool m_ForceProgressive = false;
-  bool m_EFBToTextureEnable;
+  bool m_EFBToTextureEnable = false;
-  bool m_XFBToTextureEnable;
+  bool m_XFBToTextureEnable = false;
-  bool m_DisableCopyToVRAM;
+  bool m_DisableCopyToVRAM = false;
-  bool m_ImmediateXFBEnable;
+  bool m_ImmediateXFBEnable = false;
-  bool m_EFBEmulateFormatChanges;
+  bool m_EFBEmulateFormatChanges = false;
-  int m_SafeTextureCacheColorSamples;
+  int m_SafeTextureCacheColorSamples = 0;
-  bool m_PerfQueriesEnable;
+  bool m_PerfQueriesEnable = false;
-  bool m_FloatExceptions;
+  bool m_FloatExceptions = false;
-  bool m_DivideByZeroExceptions;
+  bool m_DivideByZeroExceptions = false;
-  bool m_FPRF;
+  bool m_FPRF = false;
-  bool m_AccurateNaNs;
+  bool m_AccurateNaNs = false;
-  bool m_DisableICache;
+  bool m_DisableICache = false;
-  bool m_SyncOnSkipIdle;
+  bool m_SyncOnSkipIdle = false;
-  bool m_SyncGPU;
+  bool m_SyncGPU = false;
-  int m_SyncGpuMaxDistance;
+  int m_SyncGpuMaxDistance = 0;
-  int m_SyncGpuMinDistance;
+  int m_SyncGpuMinDistance = 0;
-  float m_SyncGpuOverclock;
+  float m_SyncGpuOverclock = 0;
-  bool m_JITFollowBranch;
+  bool m_JITFollowBranch = false;
-  bool m_FastDiscSpeed;
+  bool m_FastDiscSpeed = false;
-  bool m_MMU;
+  bool m_MMU = false;
-  bool m_Fastmem;
+  bool m_Fastmem = false;
-  bool m_SkipIPL;
+  bool m_SkipIPL = false;
-  bool m_LoadIPLDump;
+  bool m_LoadIPLDump = false;
-  bool m_VertexRounding;
+  bool m_VertexRounding = false;
-  int m_InternalResolution;
+  int m_InternalResolution = 0;
-  bool m_EFBScaledCopy;
+  bool m_EFBScaledCopy = false;
-  bool m_FastDepthCalc;
+  bool m_FastDepthCalc = false;
-  bool m_EnablePixelLighting;
+  bool m_EnablePixelLighting = false;
-  bool m_WidescreenHack;
+  bool m_WidescreenHack = false;
-  bool m_ForceFiltering;
+  bool m_ForceFiltering = false;
-  int m_MaxAnisotropy;
+  int m_MaxAnisotropy = 0;
-  bool m_ForceTrueColor;
+  bool m_ForceTrueColor = false;
-  bool m_DisableCopyFilter;
+  bool m_DisableCopyFilter = false;
-  bool m_DisableFog;
+  bool m_DisableFog = false;
-  bool m_ArbitraryMipmapDetection;
+  bool m_ArbitraryMipmapDetection = false;
-  float m_ArbitraryMipmapDetectionThreshold;
+  float m_ArbitraryMipmapDetectionThreshold = 0;
-  bool m_EnableGPUTextureDecoding;
+  bool m_EnableGPUTextureDecoding = false;
-  bool m_DeferEFBCopies;
+  bool m_DeferEFBCopies = false;
-  int m_EFBAccessTileSize;
+  int m_EFBAccessTileSize = 0;
-  bool m_EFBAccessDeferInvalidation;
+  bool m_EFBAccessDeferInvalidation = false;
 
-  bool m_StrictSettingsSync;
+  bool m_StrictSettingsSync = false;
-  bool m_SyncSaveData;
+  bool m_SyncSaveData = false;
-  bool m_SyncCodes;
+  bool m_SyncCodes = false;
   std::string m_SaveDataRegion;
-  bool m_SyncAllWiiSaves;
+  bool m_SyncAllWiiSaves = false;
-  std::array<int, 4> m_WiimoteExtension;
+  std::array<int, 4> m_WiimoteExtension{};
-  bool m_GolfMode;
+  bool m_GolfMode = false;
-  bool m_UseFMA;
+  bool m_UseFMA = false;
-  bool m_HideRemoteGBAs;
+  bool m_HideRemoteGBAs = false;
 
   // These aren't sent over the network directly
-  bool m_IsHosting;
+  bool m_IsHosting = false;
-  bool m_HostInputAuthority;
+  bool m_HostInputAuthority = false;
-  std::array<std::string, 4> m_GBARomPaths;
+  std::array<std::string, 4> m_GBARomPaths{};
 };
 
 struct NetTraversalConfig
@@ -226,7 +226,7 @@ enum : u8
 
 struct WiimoteInput
 {
-  u8 report_id;
+  u8 report_id = 0;
   std::vector<u8> data;
 };
 using PlayerId = u8;
@@ -235,19 +235,19 @@ using PadIndex = s8;
 using PadMappingArray = std::array<PlayerId, 4>;
 struct GBAConfig
 {
-  bool enabled;
+  bool enabled = false;
-  bool has_rom;
+  bool has_rom = false;
   std::string title;
-  std::array<u8, 20> hash;
+  std::array<u8, 20> hash{};
 };
 using GBAConfigArray = std::array<GBAConfig, 4>;
 
 struct PadDetails
 {
-  std::string player_name;
+  std::string player_name{};
-  bool is_local;
+  bool is_local = false;
-  int local_pad;
+  int local_pad = 0;
-  bool hide_gba;
+  bool hide_gba = false;
 };
 
 std::string GetPlayerMappingString(PlayerId pid, const PadMappingArray& pad_map,

Source/Core/Core/NetPlayServer.h

@@ -80,16 +80,16 @@ private:
   class Client
   {
   public:
-    PlayerId pid;
+    PlayerId pid{};
     std::string name;
     std::string revision;
-    SyncIdentifierComparison game_status;
+    SyncIdentifierComparison game_status = SyncIdentifierComparison::Unknown;
-    bool has_ipl_dump;
+    bool has_ipl_dump = false;
-    bool has_hardware_fma;
+    bool has_hardware_fma = false;
 
-    ENetPeer* socket;
+    ENetPeer* socket = nullptr;
-    u32 ping;
+    u32 ping = 0;
-    u32 current_game;
+    u32 current_game = 0;
 
     Common::QoSSession qos_session;
 
@@ -106,16 +106,16 @@ private:
   struct AsyncQueueEntry
   {
     sf::Packet packet;
-    PlayerId target_pid;
+    PlayerId target_pid{};
-    TargetMode target_mode;
+    TargetMode target_mode{};
-    u8 channel_id;
+    u8 channel_id = 0;
   };
 
   struct ChunkedDataQueueEntry
   {
     sf::Packet packet;
-    PlayerId target_pid;
+    PlayerId target_pid{};
-    TargetMode target_mode;
+    TargetMode target_mode{};
     std::string title;
   };
 
@@ -171,7 +171,7 @@ private:
   std::map<PlayerId, Client> m_players;
 
   std::unordered_map<u32, std::vector<std::pair<PlayerId, u64>>> m_timebase_by_frame;
-  bool m_desync_detected;
+  bool m_desync_detected = false;
 
   struct
   {
@@ -191,7 +191,7 @@ private:
   Common::Event m_chunked_data_event;
   Common::Event m_chunked_data_complete_event;
   std::thread m_chunked_data_thread;
-  u32 m_next_chunked_data_id;
+  u32 m_next_chunked_data_id = 0;
   std::unordered_map<u32, unsigned int> m_chunked_data_complete_count;
   bool m_abort_chunked_data = false;
 

Source/Core/Core/PowerPC/Jit64/Jit.h

@@ -266,9 +266,9 @@ private:
 
   Jit64AsmRoutineManager asm_routines{*this};
 
-  bool m_enable_blr_optimization;
+  bool m_enable_blr_optimization = false;
-  bool m_cleanup_after_stackfault;
+  bool m_cleanup_after_stackfault = false;
-  u8* m_stack;
+  u8* m_stack = nullptr;
 
   HyoutaUtilities::RangeSizeSet<u8*> m_free_ranges_near;
   HyoutaUtilities::RangeSizeSet<u8*> m_free_ranges_far;

Source/Core/Core/PowerPC/Jit64Common/EmuCodeBlock.h

@@ -134,9 +134,9 @@ protected:
   FarCodeCache m_far_code;
 
   // Backed up when we switch to far code.
-  u8* m_near_code;
+  u8* m_near_code = nullptr;
-  u8* m_near_code_end;
+  u8* m_near_code_end = nullptr;
-  bool m_near_code_write_failed;
+  bool m_near_code_write_failed = false;
 
   std::unordered_map<u8*, TrampolineInfo> m_back_patch_info;
   std::unordered_map<u8*, u8*> m_exception_handler_at_loc;

Source/Core/Core/PowerPC/JitCommon/JitCache.h

@@ -205,5 +205,5 @@ private:
 
   // This array is indexed with the masked PC and likely holds the correct block id.
   // This is used as a fast cache of block_map used in the assembly dispatcher.
-  std::array<JitBlock*, FAST_BLOCK_MAP_ELEMENTS> fast_block_map;  // start_addr & mask -> number
+  std::array<JitBlock*, FAST_BLOCK_MAP_ELEMENTS> fast_block_map{};  // start_addr & mask -> number
 };

Source/Core/Core/PowerPC/MMU.cpp

@@ -3,7 +3,6 @@
 
 #include "Core/PowerPC/MMU.h"
 
-#include <cassert>
 #include <cstddef>
 #include <cstring>
 #include <string>
@@ -469,34 +468,35 @@ u32 HostRead_Instruction(const u32 address)
   return ReadFromHardware<XCheckTLBFlag::OpcodeNoException, u32>(address);
 }
 
-TryReadResult<u32> HostTryReadInstruction(const u32 address, RequestedAddressSpace space)
+std::optional<ReadResult<u32>> HostTryReadInstruction(const u32 address,
+                                                      RequestedAddressSpace space)
 {
   if (!HostIsInstructionRAMAddress(address, space))
-    return TryReadResult<u32>();
+    return std::nullopt;
 
   switch (space)
   {
   case RequestedAddressSpace::Effective:
   {
     const u32 value = ReadFromHardware<XCheckTLBFlag::OpcodeNoException, u32>(address);
-    return TryReadResult<u32>(!!MSR.DR, value);
+    return ReadResult<u32>(!!MSR.DR, value);
   }
   case RequestedAddressSpace::Physical:
   {
     const u32 value = ReadFromHardware<XCheckTLBFlag::OpcodeNoException, u32, true>(address);
-    return TryReadResult<u32>(false, value);
+    return ReadResult<u32>(false, value);
   }
   case RequestedAddressSpace::Virtual:
   {
     if (!MSR.DR)
-      return TryReadResult<u32>();
+      return std::nullopt;
     const u32 value = ReadFromHardware<XCheckTLBFlag::OpcodeNoException, u32>(address);
-    return TryReadResult<u32>(true, value);
+    return ReadResult<u32>(true, value);
   }
   }
 
-  assert(0);
+  ASSERT(0);
-  return TryReadResult<u32>();
+  return std::nullopt;
 }
 
 static void Memcheck(u32 address, u64 var, bool write, size_t size)
@@ -575,70 +575,70 @@ float Read_F32(const u32 address)
 }
 
 template <typename T>
-static TryReadResult<T> HostTryReadUX(const u32 address, RequestedAddressSpace space)
+static std::optional<ReadResult<T>> HostTryReadUX(const u32 address, RequestedAddressSpace space)
 {
   if (!HostIsRAMAddress(address, space))
-    return TryReadResult<T>();
+    return std::nullopt;
 
   switch (space)
   {
   case RequestedAddressSpace::Effective:
   {
     T value = ReadFromHardware<XCheckTLBFlag::NoException, T>(address);
-    return TryReadResult<T>(!!MSR.DR, std::move(value));
+    return ReadResult<T>(!!MSR.DR, std::move(value));
   }
   case RequestedAddressSpace::Physical:
   {
     T value = ReadFromHardware<XCheckTLBFlag::NoException, T, true>(address);
-    return TryReadResult<T>(false, std::move(value));
+    return ReadResult<T>(false, std::move(value));
   }
   case RequestedAddressSpace::Virtual:
   {
     if (!MSR.DR)
-      return TryReadResult<T>();
+      return std::nullopt;
     T value = ReadFromHardware<XCheckTLBFlag::NoException, T>(address);
-    return TryReadResult<T>(true, std::move(value));
+    return ReadResult<T>(true, std::move(value));
   }
   }
 
-  assert(0);
+  ASSERT(0);
-  return TryReadResult<T>();
+  return std::nullopt;
 }
 
-TryReadResult<u8> HostTryReadU8(u32 address, RequestedAddressSpace space)
+std::optional<ReadResult<u8>> HostTryReadU8(u32 address, RequestedAddressSpace space)
 {
   return HostTryReadUX<u8>(address, space);
 }
 
-TryReadResult<u16> HostTryReadU16(u32 address, RequestedAddressSpace space)
+std::optional<ReadResult<u16>> HostTryReadU16(u32 address, RequestedAddressSpace space)
 {
   return HostTryReadUX<u16>(address, space);
 }
 
-TryReadResult<u32> HostTryReadU32(u32 address, RequestedAddressSpace space)
+std::optional<ReadResult<u32>> HostTryReadU32(u32 address, RequestedAddressSpace space)
 {
   return HostTryReadUX<u32>(address, space);
 }
 
-TryReadResult<u64> HostTryReadU64(u32 address, RequestedAddressSpace space)
+std::optional<ReadResult<u64>> HostTryReadU64(u32 address, RequestedAddressSpace space)
 {
   return HostTryReadUX<u64>(address, space);
 }
 
-TryReadResult<float> HostTryReadF32(u32 address, RequestedAddressSpace space)
+std::optional<ReadResult<float>> HostTryReadF32(u32 address, RequestedAddressSpace space)
 {
   const auto result = HostTryReadUX<u32>(address, space);
   if (!result)
-    return TryReadResult<float>();
+    return std::nullopt;
-  return TryReadResult<float>(result.translated, Common::BitCast<float>(result.value));
+  return ReadResult<float>(result->translated, Common::BitCast<float>(result->value));
 }
 
-TryReadResult<double> HostTryReadF64(u32 address, RequestedAddressSpace space)
+std::optional<ReadResult<double>> HostTryReadF64(u32 address, RequestedAddressSpace space)
 {
   const auto result = HostTryReadUX<u64>(address, space);
   if (!result)
-    return TryReadResult<double>();
+    return std::nullopt;
-  return TryReadResult<double>(result.translated, Common::BitCast<double>(result.value));
+  return ReadResult<double>(result->translated, Common::BitCast<double>(result->value));
 }
 
 u32 Read_U8_ZX(const u32 address)
@@ -764,62 +764,68 @@ void HostWrite_F64(const double var, const u32 address)
   HostWrite_U64(integral, address);
 }
 
-static TryWriteResult HostTryWriteUX(const u32 var, const u32 address, const u32 size,
+static std::optional<WriteResult> HostTryWriteUX(const u32 var, const u32 address, const u32 size,
                                                  RequestedAddressSpace space)
 {
   if (!HostIsRAMAddress(address, space))
-    return TryWriteResult();
+    return std::nullopt;
 
   switch (space)
   {
   case RequestedAddressSpace::Effective:
     WriteToHardware<XCheckTLBFlag::NoException>(address, var, size);
-    return TryWriteResult(!!MSR.DR);
+    return WriteResult(!!MSR.DR);
   case RequestedAddressSpace::Physical:
     WriteToHardware<XCheckTLBFlag::NoException, true>(address, var, size);
-    return TryWriteResult(false);
+    return WriteResult(false);
   case RequestedAddressSpace::Virtual:
     if (!MSR.DR)
-      return TryWriteResult();
+      return std::nullopt;
     WriteToHardware<XCheckTLBFlag::NoException>(address, var, size);
-    return TryWriteResult(true);
+    return WriteResult(true);
   }
 
-  assert(0);
+  ASSERT(0);
-  return TryWriteResult();
+  return std::nullopt;
 }
 
-TryWriteResult HostTryWriteU8(const u32 var, const u32 address, RequestedAddressSpace space)
+std::optional<WriteResult> HostTryWriteU8(const u32 var, const u32 address,
+                                          RequestedAddressSpace space)
 {
   return HostTryWriteUX(var, address, 1, space);
 }
 
-TryWriteResult HostTryWriteU16(const u32 var, const u32 address, RequestedAddressSpace space)
+std::optional<WriteResult> HostTryWriteU16(const u32 var, const u32 address,
+                                           RequestedAddressSpace space)
 {
   return HostTryWriteUX(var, address, 2, space);
 }
 
-TryWriteResult HostTryWriteU32(const u32 var, const u32 address, RequestedAddressSpace space)
+std::optional<WriteResult> HostTryWriteU32(const u32 var, const u32 address,
+                                           RequestedAddressSpace space)
 {
   return HostTryWriteUX(var, address, 4, space);
 }
 
-TryWriteResult HostTryWriteU64(const u64 var, const u32 address, RequestedAddressSpace space)
+std::optional<WriteResult> HostTryWriteU64(const u64 var, const u32 address,
+                                           RequestedAddressSpace space)
 {
-  const TryWriteResult result = HostTryWriteUX(static_cast<u32>(var >> 32), address, 4, space);
+  const auto result = HostTryWriteUX(static_cast<u32>(var >> 32), address, 4, space);
   if (!result)
     return result;
 
   return HostTryWriteUX(static_cast<u32>(var), address + 4, 4, space);
 }
 
-TryWriteResult HostTryWriteF32(const float var, const u32 address, RequestedAddressSpace space)
+std::optional<WriteResult> HostTryWriteF32(const float var, const u32 address,
+                                           RequestedAddressSpace space)
 {
   const u32 integral = Common::BitCast<u32>(var);
   return HostTryWriteU32(integral, address, space);
 }
 
-TryWriteResult HostTryWriteF64(const double var, const u32 address, RequestedAddressSpace space)
+std::optional<WriteResult> HostTryWriteF64(const double var, const u32 address,
+                                           RequestedAddressSpace space)
 {
   const u64 integral = Common::BitCast<u64>(var);
   return HostTryWriteU64(integral, address, space);
@@ -841,25 +847,26 @@ std::string HostGetString(u32 address, size_t size)
   return s;
 }
 
-TryReadResult<std::string> HostTryReadString(u32 address, size_t size, RequestedAddressSpace space)
+std::optional<ReadResult<std::string>> HostTryReadString(u32 address, size_t size,
+                                                         RequestedAddressSpace space)
 {
   auto c = HostTryReadU8(address, space);
   if (!c)
-    return TryReadResult<std::string>();
+    return std::nullopt;
-  if (c.value == 0)
+  if (c->value == 0)
-    return TryReadResult<std::string>(c.translated, "");
+    return ReadResult<std::string>(c->translated, "");
 
   std::string s;
-  s += static_cast<char>(c.value);
+  s += static_cast<char>(c->value);
   while (size == 0 || s.length() < size)
   {
     ++address;
     const auto res = HostTryReadU8(address, space);
-    if (!res || res.value == 0)
+    if (!res || res->value == 0)
       break;
-    s += static_cast<char>(res.value);
+    s += static_cast<char>(res->value);
   }
-  return TryReadResult<std::string>(c.translated, std::move(s));
+  return ReadResult<std::string>(c->translated, std::move(s));
 }
 
 bool IsOptimizableRAMAddress(const u32 address)
@@ -925,7 +932,7 @@ bool HostIsRAMAddress(u32 address, RequestedAddressSpace space)
     return IsRAMAddress<XCheckTLBFlag::NoException>(address, true);
   }
 
-  assert(0);
+  ASSERT(0);
   return false;
 }
 
@@ -947,7 +954,7 @@ bool HostIsInstructionRAMAddress(u32 address, RequestedAddressSpace space)
     return IsRAMAddress<XCheckTLBFlag::OpcodeNoException>(address, true);
   }
 
-  assert(0);
+  ASSERT(0);
   return false;
 }
 

Source/Core/Core/PowerPC/MMU.h

@@ -37,11 +37,8 @@ u32 HostRead_Instruction(u32 address);
 std::string HostGetString(u32 address, size_t size = 0);
 
 template <typename T>
-struct TryReadResult
+struct ReadResult
 {
-  // whether the read succeeded; if false, the other fields should not be touched
-  bool success;
-
   // whether the address had to be translated (given address was treated as virtual) or not (given
   // address was treated as physical)
   bool translated;
@@ -49,37 +46,31 @@ struct TryReadResult
   // the actual value that was read
   T value;
 
-  TryReadResult() : success(false) {}
+  ReadResult(bool translated_, T&& value_) : translated(translated_), value(std::forward<T>(value_))
-  TryReadResult(bool translated_, T&& value_)
-      : success(true), translated(translated_), value(std::move(value_))
   {
   }
-  TryReadResult(bool translated_, const T& value_)
+  ReadResult(bool translated_, const T& value_) : translated(translated_), value(value_) {}
-      : success(true), translated(translated_), value(value_)
-  {
-  }
-  explicit operator bool() const { return success; }
 };
 
 // Try to read a value from emulated memory at the given address in the given memory space.
-// If the read succeeds, the returned TryReadResult contains the read value and information on
+// If the read succeeds, the returned value will be present and the ReadResult contains the read
-// whether the given address had to be translated or not. Unlike the HostRead functions, this does
+// value and information on whether the given address had to be translated or not. Unlike the
-// not raise a user-visible alert on failure.
+// HostRead functions, this does not raise a user-visible alert on failure.
-TryReadResult<u8> HostTryReadU8(u32 address,
+std::optional<ReadResult<u8>>
-                                RequestedAddressSpace space = RequestedAddressSpace::Effective);
+HostTryReadU8(u32 address, RequestedAddressSpace space = RequestedAddressSpace::Effective);
-TryReadResult<u16> HostTryReadU16(u32 address,
+std::optional<ReadResult<u16>>
-                                  RequestedAddressSpace space = RequestedAddressSpace::Effective);
+HostTryReadU16(u32 address, RequestedAddressSpace space = RequestedAddressSpace::Effective);
-TryReadResult<u32> HostTryReadU32(u32 address,
+std::optional<ReadResult<u32>>
-                                  RequestedAddressSpace space = RequestedAddressSpace::Effective);
+HostTryReadU32(u32 address, RequestedAddressSpace space = RequestedAddressSpace::Effective);
-TryReadResult<u64> HostTryReadU64(u32 address,
+std::optional<ReadResult<u64>>
-                                  RequestedAddressSpace space = RequestedAddressSpace::Effective);
+HostTryReadU64(u32 address, RequestedAddressSpace space = RequestedAddressSpace::Effective);
-TryReadResult<float> HostTryReadF32(u32 address,
+std::optional<ReadResult<float>>
-                                    RequestedAddressSpace space = RequestedAddressSpace::Effective);
+HostTryReadF32(u32 address, RequestedAddressSpace space = RequestedAddressSpace::Effective);
-TryReadResult<double>
+std::optional<ReadResult<double>>
 HostTryReadF64(u32 address, RequestedAddressSpace space = RequestedAddressSpace::Effective);
-TryReadResult<u32>
+std::optional<ReadResult<u32>>
 HostTryReadInstruction(u32 address, RequestedAddressSpace space = RequestedAddressSpace::Effective);
-TryReadResult<std::string>
+std::optional<ReadResult<std::string>>
 HostTryReadString(u32 address, size_t size = 0,
                   RequestedAddressSpace space = RequestedAddressSpace::Effective);
 
@@ -93,35 +84,36 @@ void HostWrite_U64(u64 var, u32 address);
 void HostWrite_F32(float var, u32 address);
 void HostWrite_F64(double var, u32 address);
 
-struct TryWriteResult
+struct WriteResult
 {
-  // whether the write succeeded; if false, the other fields should not be touched
-  bool success;
-
   // whether the address had to be translated (given address was treated as virtual) or not (given
   // address was treated as physical)
   bool translated;
 
-  TryWriteResult() : success(false) {}
+  explicit WriteResult(bool translated_) : translated(translated_) {}
-  TryWriteResult(bool translated_) : success(true), translated(translated_) {}
-  explicit operator bool() const { return success; }
 };
 
 // Try to a write a value to memory at the given address in the given memory space.
 // If the write succeeds, the returned TryWriteResult contains information on whether the given
 // address had to be translated or not. Unlike the HostWrite functions, this does not raise a
 // user-visible alert on failure.
-TryWriteResult HostTryWriteU8(u32 var, const u32 address,
+std::optional<WriteResult>
+HostTryWriteU8(u32 var, const u32 address,
                RequestedAddressSpace space = RequestedAddressSpace::Effective);
-TryWriteResult HostTryWriteU16(u32 var, const u32 address,
+std::optional<WriteResult>
+HostTryWriteU16(u32 var, const u32 address,
                 RequestedAddressSpace space = RequestedAddressSpace::Effective);
-TryWriteResult HostTryWriteU32(u32 var, const u32 address,
+std::optional<WriteResult>
+HostTryWriteU32(u32 var, const u32 address,
                 RequestedAddressSpace space = RequestedAddressSpace::Effective);
-TryWriteResult HostTryWriteU64(u64 var, const u32 address,
+std::optional<WriteResult>
+HostTryWriteU64(u64 var, const u32 address,
                 RequestedAddressSpace space = RequestedAddressSpace::Effective);
-TryWriteResult HostTryWriteF32(float var, const u32 address,
+std::optional<WriteResult>
+HostTryWriteF32(float var, const u32 address,
                 RequestedAddressSpace space = RequestedAddressSpace::Effective);
-TryWriteResult HostTryWriteF64(double var, const u32 address,
+std::optional<WriteResult>
+HostTryWriteF64(double var, const u32 address,
                 RequestedAddressSpace space = RequestedAddressSpace::Effective);
 
 // Returns whether a read or write to the given address will resolve to a RAM access in the given

Source/Core/Core/PowerPC/PPCAnalyst.h

@@ -24,29 +24,29 @@ namespace PPCAnalyst
 struct CodeOp  // 16B
 {
   UGeckoInstruction inst;
-  GekkoOPInfo* opinfo;
+  GekkoOPInfo* opinfo = nullptr;
-  u32 address;
+  u32 address = 0;
-  u32 branchTo;  // if UINT32_MAX, not a branch
+  u32 branchTo = 0;  // if UINT32_MAX, not a branch
   BitSet32 regsOut;
   BitSet32 regsIn;
   BitSet32 fregsIn;
-  s8 fregOut;
+  s8 fregOut = 0;
-  bool isBranchTarget;
+  bool isBranchTarget = false;
-  bool branchUsesCtr;
+  bool branchUsesCtr = false;
-  bool branchIsIdleLoop;
+  bool branchIsIdleLoop = false;
-  bool wantsCR0;
+  bool wantsCR0 = false;
-  bool wantsCR1;
+  bool wantsCR1 = false;
-  bool wantsFPRF;
+  bool wantsFPRF = false;
-  bool wantsCA;
+  bool wantsCA = false;
-  bool wantsCAInFlags;
+  bool wantsCAInFlags = false;
-  bool outputCR0;
+  bool outputCR0 = false;
-  bool outputCR1;
+  bool outputCR1 = false;
-  bool outputFPRF;
+  bool outputFPRF = false;
-  bool outputCA;
+  bool outputCA = false;
-  bool canEndBlock;
+  bool canEndBlock = false;
-  bool canCauseException;
+  bool canCauseException = false;
-  bool skipLRStack;
+  bool skipLRStack = false;
-  bool skip;  // followed BL-s for example
+  bool skip = false;  // followed BL-s for example
   // which registers are still needed after this instruction in this block
   BitSet32 fprInUse;
   BitSet32 gprInUse;
@@ -138,23 +138,24 @@ using CodeBuffer = std::vector<CodeOp>;
 struct CodeBlock
 {
   // Beginning PPC address.
-  u32 m_address;
+  u32 m_address = 0;
 
   // Number of instructions
   // Gives us the size of the block.
-  u32 m_num_instructions;
+  u32 m_num_instructions = 0;
 
   // Some basic statistics about the block.
-  BlockStats* m_stats;
+  BlockStats* m_stats = nullptr;
 
   // Register statistics about the block.
-  BlockRegStats *m_gpa, *m_fpa;
+  BlockRegStats* m_gpa = nullptr;
+  BlockRegStats* m_fpa = nullptr;
 
   // Are we a broken block?
-  bool m_broken;
+  bool m_broken = false;
 
   // Did we have a memory_exception?
-  bool m_memory_exception;
+  bool m_memory_exception = false;
 
   // Which GQRs this block uses, if any.
   BitSet8 m_gqr_used;

Source/Core/Core/PowerPC/PPCCache.cpp

@@ -87,10 +87,6 @@ constexpr std::array<u32, 128> s_way_from_plru = [] {
 }();
 }  // Anonymous namespace
 
-InstructionCache::InstructionCache()
-{
-}
-
 void InstructionCache::Reset()
 {
   valid.fill(0);

Source/Core/Core/PowerPC/PPCCache.h

@@ -21,16 +21,16 @@ constexpr u32 ICACHE_VMEM_BIT = 0x20000000;
 
 struct InstructionCache
 {
-  std::array<std::array<std::array<u32, ICACHE_BLOCK_SIZE>, ICACHE_WAYS>, ICACHE_SETS> data;
+  std::array<std::array<std::array<u32, ICACHE_BLOCK_SIZE>, ICACHE_WAYS>, ICACHE_SETS> data{};
-  std::array<std::array<u32, ICACHE_WAYS>, ICACHE_SETS> tags;
+  std::array<std::array<u32, ICACHE_WAYS>, ICACHE_SETS> tags{};
-  std::array<u32, ICACHE_SETS> plru;
+  std::array<u32, ICACHE_SETS> plru{};
-  std::array<u32, ICACHE_SETS> valid;
+  std::array<u32, ICACHE_SETS> valid{};
 
-  std::array<u8, 1 << 20> lookup_table;
+  std::array<u8, 1 << 20> lookup_table{};
-  std::array<u8, 1 << 21> lookup_table_ex;
+  std::array<u8, 1 << 21> lookup_table_ex{};
-  std::array<u8, 1 << 20> lookup_table_vmem;
+  std::array<u8, 1 << 20> lookup_table_vmem{};
 
-  InstructionCache();
+  InstructionCache() = default;
   u32 ReadInstruction(u32 addr);
   void Invalidate(u32 addr);
   void Init();

Source/Core/Core/PowerPC/PowerPC.h

@@ -113,14 +113,14 @@ static_assert(std::is_standard_layout<PairedSingle>(), "PairedSingle must be sta
 // Unfortunately not all of those fit in 520 bytes, but we can fit most of ps and all of the rest.
 struct PowerPCState
 {
-  u32 pc;  // program counter
+  u32 pc = 0;  // program counter
-  u32 npc;
+  u32 npc = 0;
 
   // gather pipe pointer for JIT access
-  u8* gather_pipe_ptr;
+  u8* gather_pipe_ptr = nullptr;
-  u8* gather_pipe_base_ptr;
+  u8* gather_pipe_base_ptr = nullptr;
 
-  u32 gpr[32];  // General purpose registers. r1 = stack pointer.
+  u32 gpr[32]{};  // General purpose registers. r1 = stack pointer.
 
 #ifndef _M_X86_64
   // The paired singles are strange : PS0 is stored in the full 64 bits of each FPR
@@ -129,25 +129,25 @@ struct PowerPCState
   alignas(16) PairedSingle ps[32];
 #endif
 
-  ConditionRegister cr;
+  ConditionRegister cr{};
 
   UReg_MSR msr;      // machine state register
   UReg_FPSCR fpscr;  // floating point flags/status bits
 
   // Exception management.
-  u32 Exceptions;
+  u32 Exceptions = 0;
 
   // Downcount for determining when we need to do timing
   // This isn't quite the right location for it, but it is here to accelerate the ARM JIT
   // This variable should be inside of the CoreTiming namespace if we wanted to be correct.
-  int downcount;
+  int downcount = 0;
 
   // XER, reformatted into byte fields for easier access.
-  u8 xer_ca;
+  u8 xer_ca = 0;
-  u8 xer_so_ov;  // format: (SO << 1) | OV
+  u8 xer_so_ov = 0;  // format: (SO << 1) | OV
   // The Broadway CPU implements bits 16-23 of the XER register... even though it doesn't support
   // lscbx
-  u16 xer_stringctrl;
+  u16 xer_stringctrl = 0;
 
 #if _M_X86_64
   // This member exists only for the purpose of an assertion that its offset <= 0x100.
@@ -156,19 +156,19 @@ struct PowerPCState
   alignas(16) PairedSingle ps[32];
 #endif
 
-  u32 sr[16];  // Segment registers.
+  u32 sr[16]{};  // Segment registers.
 
   // special purpose registers - controls quantizers, DMA, and lots of other misc extensions.
   // also for power management, but we don't care about that.
-  u32 spr[1024];
+  u32 spr[1024]{};
 
   // Storage for the stack pointer of the BLR optimization.
-  u8* stored_stack_pointer;
+  u8* stored_stack_pointer = nullptr;
 
   std::array<std::array<TLBEntry, TLB_SIZE / TLB_WAYS>, NUM_TLBS> tlb;
 
-  u32 pagetable_base;
+  u32 pagetable_base = 0;
-  u32 pagetable_hashmask;
+  u32 pagetable_hashmask = 0;
 
   InstructionCache iCache;
 

Source/Core/Core/PowerPC/Profiler.h

@@ -28,9 +28,9 @@ struct BlockStat
 struct ProfileStats
 {
   std::vector<BlockStat> block_stats;
-  u64 cost_sum;
+  u64 cost_sum = 0;
-  u64 timecost_sum;
+  u64 timecost_sum = 0;
-  u64 countsPerSec;
+  u64 countsPerSec = 0;
 };
 
 }  // namespace Profiler

Source/Core/Core/State.cpp

@@ -298,10 +298,10 @@ static std::map<double, int> GetSavedStates()
 
 struct CompressAndDumpState_args
 {
-  std::vector<u8>* buffer_vector;
+  std::vector<u8>* buffer_vector = nullptr;
-  std::mutex* buffer_mutex;
+  std::mutex* buffer_mutex = nullptr;
   std::string filename;
-  bool wait;
+  bool wait = false;
 };
 
 static void CompressAndDumpState(CompressAndDumpState_args save_args)

Source/Core/Core/SyncIdentifier.h

@@ -13,18 +13,18 @@ namespace NetPlay
 {
 struct SyncIdentifier
 {
-  u64 dol_elf_size;
+  u64 dol_elf_size = 0;
   std::string game_id;
-  u16 revision;
+  u16 revision = 0;
-  u8 disc_number;
+  u8 disc_number = 0;
-  bool is_datel;
+  bool is_datel = false;
 
   // This hash is intended to be (but is not guaranteed to be):
   // 1. Identical for discs with no differences that affect netplay/TAS sync
   // 2. Different for discs with differences that affect netplay/TAS sync
   // 3. Much faster than hashing the entire disc
   // The way the hash is calculated may change with updates to Dolphin.
-  std::array<u8, 20> sync_hash;
+  std::array<u8, 20> sync_hash{};
 
   bool operator==(const SyncIdentifier& s) const
   {

Source/Core/DiscIO/CompressedBlob.cpp

@@ -173,17 +173,17 @@ struct CompressThreadState
 
 struct CompressParameters
 {
-  std::vector<u8> data;
+  std::vector<u8> data{};
-  u32 block_number;
+  u32 block_number = 0;
-  u64 inpos;
+  u64 inpos = 0;
 };
 
 struct OutputParameters
 {
-  std::vector<u8> data;
+  std::vector<u8> data{};
-  u32 block_number;
+  u32 block_number = 0;
-  bool compressed;
+  bool compressed = false;
-  u64 inpos;
+  u64 inpos = 0;
 };
 
 static ConversionResultCode SetUpCompressThreadState(CompressThreadState* state)

Source/Core/DiscIO/DirectoryBlob.h

@@ -132,14 +132,14 @@ private:
   std::vector<u8> m_apploader;
   std::vector<u8> m_fst_data;
 
-  std::array<u8, VolumeWii::AES_KEY_SIZE> m_key;
+  std::array<u8, VolumeWii::AES_KEY_SIZE> m_key{};
 
   std::string m_root_directory;
   bool m_is_wii = false;
   // GameCube has no shift, Wii has 2 bit shift
   u32 m_address_shift = 0;
 
-  u64 m_data_size;
+  u64 m_data_size = 0;
 };
 
 class DirectoryBlobReader : public BlobReader

Source/Core/DiscIO/DiscScrubber.h

@@ -46,7 +46,7 @@ private:
   bool ParsePartitionData(const Partition& partition);
   void ParseFileSystemData(u64 partition_data_offset, const FileInfo& directory);
 
-  const Volume* m_disc;
+  const Volume* m_disc = nullptr;
 
   std::vector<u8> m_free_table;
   u64 m_file_size = 0;

Source/Core/DiscIO/LaggedFibonacciGenerator.h

@@ -43,7 +43,7 @@ private:
   static constexpr size_t LFG_K = 521;
   static constexpr size_t LFG_J = 32;
 
-  std::array<u32, LFG_K> m_buffer;
+  std::array<u32, LFG_K> m_buffer{};
 
   size_t m_position_bytes = 0;
 };

Source/Core/DiscIO/VolumeVerifier.h

@@ -78,7 +78,7 @@ private:
 
   struct PotentialMatch
   {
-    u64 size;
+    u64 size = 0;
     Hashes<std::vector<u8>> hashes;
   };
 
@@ -87,9 +87,9 @@ private:
   std::vector<PotentialMatch> ScanDatfile(const std::vector<u8>& data, const std::string& system);
 
   std::string m_game_id;
-  u16 m_revision;
+  u16 m_revision = 0;
-  u8 m_disc_number;
+  u8 m_disc_number = 0;
-  u64 m_size;
+  u64 m_size = 0;
 
   std::future<std::vector<PotentialMatch>> m_future;
   Result m_result;
@@ -173,8 +173,8 @@ private:
   Hashes<bool> m_hashes_to_calculate{};
   bool m_calculating_any_hash = false;
   unsigned long m_crc32_context = 0;
-  mbedtls_md5_context m_md5_context;
+  mbedtls_md5_context m_md5_context{};
-  mbedtls_sha1_context m_sha1_context;
+  mbedtls_sha1_context m_sha1_context{};
 
   u64 m_excess_bytes = 0;
   std::vector<u8> m_data;

Source/Core/DiscIO/VolumeWii.h

@@ -122,7 +122,7 @@ private:
     Common::Lazy<std::vector<u8>> h3_table;
     Common::Lazy<std::unique_ptr<FileSystem>> file_system;
     Common::Lazy<u64> data_offset;
-    u32 type;
+    u32 type = 0;
   };
 
   std::unique_ptr<BlobReader> m_reader;
@@ -131,7 +131,7 @@ private:
   bool m_encrypted;
 
   mutable u64 m_last_decrypted_block;
-  mutable u8 m_last_decrypted_block_data[BLOCK_DATA_SIZE];
+  mutable u8 m_last_decrypted_block_data[BLOCK_DATA_SIZE]{};
 };
 
 }  // namespace DiscIO

Source/Core/DiscIO/WIABlob.h

@@ -168,7 +168,10 @@ private:
     bool is_partition;
     u8 partition_data_index;
 
-    DataEntry(size_t index_) : index(static_cast<u32>(index_)), is_partition(false) {}
+    DataEntry(size_t index_)
+        : index(static_cast<u32>(index_)), is_partition(false), partition_data_index(0)
+    {
+    }
     DataEntry(size_t index_, size_t partition_data_index_)
         : index(static_cast<u32>(index_)), is_partition(true),
           partition_data_index(static_cast<u8>(partition_data_index_))
@@ -281,11 +284,11 @@ private:
 
   struct CompressParameters
   {
-    std::vector<u8> data;
+    std::vector<u8> data{};
-    const DataEntry* data_entry;
+    const DataEntry* data_entry = nullptr;
-    u64 data_offset;
+    u64 data_offset = 0;
-    u64 bytes_read;
+    u64 bytes_read = 0;
-    size_t group_index;
+    size_t group_index = 0;
   };
 
   struct WIAOutputParametersEntry
@@ -312,8 +315,8 @@ private:
   struct OutputParameters
   {
     std::vector<OutputParametersEntry> entries;
-    u64 bytes_read;
+    u64 bytes_read = 0;
-    size_t group_index;
+    size_t group_index = 0;
   };
 
   static bool PadTo4(File::IOFile* file, u64* bytes_written);

Source/Core/DiscIO/WIACompression.h

@@ -141,7 +141,7 @@ private:
   u32 m_rvz_packed_size;
 
   u32 m_size = 0;
-  bool m_junk;
+  bool m_junk = false;
   LaggedFibonacciGenerator m_lfg;
 };
 
@@ -178,7 +178,7 @@ public:
 
 private:
   std::vector<u8> m_buffer;
-  size_t m_bytes_written;
+  size_t m_bytes_written = 0;
   mbedtls_sha1_context m_sha1_context;
 };
 
@@ -244,7 +244,7 @@ private:
   void ExpandBuffer(size_t bytes_to_add);
 
   ZSTD_CStream* m_stream;
-  ZSTD_outBuffer m_out_buffer;
+  ZSTD_outBuffer m_out_buffer{};
   std::vector<u8> m_buffer;
 };
 

Source/Core/DiscIO/WiiEncryptionCache.h

@@ -50,7 +50,7 @@ public:
 private:
   BlobReader* m_blob;
   std::unique_ptr<std::array<u8, VolumeWii::GROUP_TOTAL_SIZE>> m_cache;
-  u64 m_cached_offset;
+  u64 m_cached_offset = 0;
 };
 
 }  // namespace DiscIO

Source/Core/DolphinQt/Config/Graphics/PostProcessingConfigWindow.h

@@ -52,7 +52,7 @@ private:
     u32 AddInteger(PostProcessingConfigWindow* parent, QGridLayout* grid, u32 row);
     u32 AddFloat(PostProcessingConfigWindow* parent, QGridLayout* grid, u32 row);
 
-    QCheckBox* m_checkbox;
+    QCheckBox* m_checkbox = nullptr;
     std::vector<QSlider*> m_sliders;
     std::vector<QLineEdit*> m_value_boxes;
 

Source/Core/DolphinQt/Config/Mapping/IOWindow.cpp

@@ -207,7 +207,7 @@ public:
 
 private:
   std::function<ControlState()> m_state_evaluator;
-  bool m_should_paint_state_indicator;
+  bool m_should_paint_state_indicator = false;
 };
 
 IOWindow::IOWindow(MappingWidget* parent, ControllerEmu::EmulatedController* controller,

Source/Core/DolphinQt/Debugger/CodeViewWidget.cpp

@@ -35,10 +35,10 @@
 
 struct CodeViewBranch
 {
-  u32 src_addr;
+  u32 src_addr = 0;
-  u32 dst_addr;
+  u32 dst_addr = 0;
   u32 indentation = 0;
-  bool is_link;
+  bool is_link = false;
 };
 
 constexpr u32 WIDTH_PER_BRANCH_ARROW = 16;

Source/Core/DolphinQt/TAS/TASCheckBox.h

@@ -21,7 +21,7 @@ protected:
 
 private:
   const TASInputWindow* m_parent;
-  int m_frame_turbo_started;
+  int m_frame_turbo_started = 0;
-  int m_turbo_press_frames;
+  int m_turbo_press_frames = 0;
-  int m_turbo_total_frames;
+  int m_turbo_total_frames = 0;
 };

Source/Core/InputCommon/ControlReference/ControlReference.cpp

@@ -58,9 +58,7 @@ std::optional<std::string> ControlReference::SetExpression(std::string expr)
   return parse_result.description;
 }
 
-ControlReference::ControlReference() : range(1), m_parsed_expression(nullptr)
+ControlReference::ControlReference() = default;
-{
-}
 
 ControlReference::~ControlReference() = default;
 

Source/Core/InputCommon/ControlReference/ControlReference.h

@@ -41,13 +41,14 @@ public:
   // Returns a human-readable error description when the given expression is invalid.
   std::optional<std::string> SetExpression(std::string expr);
 
-  ControlState range;
+  ControlState range = 1;
 
 protected:
   ControlReference();
   std::string m_expression;
   std::unique_ptr<ciface::ExpressionParser::Expression> m_parsed_expression;
-  ciface::ExpressionParser::ParseStatus m_parse_status;
+  ciface::ExpressionParser::ParseStatus m_parse_status =
+      ciface::ExpressionParser::ParseStatus::EmptyExpression;
 };
 
 template <>

Source/Core/InputCommon/ControlReference/ExpressionParser.h

@@ -181,7 +181,7 @@ public:
   static ParseResult MakeSuccessfulResult(std::unique_ptr<Expression>&& expr);
   static ParseResult MakeErrorResult(Token token, std::string description);
 
-  ParseStatus status;
+  ParseStatus status = ParseStatus::EmptyExpression;
   std::unique_ptr<Expression> expr;
 
   // Used for parse errors:

Source/Core/InputCommon/ControllerInterface/CoreDevice.h

@@ -174,7 +174,7 @@ protected:
   void AddCombinedInput(std::string name, const std::pair<std::string, std::string>& inputs);
 
 private:
-  int m_id;
+  int m_id = 0;
   std::vector<Input*> m_inputs;
   std::vector<Output*> m_outputs;
 };
@@ -216,10 +216,10 @@ public:
   struct InputDetection
   {
     std::shared_ptr<Device> device;
-    Device::Input* input;
+    Device::Input* input = nullptr;
     Clock::time_point press_time;
     std::optional<Clock::time_point> release_time;
-    ControlState smoothness;
+    ControlState smoothness = 0;
   };
 
   Device::Input* FindInput(std::string_view name, const Device* def_dev) const;

Source/Core/InputCommon/ControllerInterface/DInput/DInputJoystick.cpp

@@ -177,9 +177,6 @@ Joystick::Joystick(const LPDIRECTINPUTDEVICE8 device) : m_device(device)
     InitForceFeedback(m_device, num_ff_axes);
   }
 
-  // Zero inputs:
-  m_state_in = {};
-
   // Set hats to center:
   // "The center position is normally reported as -1" -MSDN
   std::fill(std::begin(m_state_in.rgdwPOV), std::end(m_state_in.rgdwPOV), -1);

Source/Core/InputCommon/ControllerInterface/DInput/DInputJoystick.h

@@ -70,7 +70,7 @@ public:
 private:
   const LPDIRECTINPUTDEVICE8 m_device;
 
-  DIJOYSTATE m_state_in;
+  DIJOYSTATE m_state_in{};
 
   bool m_buffered;
 };

Source/Core/InputCommon/ControllerInterface/DInput/DInputKeyboardMouse.h

@@ -22,10 +22,10 @@ class KeyboardMouse : public Core::Device
 private:
   struct State
   {
-    BYTE keyboard[256];
+    BYTE keyboard[256]{};
 
     // Old smoothed relative mouse movement.
-    DIMOUSESTATE2 mouse;
+    DIMOUSESTATE2 mouse{};
 
     // Normalized mouse cursor position.
     Common::TVec2<ControlState> cursor;

Source/Core/InputCommon/ControllerInterface/DualShockUDPClient/DualShockUDPClient.cpp

@@ -191,7 +191,7 @@ struct Server
   std::string m_description;
   std::string m_address;
   u16 m_port;
-  std::array<Proto::MessageType::PortInfo, Proto::PORT_COUNT> m_port_info;
+  std::array<Proto::MessageType::PortInfo, Proto::PORT_COUNT> m_port_info{};
   sf::UdpSocket m_socket;
   SteadyClock::time_point m_disconnect_time = SteadyClock::now();
 };

Source/Core/InputCommon/GCPadStatus.h

@@ -30,16 +30,16 @@ enum PadButton
 
 struct GCPadStatus
 {
-  u16 button;       // Or-ed PAD_BUTTON_* and PAD_TRIGGER_* bits
+  u16 button = 0;       // Or-ed PAD_BUTTON_* and PAD_TRIGGER_* bits
-  u8 stickX;        // 0 <= stickX       <= 255
+  u8 stickX = 0;        // 0 <= stickX       <= 255
-  u8 stickY;        // 0 <= stickY       <= 255
+  u8 stickY = 0;        // 0 <= stickY       <= 255
-  u8 substickX;     // 0 <= substickX    <= 255
+  u8 substickX = 0;     // 0 <= substickX    <= 255
-  u8 substickY;     // 0 <= substickY    <= 255
+  u8 substickY = 0;     // 0 <= substickY    <= 255
-  u8 triggerLeft;   // 0 <= triggerLeft  <= 255
+  u8 triggerLeft = 0;   // 0 <= triggerLeft  <= 255
-  u8 triggerRight;  // 0 <= triggerRight <= 255
+  u8 triggerRight = 0;  // 0 <= triggerRight <= 255
-  u8 analogA;       // 0 <= analogA      <= 255
+  u8 analogA = 0;       // 0 <= analogA      <= 255
-  u8 analogB;       // 0 <= analogB      <= 255
+  u8 analogB = 0;       // 0 <= analogB      <= 255
-  bool isConnected{true};
+  bool isConnected = true;
 
   static const u8 MAIN_STICK_CENTER_X = 0x80;
   static const u8 MAIN_STICK_CENTER_Y = 0x80;

Source/Core/UICommon/NetPlayIndex.h

@@ -23,11 +23,11 @@ struct NetPlaySession
   std::string game_id;
   std::string version;
 
-  int player_count;
+  int player_count = 0;
-  int port;
+  int port = 0;
 
-  bool has_password;
+  bool has_password = false;
-  bool in_game;
+  bool in_game = false;
 
   bool EncryptID(std::string_view password);
   std::optional<std::string> DecryptID(std::string_view password) const;

Source/Core/UpdaterCommon/UpdaterCommon.cpp

@@ -49,7 +49,7 @@ struct TodoList
   struct DownloadOp
   {
     Manifest::Filename filename;
-    Manifest::Hash hash;
+    Manifest::Hash hash{};
   };
   std::vector<DownloadOp> to_download;
 
@@ -57,14 +57,14 @@ struct TodoList
   {
     Manifest::Filename filename;
     std::optional<Manifest::Hash> old_hash;
-    Manifest::Hash new_hash;
+    Manifest::Hash new_hash{};
   };
   std::vector<UpdateOp> to_update;
 
   struct DeleteOp
   {
     Manifest::Filename filename;
-    Manifest::Hash old_hash;
+    Manifest::Hash old_hash{};
   };
   std::vector<DeleteOp> to_delete;
 

Source/Core/VideoBackends/D3D/D3DPerfQuery.h

@@ -26,7 +26,7 @@ private:
   struct ActiveQuery
   {
     ComPtr<ID3D11Query> query;
-    PerfQueryGroup query_type;
+    PerfQueryGroup query_type{};
   };
 
   void WeakFlush();

Source/Core/VideoBackends/D3D12/D3D12BoundingBox.h

@@ -34,7 +34,7 @@ private:
   ComPtr<ID3D12Resource> m_gpu_buffer;
   ComPtr<ID3D12Resource> m_readback_buffer;
   StreamBuffer m_upload_buffer;
-  DescriptorHandle m_gpu_descriptor;
+  DescriptorHandle m_gpu_descriptor{};
 };
 
 }  // namespace DX12

Source/Core/VideoBackends/D3D12/DescriptorHeapManager.h

@@ -66,7 +66,7 @@ private:
   u32 m_descriptor_increment_size = 0;
   u32 m_current_offset = 0;
 
-  D3D12_CPU_DESCRIPTOR_HANDLE m_heap_base_cpu;
+  D3D12_CPU_DESCRIPTOR_HANDLE m_heap_base_cpu{};
 
   std::unordered_map<SamplerState::StorageType, D3D12_CPU_DESCRIPTOR_HANDLE> m_sampler_map;
 };

Source/Core/VideoBackends/OGL/ProgramShaderCache.h

@@ -59,7 +59,7 @@ struct PipelineProgramKeyHash
 
 struct PipelineProgram
 {
-  PipelineProgramKey key;
+  PipelineProgramKey key{};
   SHADER shader;
   std::atomic_size_t reference_count{1};
   bool binary_retrieved = false;

Source/Core/VideoBackends/Software/SWVertexLoader.h

@@ -25,6 +25,6 @@ protected:
   void SetFormat(u8 attributeIndex, u8 primitiveType);
   void ParseVertex(const PortableVertexDeclaration& vdec, int index);
 
-  InputVertexData m_vertex;
+  InputVertexData m_vertex{};
   SetupUnit m_setup_unit;
 };

Source/Core/VideoBackends/Software/SetupUnit.h

@@ -8,12 +8,12 @@
 
 class SetupUnit
 {
-  u8 m_PrimType;
+  u8 m_PrimType = 0;
-  int m_VertexCounter;
+  int m_VertexCounter = 0;
 
   OutputVertexData m_Vertices[3];
-  OutputVertexData* m_VertPointer[3];
+  OutputVertexData* m_VertPointer[3]{};
-  OutputVertexData* m_VertWritePointer;
+  OutputVertexData* m_VertWritePointer{};
 
   void SetupQuad();
   void SetupTriangle();

Source/Core/VideoBackends/Software/Vec3.h

@@ -11,7 +11,7 @@ class Vec3
 public:
   float x, y, z;
 
-  Vec3() {}
+  Vec3() = default;
   explicit Vec3(float f) { x = y = z = f; }
   explicit Vec3(const float* f)
   {

Source/Core/VideoBackends/Vulkan/CommandBufferManager.h

@@ -120,7 +120,7 @@ private:
   u64 m_completed_fence_counter = 0;
 
   std::array<FrameResources, NUM_COMMAND_BUFFERS> m_frame_resources;
-  u32 m_current_frame;
+  u32 m_current_frame = 0;
 
   // Threaded command buffer execution
   // Semaphore determines when a command buffer can be queued

Source/Core/VideoBackends/Vulkan/VKSwapChain.h

@@ -86,7 +86,7 @@ private:
 
   struct SwapChainImage
   {
-    VkImage image;
+    VkImage image{};
     std::unique_ptr<VKTexture> texture;
     std::unique_ptr<VKFramebuffer> framebuffer;
   };