Jit: Use LazyMemoryRegion-backed bit sets

JitCache has been using a class called ValidBlockBitSet. This commit
replaces it with a new class called LazyMemoryRegionBitSet, which works
similarly but is backed by a LazyMemoryRegion, letting us skip
allocating memory for parts of the bit set that correspond to emulated
memory regions where the game isn't storing any code. I have also added
optimized functions for setting or clearing long runs of bits.

Additionally, this commit replaces JitBase's three std::unordered_sets
that are keeping track of instructions with LazyMemoryRegionBitSets.
Here the benefit is more speed than memory usage. This improves NBA Live
2005's menu performance by 1% or so in SuperSamus's testing.

Author: JosJuice

Source/Core/Common/CMakeLists.txt

@@ -99,6 +99,8 @@ add_library(common
   JsonUtil.h
   JsonUtil.cpp
   Lazy.h
+  LazyMemoryRegionBitSet.cpp
+  LazyMemoryRegionBitSet.h
   LinearDiskCache.h
   UnixUtil.h
   Logging/ConsoleListener.h

Source/Core/Common/LazyMemoryRegionBitSet.cpp

@@ -0,0 +1,100 @@
+// Copyright 2026 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "Common/LazyMemoryRegionBitSet.h"
+
+#include <cstring>
+
+#include "Common/MsgHandler.h"
+
+namespace Common
+{
+LazyMemoryRegionBitSet::LazyMemoryRegionBitSet(size_t bits) : m_bits(bits), m_valid(Create(bits))
+{
+}
+
+bool LazyMemoryRegionBitSet::Create(size_t bits)
+{
+  const size_t page_size = MemArena().GetPageSize();
+  if (bits % (page_size * 8) != 0)
+  {
+    PanicAlertFmt(
+        "LazyMemoryRegionBitSet size of {} bits is not aligned with page size of {} bytes", bits,
+        page_size);
+    return false;
+  }
+
+  m_pointer = reinterpret_cast<u32*>(m_region.Create(bits / 8));
+  if (!m_pointer)
+  {
+    PanicAlertFmt("LazyMemoryRegionBitSet failed to create backing region");
+    return false;
+  }
+
+  return true;
+}
+
+void LazyMemoryRegionBitSet::Clear()
+{
+  m_region.Clear();
+}
+
+void LazyMemoryRegionBitSet::SetBits(size_t bits_start, size_t bits_end)
+{
+  if (bits_start == bits_end)
+    return;
+
+  RangeCheck(bits_end);
+
+  m_region.EnsureMemoryPagesWritable(bits_start / 8, (bits_end - bits_start) / 8);
+
+  const u32 extra_first_word = 0xFFFFFFFF << bits_start % 32;
+  const u32 extra_last_word = ~(0xFFFFFFFF << bits_end % 32);
+
+  if (bits_start / 32 == bits_end / 32)
+  {
+    m_pointer[bits_start / 32] |= extra_first_word & extra_last_word;
+    return;
+  }
+
+  if (bits_start % 32 != 0)
+    m_pointer[bits_start / 32] |= extra_first_word;
+
+  const size_t start_index = (bits_start + 31) / 32;
+  const size_t end_index = bits_end / 32;
+  std::memset(m_pointer + start_index, 0xFF, (end_index - start_index) * 4);
+
+  if (bits_end % 32 != 0)
+    m_pointer[bits_end / 32] |= extra_last_word;
+}
+
+void LazyMemoryRegionBitSet::ClearBits(size_t bits_start, size_t bits_end)
+{
+  if (bits_start == bits_end)
+    return;
+
+  RangeCheck(bits_end);
+
+  m_region.EnsureMemoryPagesWritable(bits_start / 8, (bits_end - bits_start) / 8);
+
+  const u32 extra_first_word = ~(0xFFFFFFFF << bits_start % 32);
+  const u32 extra_last_word = 0xFFFFFFFF << bits_end % 32;
+
+  if (bits_start / 32 == bits_end / 32)
+  {
+    m_pointer[bits_start / 32] &= extra_first_word | extra_last_word;
+    return;
+  }
+
+  if (bits_start % 32 != 0)
+    m_pointer[bits_start / 32] &= extra_first_word;
+
+  const size_t start_index = (bits_start + 31) / 32;
+  const size_t end_index = bits_end / 32;
+  std::memset(m_pointer + start_index, 0x00, (end_index - start_index) * 4);
+
+  if (bits_end % 32 != 0)
+    m_pointer[bits_end / 32] &= extra_last_word;
+}
+
+}  // namespace Common

Source/Core/Common/LazyMemoryRegionBitSet.h

@@ -0,0 +1,68 @@
+// Copyright 2026 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <cstddef>
+
+#include "Common/Assert.h"
+#include "Common/MemArena.h"
+
+namespace Common
+{
+// A bit set backed by a LazyMemoryRegion.
+class LazyMemoryRegionBitSet final
+{
+public:
+  // Allocates backing memory and creates a bit set.
+  // Allocating backing memory may fail; use IsValid to check for success.
+  LazyMemoryRegionBitSet(size_t bits);
+
+  bool IsValid() const { return m_valid; }
+
+  void Clear();
+
+  bool IsBitSet(size_t bit) const
+  {
+    RangeCheck(bit);
+    return (m_pointer[bit / 32] & (1 << (bit % 32))) != 0;
+  }
+
+  void SetBit(size_t bit)
+  {
+    RangeCheck(bit);
+    m_region.EnsureMemoryPageWritable(bit / 8);
+    m_pointer[bit / 32] |= (1 << (bit % 32));
+  }
+
+  void ClearBit(size_t bit)
+  {
+    RangeCheck(bit);
+    m_region.EnsureMemoryPageWritable(bit / 8);
+    m_pointer[bit / 32] &= ~(1 << (bit % 32));
+  }
+
+  void SetBits(size_t bits_start, size_t bits_end);
+
+  void ClearBits(size_t bits_start, size_t bits_end);
+
+  void RangeCheck(size_t bit) const
+  {
+    DEBUG_ASSERT_MSG(COMMON, m_valid, "LazyMemoryRegionBitSet isn't valid");
+    DEBUG_ASSERT_MSG(COMMON, bit < m_bits,
+                     "Tried to access bit {} in a LazyMemoryRegionBitSet with only {} bits", bit,
+                     m_bits);
+  }
+
+  const u32* GetRawMemory() const { return m_pointer; }
+
+private:
+  LazyMemoryRegion m_region;
+  u32* m_pointer;
+  size_t m_bits;
+  bool m_valid;
+
+  bool Create(size_t bits);
+};
+
+}  // namespace Common

Source/Core/Core/FifoPlayer/FifoPlayer.cpp

@@ -217,7 +217,7 @@ class FifoPlayer::CPUCore final : public CPUCoreBase
   ~CPUCore() override {}
   CPUCore& operator=(const CPUCore&) = delete;
 
-  void Init() override
+  bool Init() override
   {
     IsPlayingBackFifologWithBrokenEFBCopies = m_parent->m_File->HasBrokenEFBCopies();
     // Without this call, we deadlock in initialization in dual core, as the FIFO is disabled and
@@ -226,6 +226,8 @@ class FifoPlayer::CPUCore final : public CPUCoreBase
 
     m_parent->m_CurrentFrame = m_parent->m_FrameRangeStart;
     m_parent->LoadMemory();
+
+    return true;
   }
 
   void Shutdown() override { IsPlayingBackFifologWithBrokenEFBCopies = false; }

Source/Core/Core/PowerPC/CPUCoreBase.h

@@ -7,7 +7,7 @@ class CPUCoreBase
 {
 public:
   virtual ~CPUCoreBase() = default;
-  virtual void Init() = 0;
+  [[nodiscard]] virtual bool Init() = 0;
   virtual void Shutdown() = 0;
   virtual void ClearCache() = 0;
   virtual void Run() = 0;

Source/Core/Core/PowerPC/CachedInterpreter/CachedInterpreter.cpp

@@ -31,20 +31,26 @@ CachedInterpreter::CachedInterpreter(Core::System& system) : JitBase(system), m_
 
 CachedInterpreter::~CachedInterpreter() = default;
 
-void CachedInterpreter::Init()
+bool CachedInterpreter::Init()
 {
+  if (!CheckValidity())
+    return false;
+
   RefreshConfig();
 
   AllocCodeSpace(CODE_SIZE);
   ResetFreeMemoryRanges();
 
   jo.enableBlocklink = false;
 
-  m_block_cache.Init();
+  if (!m_block_cache.Init())
+    return false;
 
   code_block.m_stats = &js.st;
   code_block.m_gpa = &js.gpa;
   code_block.m_fpa = &js.fpa;
+
+  return true;
 }
 
 void CachedInterpreter::Shutdown()

Source/Core/Core/PowerPC/CachedInterpreter/CachedInterpreter.h

@@ -32,7 +32,7 @@ class CachedInterpreter : public JitBase, public CachedInterpreterCodeBlock
   CachedInterpreter& operator=(CachedInterpreter&&) = delete;
   ~CachedInterpreter() override;
 
-  void Init() override;
+  [[nodiscard]] bool Init() override;
   void Shutdown() override;
 
   bool HandleFault(uintptr_t access_address, SContext* ctx) override { return false; }

Source/Core/Core/PowerPC/CachedInterpreter/CachedInterpreterBlockCache.cpp

@@ -10,10 +10,10 @@ CachedInterpreterBlockCache::CachedInterpreterBlockCache(JitBase& jit) : JitBase
 {
 }
 
-void CachedInterpreterBlockCache::Init()
+bool CachedInterpreterBlockCache::Init()
 {
-  JitBaseBlockCache::Init();
   ClearRangesToFree();
+  return JitBaseBlockCache::Init();
 }
 
 void CachedInterpreterBlockCache::DestroyBlock(JitBlock& block)

Source/Core/Core/PowerPC/CachedInterpreter/CachedInterpreterBlockCache.h

@@ -16,7 +16,7 @@ class CachedInterpreterBlockCache final : public JitBaseBlockCache
 public:
   explicit CachedInterpreterBlockCache(JitBase& jit);
 
-  void Init() override;
+  [[nodiscard]] bool Init() override;
 
   void DestroyBlock(JitBlock& block) override;
 

Source/Core/Core/PowerPC/Interpreter/Interpreter.cpp

@@ -70,9 +70,11 @@ Interpreter::Interpreter(Core::System& system, PowerPC::PowerPCState& ppc_state,
 
 Interpreter::~Interpreter() = default;
 
-void Interpreter::Init()
+bool Interpreter::Init()
 {
   m_end_block = false;
+
+  return true;
 }
 
 void Interpreter::Shutdown()