WIP: [cmake] Use a debloated boost distribution

Should speed up fetch time

Signed-off-by: crueter <crueter@eden-emu.dev>

.patch/boost/0001-clang-cl.patch

@@ -1,13 +0,0 @@
-diff --git a/libs/cobalt/include/boost/cobalt/concepts.hpp b/libs/cobalt/include/boost/cobalt/concepts.hpp
-index d49f2ec..a9bdb80 100644
---- a/libs/cobalt/include/boost/cobalt/concepts.hpp
-+++ b/libs/cobalt/include/boost/cobalt/concepts.hpp
-@@ -62,7 +62,7 @@ struct enable_awaitables
- template <typename T>
- concept with_get_executor = requires (T& t)
- {
--  {t.get_executor()} -> asio::execution::executor;
-+  t.get_executor();
- };
- 
- 

CMakeLists.txt

@@ -414,12 +414,9 @@ AddJsonPackage(boost)
 set(BOOST_NO_HEADERS ${Boost_ADDED})
 
 if (Boost_ADDED)
-    if (MSVC OR ANDROID)
+    add_compile_definitions(YUZU_BOOST_v1)
-        add_compile_definitions(YUZU_BOOST_v1)
-    endif()
-
     if (NOT MSVC OR CXX_CLANG)
-        # boost sucks
+        # solaris sucks
         if (SOLARIS)
             add_compile_options($<$<COMPILE_LANGUAGE:C,CXX>:-pthreads>)
         endif()
@@ -428,8 +425,7 @@ if (Boost_ADDED)
         target_compile_options(boost_icl INTERFACE $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-shadow>)
         target_compile_options(boost_asio INTERFACE
             $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-conversion>
-            $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-implicit-fallthrough>
+            $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-implicit-fallthrough>)
-        )
     endif()
 endif()
 

cpmfile.json

@@ -6,22 +6,19 @@
         "version": "v0.19.0"
     },
     "boost": {
-        "artifact": "%VERSION%-cmake.tar.xz",
+        "artifact": "boost-%VERSION%.tar.zst",
         "find_args": "CONFIG OPTIONAL_COMPONENTS headers context system fiber filesystem",
-        "hash": "6ae6e94664fe7f2fb01976b59b276ac5df8085c7503fa829d810fbfe495960cfec44fa2c36e2cb23480bc19c956ed199d4952b02639a00a6c07625d4e7130c2d",
+        "hash": "077ad58b3d336041c05ad5f2b1de7db9fe1d35af3da85cd99496c35ddeca080ecd0ae5c8058319077bda892361b38624d89f70bc9bfec6713aae2aabc17f2a43",
         "min_version": "1.57",
         "package": "Boost",
-        "patches": [
+        "repo": "eden-emulator/ext-boost",
-            "0001-clang-cl.patch"
+        "version": "1.91.0-1"
-        ],
-        "repo": "boostorg/boost",
-        "version": "boost-1.90.0"
     },
     "boost_headers": {
         "bundled": true,
-        "hash": "4ef845775e2277a8104ded6ddf749aa262ce52cf8438042869a048f9a0156dd772fbbcfa74efa1378fecef339b7286f6fe4b4feb5c45d49966b35d08e3e83507",
+        "hash": "c5fa2cd72f6e6666b7963b97bc359c75284b8fb540c30f3629a028b85270c9bc66c8a051383964f2bd4c1e005a4691593d15696e7ef39ea87cf6cff9e5691fb2",
         "repo": "boostorg/headers",
-        "version": "boost-1.90.0"
+        "version": "boost-1.91.0"
     },
     "catch2": {
         "hash": "7eea385d79d88a5690cde131fe7ccda97d5c54ea09d6f515000d7bf07c828809d61c1ac99912c1ee507cf933f61c1c47ecdcc45df7850ffa82714034b0fccf35",

src/core/hle/service/am/display_layer_manager.cpp

@@ -129,9 +129,9 @@ Result DisplayLayerManager::IsSystemBufferSharingEnabled() {
     (void)m_display_service->GetContainer()->SetLayerStackMask(m_system_shared_layer_id,
                                                               this->GetLayerStackMask());
     m_manager_display_service->SetLayerBlending(m_blending_enabled, m_system_shared_layer_id);
-    s32 initial_z = 1;
+    s32 initial_z = Foreground;
     if (m_applet_id == AppletId::OverlayDisplay) {
-        initial_z = -1;
+        initial_z = Overlay;
         (void)m_display_service->GetContainer()->SetLayerIsOverlay(m_system_shared_layer_id, true);
     }
     m_manager_display_service->SetLayerZIndex(initial_z, m_system_shared_layer_id);

src/core/hle/service/sockets/bsd.cpp

@@ -54,11 +54,11 @@ void PutValue(std::span<u8> buffer, const T& t) {
 
 } // Anonymous namespace
 
-void BSD_USA::PollWork::Execute(BSD_USA* bsd) {
+void BSD::PollWork::Execute(BSD* bsd) {
     std::tie(ret, bsd_errno) = bsd->PollImpl(write_buffer, read_buffer, nfds, timeout);
 }
 
-void BSD_USA::PollWork::Response(HLERequestContext& ctx) {
+void BSD::PollWork::Response(HLERequestContext& ctx) {
     if (write_buffer.size() > 0) {
         ctx.WriteBuffer(write_buffer);
     }
@@ -69,11 +69,11 @@ void BSD_USA::PollWork::Response(HLERequestContext& ctx) {
     rb.PushEnum(bsd_errno);
 }
 
-void BSD_USA::AcceptWork::Execute(BSD_USA* bsd) {
+void BSD::AcceptWork::Execute(BSD* bsd) {
     std::tie(ret, bsd_errno) = bsd->AcceptImpl(fd, write_buffer);
 }
 
-void BSD_USA::AcceptWork::Response(HLERequestContext& ctx) {
+void BSD::AcceptWork::Response(HLERequestContext& ctx) {
     if (write_buffer.size() > 0) {
         ctx.WriteBuffer(write_buffer);
     }
@@ -85,22 +85,22 @@ void BSD_USA::AcceptWork::Response(HLERequestContext& ctx) {
     rb.Push<u32>(static_cast<u32>(write_buffer.size()));
 }
 
-void BSD_USA::ConnectWork::Execute(BSD_USA* bsd) {
+void BSD::ConnectWork::Execute(BSD* bsd) {
     bsd_errno = bsd->ConnectImpl(fd, addr);
 }
 
-void BSD_USA::ConnectWork::Response(HLERequestContext& ctx) {
+void BSD::ConnectWork::Response(HLERequestContext& ctx) {
     IPC::ResponseBuilder rb{ctx, 4};
     rb.Push(ResultSuccess);
     rb.Push<s32>(bsd_errno == Errno::SUCCESS ? 0 : -1);
     rb.PushEnum(bsd_errno);
 }
 
-void BSD_USA::RecvWork::Execute(BSD_USA* bsd) {
+void BSD::RecvWork::Execute(BSD* bsd) {
     std::tie(ret, bsd_errno) = bsd->RecvImpl(fd, flags, message);
 }
 
-void BSD_USA::RecvWork::Response(HLERequestContext& ctx) {
+void BSD::RecvWork::Response(HLERequestContext& ctx) {
     ctx.WriteBuffer(message);
 
     IPC::ResponseBuilder rb{ctx, 4};
@@ -109,11 +109,11 @@ void BSD_USA::RecvWork::Response(HLERequestContext& ctx) {
     rb.PushEnum(bsd_errno);
 }
 
-void BSD_USA::RecvFromWork::Execute(BSD_USA* bsd) {
+void BSD::RecvFromWork::Execute(BSD* bsd) {
     std::tie(ret, bsd_errno) = bsd->RecvFromImpl(fd, flags, message, addr);
 }
 
-void BSD_USA::RecvFromWork::Response(HLERequestContext& ctx) {
+void BSD::RecvFromWork::Response(HLERequestContext& ctx) {
     ctx.WriteBuffer(message, 0);
     if (!addr.empty()) {
         ctx.WriteBuffer(addr, 1);
@@ -126,29 +126,29 @@ void BSD_USA::RecvFromWork::Response(HLERequestContext& ctx) {
     rb.Push<u32>(static_cast<u32>(addr.size()));
 }
 
-void BSD_USA::SendWork::Execute(BSD_USA* bsd) {
+void BSD::SendWork::Execute(BSD* bsd) {
     std::tie(ret, bsd_errno) = bsd->SendImpl(fd, flags, message);
 }
 
-void BSD_USA::SendWork::Response(HLERequestContext& ctx) {
+void BSD::SendWork::Response(HLERequestContext& ctx) {
     IPC::ResponseBuilder rb{ctx, 4};
     rb.Push(ResultSuccess);
     rb.Push<s32>(ret);
     rb.PushEnum(bsd_errno);
 }
 
-void BSD_USA::SendToWork::Execute(BSD_USA* bsd) {
+void BSD::SendToWork::Execute(BSD* bsd) {
     std::tie(ret, bsd_errno) = bsd->SendToImpl(fd, flags, message, addr);
 }
 
-void BSD_USA::SendToWork::Response(HLERequestContext& ctx) {
+void BSD::SendToWork::Response(HLERequestContext& ctx) {
     IPC::ResponseBuilder rb{ctx, 4};
     rb.Push(ResultSuccess);
     rb.Push<s32>(ret);
     rb.PushEnum(bsd_errno);
 }
 
-void BSD_USA::RegisterClient(HLERequestContext& ctx) {
+void BSD::RegisterClient(HLERequestContext& ctx) {
     LOG_WARNING(Service, "(STUBBED) called");
 
     IPC::ResponseBuilder rb{ctx, 3};
@@ -157,7 +157,7 @@ void BSD_USA::RegisterClient(HLERequestContext& ctx) {
     rb.Push<s32>(0); // bsd errno
 }
 
-void BSD_USA::StartMonitoring(HLERequestContext& ctx) {
+void BSD::StartMonitoring(HLERequestContext& ctx) {
     LOG_WARNING(Service, "(STUBBED) called");
 
     IPC::ResponseBuilder rb{ctx, 2};
@@ -165,7 +165,7 @@ void BSD_USA::StartMonitoring(HLERequestContext& ctx) {
     rb.Push(ResultSuccess);
 }
 
-void BSD_USA::Socket(HLERequestContext& ctx) {
+void BSD::Socket(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const u32 domain = rp.Pop<u32>();
     const u32 type = rp.Pop<u32>();
@@ -181,7 +181,7 @@ void BSD_USA::Socket(HLERequestContext& ctx) {
     rb.PushEnum(bsd_errno);
 }
 
-void BSD_USA::SocketExempt(HLERequestContext& ctx) {
+void BSD::SocketExempt(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const u32 domain = rp.Pop<u32>();
     const u32 type = rp.Pop<u32>();
@@ -200,7 +200,7 @@ void BSD_USA::SocketExempt(HLERequestContext& ctx) {
     rb.PushEnum(bsd_errno);
 }
 
-void BSD_USA::Select(HLERequestContext& ctx) {
+void BSD::Select(HLERequestContext& ctx) {
     LOG_DEBUG(Service, "(STUBBED) called");
 
     IPC::ResponseBuilder rb{ctx, 4};
@@ -210,7 +210,7 @@ void BSD_USA::Select(HLERequestContext& ctx) {
     rb.Push<u32>(0); // bsd errno
 }
 
-void BSD_USA::Poll(HLERequestContext& ctx) {
+void BSD::Poll(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const s32 nfds = rp.Pop<s32>();
     const s32 timeout = rp.Pop<s32>();
@@ -225,7 +225,7 @@ void BSD_USA::Poll(HLERequestContext& ctx) {
                      });
 }
 
-void BSD_USA::Accept(HLERequestContext& ctx) {
+void BSD::Accept(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const s32 fd = rp.Pop<s32>();
 
@@ -237,7 +237,7 @@ void BSD_USA::Accept(HLERequestContext& ctx) {
                      });
 }
 
-void BSD_USA::Bind(HLERequestContext& ctx) {
+void BSD::Bind(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const s32 fd = rp.Pop<s32>();
 
@@ -245,7 +245,7 @@ void BSD_USA::Bind(HLERequestContext& ctx) {
     BuildErrnoResponse(ctx, BindImpl(fd, ctx.ReadBuffer()));
 }
 
-void BSD_USA::Connect(HLERequestContext& ctx) {
+void BSD::Connect(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const s32 fd = rp.Pop<s32>();
 
@@ -257,7 +257,7 @@ void BSD_USA::Connect(HLERequestContext& ctx) {
                      });
 }
 
-void BSD_USA::GetPeerName(HLERequestContext& ctx) {
+void BSD::GetPeerName(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const s32 fd = rp.Pop<s32>();
 
@@ -275,7 +275,7 @@ void BSD_USA::GetPeerName(HLERequestContext& ctx) {
     rb.Push<u32>(static_cast<u32>(write_buffer.size()));
 }
 
-void BSD_USA::GetSockName(HLERequestContext& ctx) {
+void BSD::GetSockName(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const s32 fd = rp.Pop<s32>();
 
@@ -293,7 +293,7 @@ void BSD_USA::GetSockName(HLERequestContext& ctx) {
     rb.Push<u32>(static_cast<u32>(write_buffer.size()));
 }
 
-void BSD_USA::GetSockOpt(HLERequestContext& ctx) {
+void BSD::GetSockOpt(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const s32 fd = rp.Pop<s32>();
     const u32 level = rp.Pop<u32>();
@@ -315,7 +315,7 @@ void BSD_USA::GetSockOpt(HLERequestContext& ctx) {
     rb.Push<u32>(static_cast<u32>(optval.size()));
 }
 
-void BSD_USA::Listen(HLERequestContext& ctx) {
+void BSD::Listen(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const s32 fd = rp.Pop<s32>();
     const s32 backlog = rp.Pop<s32>();
@@ -325,7 +325,7 @@ void BSD_USA::Listen(HLERequestContext& ctx) {
     BuildErrnoResponse(ctx, ListenImpl(fd, backlog));
 }
 
-void BSD_USA::Fcntl(HLERequestContext& ctx) {
+void BSD::Fcntl(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const s32 fd = rp.Pop<s32>();
     const s32 cmd = rp.Pop<s32>();
@@ -341,7 +341,7 @@ void BSD_USA::Fcntl(HLERequestContext& ctx) {
     rb.PushEnum(bsd_errno);
 }
 
-void BSD_USA::SetSockOpt(HLERequestContext& ctx) {
+void BSD::SetSockOpt(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
 
     const s32 fd = rp.Pop<s32>();
@@ -355,7 +355,7 @@ void BSD_USA::SetSockOpt(HLERequestContext& ctx) {
     BuildErrnoResponse(ctx, SetSockOptImpl(fd, level, optname, optval));
 }
 
-void BSD_USA::Shutdown(HLERequestContext& ctx) {
+void BSD::Shutdown(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
 
     const s32 fd = rp.Pop<s32>();
@@ -366,7 +366,7 @@ void BSD_USA::Shutdown(HLERequestContext& ctx) {
     BuildErrnoResponse(ctx, ShutdownImpl(fd, how));
 }
 
-void BSD_USA::Recv(HLERequestContext& ctx) {
+void BSD::Recv(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
 
     const s32 fd = rp.Pop<s32>();
@@ -381,7 +381,7 @@ void BSD_USA::Recv(HLERequestContext& ctx) {
                      });
 }
 
-void BSD_USA::RecvFrom(HLERequestContext& ctx) {
+void BSD::RecvFrom(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
 
     const s32 fd = rp.Pop<s32>();
@@ -398,7 +398,7 @@ void BSD_USA::RecvFrom(HLERequestContext& ctx) {
                      });
 }
 
-void BSD_USA::Send(HLERequestContext& ctx) {
+void BSD::Send(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
 
     const s32 fd = rp.Pop<s32>();
@@ -413,7 +413,7 @@ void BSD_USA::Send(HLERequestContext& ctx) {
                      });
 }
 
-void BSD_USA::SendTo(HLERequestContext& ctx) {
+void BSD::SendTo(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const s32 fd = rp.Pop<s32>();
     const u32 flags = rp.Pop<u32>();
@@ -429,7 +429,7 @@ void BSD_USA::SendTo(HLERequestContext& ctx) {
                      });
 }
 
-void BSD_USA::Write(HLERequestContext& ctx) {
+void BSD::Write(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const s32 fd = rp.Pop<s32>();
 
@@ -442,7 +442,7 @@ void BSD_USA::Write(HLERequestContext& ctx) {
                      });
 }
 
-void BSD_USA::Read(HLERequestContext& ctx) {
+void BSD::Read(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const s32 fd = rp.Pop<s32>();
 
@@ -454,7 +454,7 @@ void BSD_USA::Read(HLERequestContext& ctx) {
     rb.Push<u32>(0); // bsd errno
 }
 
-void BSD_USA::Close(HLERequestContext& ctx) {
+void BSD::Close(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const s32 fd = rp.Pop<s32>();
 
@@ -464,7 +464,7 @@ void BSD_USA::Close(HLERequestContext& ctx) {
 }
 
 /// @brief Only bsd:s is able to dup()
-void BSD_USA::DuplicateSocket(HLERequestContext& ctx) {
+void BSD::DuplicateSocket(HLERequestContext& ctx) {
     struct InputParameters {
         s32 fd;
         u64 reserved;
@@ -505,7 +505,7 @@ void BSD_USA::DuplicateSocket(HLERequestContext& ctx) {
     }
 }
 
-void BSD_USA::EventFd(HLERequestContext& ctx) {
+void BSD::EventFd(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const u64 initval = rp.Pop<u64>();
     const u32 flags = rp.Pop<u32>();
@@ -516,12 +516,12 @@ void BSD_USA::EventFd(HLERequestContext& ctx) {
 }
 
 template <typename Work>
-void BSD_USA::ExecuteWork(HLERequestContext& ctx, Work work) {
+void BSD::ExecuteWork(HLERequestContext& ctx, Work work) {
     work.Execute(this);
     work.Response(ctx);
 }
 
-std::pair<s32, Errno> BSD_USA::SocketImpl(Domain domain, Type type, Protocol protocol) {
+std::pair<s32, Errno> BSD::SocketImpl(Domain domain, Type type, Protocol protocol) {
     // user bsd:u has restrictions on SOCK_SEQPACKET and SOCK_RAW
     if (is_user && (type == Type::SEQPACKET || type == Type::RAW)) {
         if (type == Type::RAW && domain == Domain::INET && protocol == Protocol::ICMP) {
@@ -565,7 +565,7 @@ std::pair<s32, Errno> BSD_USA::SocketImpl(Domain domain, Type type, Protocol pro
     return {fd, Errno::SUCCESS};
 }
 
-std::pair<s32, Errno> BSD_USA::PollImpl(std::vector<u8>& write_buffer, std::span<const u8> read_buffer,
+std::pair<s32, Errno> BSD::PollImpl(std::vector<u8>& write_buffer, std::span<const u8> read_buffer,
                                     s32 nfds, s32 timeout) {
     if (nfds <= 0) {
         // When no entries are provided, -1 is returned with errno zero
@@ -632,7 +632,7 @@ std::pair<s32, Errno> BSD_USA::PollImpl(std::vector<u8>& write_buffer, std::span
     return Translate(result);
 }
 
-std::pair<s32, Errno> BSD_USA::AcceptImpl(s32 fd, std::vector<u8>& write_buffer) {
+std::pair<s32, Errno> BSD::AcceptImpl(s32 fd, std::vector<u8>& write_buffer) {
     if (!IsFileDescriptorValid(fd)) {
         return {-1, Errno::BADF};
     }
@@ -660,7 +660,7 @@ std::pair<s32, Errno> BSD_USA::AcceptImpl(s32 fd, std::vector<u8>& write_buffer)
     return {new_fd, Errno::SUCCESS};
 }
 
-Errno BSD_USA::BindImpl(s32 fd, std::span<const u8> addr) {
+Errno BSD::BindImpl(s32 fd, std::span<const u8> addr) {
     if (!IsFileDescriptorValid(fd)) {
         return Errno::BADF;
     }
@@ -675,7 +675,7 @@ Errno BSD_USA::BindImpl(s32 fd, std::span<const u8> addr) {
     return Translate(file_descriptors[fd]->socket->Bind(Translate(addr_in)));
 }
 
-Errno BSD_USA::ConnectImpl(s32 fd, std::span<const u8> addr) {
+Errno BSD::ConnectImpl(s32 fd, std::span<const u8> addr) {
     if (!IsFileDescriptorValid(fd)) {
         return Errno::BADF;
     }
@@ -698,7 +698,7 @@ Errno BSD_USA::ConnectImpl(s32 fd, std::span<const u8> addr) {
     return result;
 }
 
-Errno BSD_USA::GetPeerNameImpl(s32 fd, std::vector<u8>& write_buffer) {
+Errno BSD::GetPeerNameImpl(s32 fd, std::vector<u8>& write_buffer) {
     if (!IsFileDescriptorValid(fd)) {
         return Errno::BADF;
     }
@@ -720,7 +720,7 @@ Errno BSD_USA::GetPeerNameImpl(s32 fd, std::vector<u8>& write_buffer) {
     return Translate(bsd_errno);
 }
 
-Errno BSD_USA::GetSockNameImpl(s32 fd, std::vector<u8>& write_buffer) {
+Errno BSD::GetSockNameImpl(s32 fd, std::vector<u8>& write_buffer) {
     if (!IsFileDescriptorValid(fd)) {
         return Errno::BADF;
     }
@@ -742,7 +742,7 @@ Errno BSD_USA::GetSockNameImpl(s32 fd, std::vector<u8>& write_buffer) {
     return Translate(bsd_errno);
 }
 
-Errno BSD_USA::ListenImpl(s32 fd, s32 backlog) {
+Errno BSD::ListenImpl(s32 fd, s32 backlog) {
     if (!IsFileDescriptorValid(fd)) {
         return Errno::BADF;
     }
@@ -753,7 +753,7 @@ Errno BSD_USA::ListenImpl(s32 fd, s32 backlog) {
     return Translate(file_descriptors[fd]->socket->Listen(backlog));
 }
 
-std::pair<s32, Errno> BSD_USA::FcntlImpl(s32 fd, FcntlCmd cmd, s32 arg) {
+std::pair<s32, Errno> BSD::FcntlImpl(s32 fd, FcntlCmd cmd, s32 arg) {
     if (!IsFileDescriptorValid(fd)) {
         return {-1, Errno::BADF};
     }
@@ -783,7 +783,7 @@ std::pair<s32, Errno> BSD_USA::FcntlImpl(s32 fd, FcntlCmd cmd, s32 arg) {
     }
 }
 
-Errno BSD_USA::GetSockOptImpl(s32 fd, u32 level, OptName optname, std::vector<u8>& optval) {
+Errno BSD::GetSockOptImpl(s32 fd, u32 level, OptName optname, std::vector<u8>& optval) {
     if (!IsFileDescriptorValid(fd)) {
         return Errno::BADF;
     }
@@ -818,7 +818,7 @@ Errno BSD_USA::GetSockOptImpl(s32 fd, u32 level, OptName optname, std::vector<u8
     }
 }
 
-Errno BSD_USA::SetSockOptImpl(s32 fd, u32 level, OptName optname, std::span<const u8> optval) {
+Errno BSD::SetSockOptImpl(s32 fd, u32 level, OptName optname, std::span<const u8> optval) {
     if (!IsFileDescriptorValid(fd)) {
         return Errno::BADF;
     }
@@ -872,7 +872,7 @@ Errno BSD_USA::SetSockOptImpl(s32 fd, u32 level, OptName optname, std::span<cons
     }
 }
 
-Errno BSD_USA::ShutdownImpl(s32 fd, s32 how) {
+Errno BSD::ShutdownImpl(s32 fd, s32 how) {
     if (!IsFileDescriptorValid(fd)) {
         return Errno::BADF;
     }
@@ -884,7 +884,7 @@ Errno BSD_USA::ShutdownImpl(s32 fd, s32 how) {
     return Translate(file_descriptors[fd]->socket->Shutdown(host_how));
 }
 
-std::pair<s32, Errno> BSD_USA::RecvImpl(s32 fd, u32 flags, std::vector<u8>& message) {
+std::pair<s32, Errno> BSD::RecvImpl(s32 fd, u32 flags, std::vector<u8>& message) {
     if (!IsFileDescriptorValid(fd)) {
         return {-1, Errno::BADF};
     }
@@ -911,7 +911,7 @@ std::pair<s32, Errno> BSD_USA::RecvImpl(s32 fd, u32 flags, std::vector<u8>& mess
     return {ret, bsd_errno};
 }
 
-std::pair<s32, Errno> BSD_USA::RecvFromImpl(s32 fd, u32 flags, std::vector<u8>& message,
+std::pair<s32, Errno> BSD::RecvFromImpl(s32 fd, u32 flags, std::vector<u8>& message,
                                         std::vector<u8>& addr) {
     if (!IsFileDescriptorValid(fd)) {
         return {-1, Errno::BADF};
@@ -958,7 +958,7 @@ std::pair<s32, Errno> BSD_USA::RecvFromImpl(s32 fd, u32 flags, std::vector<u8>&
     return {ret, bsd_errno};
 }
 
-std::pair<s32, Errno> BSD_USA::SendImpl(s32 fd, u32 flags, std::span<const u8> message) {
+std::pair<s32, Errno> BSD::SendImpl(s32 fd, u32 flags, std::span<const u8> message) {
     if (!IsFileDescriptorValid(fd)) {
         return {-1, Errno::BADF};
     }
@@ -969,7 +969,7 @@ std::pair<s32, Errno> BSD_USA::SendImpl(s32 fd, u32 flags, std::span<const u8> m
     return Translate(file_descriptors[fd]->socket->Send(message, flags));
 }
 
-std::pair<s32, Errno> BSD_USA::SendToImpl(s32 fd, u32 flags, std::span<const u8> message,
+std::pair<s32, Errno> BSD::SendToImpl(s32 fd, u32 flags, std::span<const u8> message,
                                       std::span<const u8> addr) {
     if (!IsFileDescriptorValid(fd)) {
         return {-1, Errno::BADF};
@@ -991,7 +991,7 @@ std::pair<s32, Errno> BSD_USA::SendToImpl(s32 fd, u32 flags, std::span<const u8>
     return Translate(file_descriptors[fd]->socket->SendTo(flags, message, p_addr_in));
 }
 
-Errno BSD_USA::CloseImpl(s32 fd) {
+Errno BSD::CloseImpl(s32 fd) {
     if (!IsFileDescriptorValid(fd)) {
         return Errno::BADF;
     }
@@ -1011,7 +1011,7 @@ Errno BSD_USA::CloseImpl(s32 fd) {
     return bsd_errno;
 }
 
-std::variant<s32, Errno> BSD_USA::DuplicateSocketImpl(s32 fd) {
+std::variant<s32, Errno> BSD::DuplicateSocketImpl(s32 fd) {
     if (!IsFileDescriptorValid(fd)) {
         return Errno::BADF;
     }
@@ -1030,7 +1030,7 @@ std::variant<s32, Errno> BSD_USA::DuplicateSocketImpl(s32 fd) {
     return new_fd;
 }
 
-std::optional<std::shared_ptr<Network::SocketBase>> BSD_USA::GetSocket(s32 fd) {
+std::optional<std::shared_ptr<Network::SocketBase>> BSD::GetSocket(s32 fd) {
     if (!IsFileDescriptorValid(fd)) {
         return std::nullopt;
     }
@@ -1041,7 +1041,7 @@ std::optional<std::shared_ptr<Network::SocketBase>> BSD_USA::GetSocket(s32 fd) {
     return file_descriptors[fd]->socket;
 }
 
-s32 BSD_USA::FindFreeFileDescriptorHandle() noexcept {
+s32 BSD::FindFreeFileDescriptorHandle() noexcept {
     for (s32 fd = 0; fd < static_cast<s32>(file_descriptors.size()); ++fd) {
         if (!file_descriptors[fd]) {
             return fd;
@@ -1050,7 +1050,7 @@ s32 BSD_USA::FindFreeFileDescriptorHandle() noexcept {
     return -1;
 }
 
-bool BSD_USA::IsFileDescriptorValid(s32 fd) const noexcept {
+bool BSD::IsFileDescriptorValid(s32 fd) const noexcept {
     if (fd > static_cast<s32>(MAX_FD) || fd < 0) {
         LOG_ERROR(Service, "Invalid file descriptor handle={}", fd);
         return false;
@@ -1062,7 +1062,7 @@ bool BSD_USA::IsFileDescriptorValid(s32 fd) const noexcept {
     return true;
 }
 
-void BSD_USA::BuildErrnoResponse(HLERequestContext& ctx, Errno bsd_errno) const noexcept {
+void BSD::BuildErrnoResponse(HLERequestContext& ctx, Errno bsd_errno) const noexcept {
     IPC::ResponseBuilder rb{ctx, 4};
 
     rb.Push(ResultSuccess);
@@ -1070,7 +1070,7 @@ void BSD_USA::BuildErrnoResponse(HLERequestContext& ctx, Errno bsd_errno) const
     rb.PushEnum(bsd_errno);
 }
 
-void BSD_USA::OnProxyPacketReceived(const Network::ProxyPacket& packet) {
+void BSD::OnProxyPacketReceived(const Network::ProxyPacket& packet) {
     for (auto& optional_descriptor : file_descriptors) {
         if (!optional_descriptor.has_value()) {
             continue;
@@ -1080,43 +1080,43 @@ void BSD_USA::OnProxyPacketReceived(const Network::ProxyPacket& packet) {
     }
 }
 
-BSD_USA::BSD_USA(Core::System& system_, const char* name, bool is_user_)
+BSD::BSD(Core::System& system_, const char* name, bool is_user_)
     : ServiceFramework{system_, name}
     , is_user{is_user_} {
     // clang-format off
     static const FunctionInfo functions[] = {
-        {0, &BSD_USA::RegisterClient, "RegisterClient"},
+        {0, &BSD::RegisterClient, "RegisterClient"},
-        {1, &BSD_USA::StartMonitoring, "StartMonitoring"},
+        {1, &BSD::StartMonitoring, "StartMonitoring"},
-        {2, &BSD_USA::Socket, "Socket"},
+        {2, &BSD::Socket, "Socket"},
-        {3, &BSD_USA::SocketExempt, "SocketExempt"},
+        {3, &BSD::SocketExempt, "SocketExempt"},
         {4, nullptr, "Open"},
-        {5, &BSD_USA::Select, "Select"},
+        {5, &BSD::Select, "Select"},
-        {6, &BSD_USA::Poll, "Poll"},
+        {6, &BSD::Poll, "Poll"},
         {7, nullptr, "Sysctl"},
-        {8, &BSD_USA::Recv, "Recv"},
+        {8, &BSD::Recv, "Recv"},
-        {9, &BSD_USA::RecvFrom, "RecvFrom"},
+        {9, &BSD::RecvFrom, "RecvFrom"},
-        {10, &BSD_USA::Send, "Send"},
+        {10, &BSD::Send, "Send"},
-        {11, &BSD_USA::SendTo, "SendTo"},
+        {11, &BSD::SendTo, "SendTo"},
-        {12, &BSD_USA::Accept, "Accept"},
+        {12, &BSD::Accept, "Accept"},
-        {13, &BSD_USA::Bind, "Bind"},
+        {13, &BSD::Bind, "Bind"},
-        {14, &BSD_USA::Connect, "Connect"},
+        {14, &BSD::Connect, "Connect"},
-        {15, &BSD_USA::GetPeerName, "GetPeerName"},
+        {15, &BSD::GetPeerName, "GetPeerName"},
-        {16, &BSD_USA::GetSockName, "GetSockName"},
+        {16, &BSD::GetSockName, "GetSockName"},
-        {17, &BSD_USA::GetSockOpt, "GetSockOpt"},
+        {17, &BSD::GetSockOpt, "GetSockOpt"},
-        {18, &BSD_USA::Listen, "Listen"},
+        {18, &BSD::Listen, "Listen"},
         {19, nullptr, "Ioctl"},
-        {20, &BSD_USA::Fcntl, "Fcntl"},
+        {20, &BSD::Fcntl, "Fcntl"},
-        {21, &BSD_USA::SetSockOpt, "SetSockOpt"},
+        {21, &BSD::SetSockOpt, "SetSockOpt"},
-        {22, &BSD_USA::Shutdown, "Shutdown"},
+        {22, &BSD::Shutdown, "Shutdown"},
         {23, nullptr, "ShutdownAllSockets"},
-        {24, &BSD_USA::Write, "Write"},
+        {24, &BSD::Write, "Write"},
-        {25, &BSD_USA::Read, "Read"},
+        {25, &BSD::Read, "Read"},
-        {26, &BSD_USA::Close, "Close"},
+        {26, &BSD::Close, "Close"},
-        {27, &BSD_USA::DuplicateSocket, "DuplicateSocket"},
+        {27, &BSD::DuplicateSocket, "DuplicateSocket"},
         {28, nullptr, "GetResourceStatistics"},
         {29, nullptr, "RecvMMsg"}, //3.0.0+
         {30, nullptr, "SendMMsg"}, //3.0.0+
-        {31, &BSD_USA::EventFd, "EventFd"}, //7.0.0+
+        {31, &BSD::EventFd, "EventFd"}, //7.0.0+
         {32, nullptr, "RegisterResourceStatisticsName"}, //7.0.0+
         {33, nullptr, "RegisterClientShared"}, //10.0.0+
         {34, nullptr, "GetSocketStatistics"}, //15.0.0+
@@ -1144,13 +1144,13 @@ BSD_USA::BSD_USA(Core::System& system_, const char* name, bool is_user_)
     }
 }
 
-BSD_USA::~BSD_USA() {
+BSD::~BSD() {
     if (auto room_member = Network::GetRoomMember().lock()) {
         room_member->Unbind(proxy_packet_received);
     }
 }
 
-std::unique_lock<std::mutex> BSD_USA::LockService() noexcept {
+std::unique_lock<std::mutex> BSD::LockService() noexcept {
     return {};
 }
 

src/core/hle/service/sockets/bsd.h

@@ -27,10 +27,10 @@ class Socket;
 
 namespace Service::Sockets {
 
-class BSD_USA final : public ServiceFramework<BSD_USA> {
+class BSD final : public ServiceFramework<BSD> {
 public:
-    explicit BSD_USA(Core::System& system_, const char* name, bool is_user);
+    explicit BSD(Core::System& system_, const char* name, bool is_user);
-    ~BSD_USA() override;
+    ~BSD() override;
 
     // These methods are called from SSL; the first two are also called from
     // this class for the corresponding IPC methods.
@@ -50,7 +50,7 @@ private:
     };
 
     struct PollWork {
-        void Execute(BSD_USA* bsd);
+        void Execute(BSD* bsd);
         void Response(HLERequestContext& ctx);
 
         s32 nfds;
@@ -62,7 +62,7 @@ private:
     };
 
     struct AcceptWork {
-        void Execute(BSD_USA* bsd);
+        void Execute(BSD* bsd);
         void Response(HLERequestContext& ctx);
 
         s32 fd;
@@ -72,7 +72,7 @@ private:
     };
 
     struct ConnectWork {
-        void Execute(BSD_USA* bsd);
+        void Execute(BSD* bsd);
         void Response(HLERequestContext& ctx);
 
         s32 fd;
@@ -81,7 +81,7 @@ private:
     };
 
     struct RecvWork {
-        void Execute(BSD_USA* bsd);
+        void Execute(BSD* bsd);
         void Response(HLERequestContext& ctx);
 
         s32 fd;
@@ -92,7 +92,7 @@ private:
     };
 
     struct RecvFromWork {
-        void Execute(BSD_USA* bsd);
+        void Execute(BSD* bsd);
         void Response(HLERequestContext& ctx);
 
         s32 fd;
@@ -104,7 +104,7 @@ private:
     };
 
     struct SendWork {
-        void Execute(BSD_USA* bsd);
+        void Execute(BSD* bsd);
         void Response(HLERequestContext& ctx);
 
         s32 fd;
@@ -115,7 +115,7 @@ private:
     };
 
     struct SendToWork {
-        void Execute(BSD_USA* bsd);
+        void Execute(BSD* bsd);
         void Response(HLERequestContext& ctx);
 
         s32 fd;

src/core/hle/service/sockets/sockets.cpp

@@ -66,9 +66,9 @@ void LoopProcess(Core::System& system) {
 
     server_manager->RegisterNamedService("ethc:c", std::make_shared<ETHC_C>(system));
     server_manager->RegisterNamedService("ethc:i", std::make_shared<ETHC_I>(system));
-    server_manager->RegisterNamedService("bsd:s", std::make_shared<BSD_USA>(system, "bsd:s", false));
+    server_manager->RegisterNamedService("bsd:s", std::make_shared<BSD>(system, "bsd:s", false));
-    server_manager->RegisterNamedService("bsd:u", std::make_shared<BSD_USA>(system, "bsd:u", true));
+    server_manager->RegisterNamedService("bsd:u", std::make_shared<BSD>(system, "bsd:u", true));
-    server_manager->RegisterNamedService("bsd:a", std::make_shared<BSD_USA>(system, "bsd:a", true));
+    server_manager->RegisterNamedService("bsd:a", std::make_shared<BSD>(system, "bsd:a", true));
     server_manager->RegisterNamedService("bsd:nu", std::make_shared<BSD_NU>(system));
     server_manager->RegisterNamedService("bsdcfg", std::make_shared<BSDCFG>(system, "bsdcfg"));
     server_manager->RegisterNamedService("ifcfg", std::make_shared<BSDCFG>(system, "ifcfg"));

src/core/hle/service/ssl/ssl.cpp

@@ -129,7 +129,7 @@ public:
                 LOG_ERROR(Service_SSL,
                           "do_not_close_socket was changed after setting socket; is this right?");
             } else {
-                auto bsd = system.ServiceManager().GetService<Service::Sockets::BSD_USA>("bsd:u");
+                auto bsd = system.ServiceManager().GetService<Service::Sockets::BSD>("bsd:u");
                 if (bsd) {
                     auto err = bsd->CloseImpl(fd);
                     if (err != Service::Sockets::Errno::SUCCESS) {
@@ -157,7 +157,7 @@ private:
     Result SetSocketDescriptorImpl(s32* out_fd, s32 fd) {
         LOG_DEBUG(Service_SSL, "called, fd={}", fd);
         ASSERT(!did_handshake);
-        auto bsd = system.ServiceManager().GetService<Service::Sockets::BSD_USA>("bsd:u");
+        auto bsd = system.ServiceManager().GetService<Service::Sockets::BSD>("bsd:u");
         ASSERT_OR_EXECUTE(bsd, { return ResultInternalError; });
 
         auto const res_v = bsd->DuplicateSocketImpl(fd);

src/dynarmic/src/dynarmic/backend/x64/block_of_code.cpp

@@ -76,34 +76,57 @@ void ProtectMemory(const void* base, size_t size, bool is_executable) {
 }
 #endif
 
-static const HostFeature features = []() {
+HostFeature GetHostFeatures() {
-    HostFeature f{};
+    HostFeature features = {};
 #ifdef DYNARMIC_ENABLE_CPU_FEATURE_DETECTION
     using Cpu = Xbyak::util::Cpu;
     Xbyak::util::Cpu cpu_info{};
-    if (cpu_info.has(Cpu::tSSSE3)) f |= HostFeature::SSSE3;
+    if (cpu_info.has(Cpu::tSSSE3))
-    if (cpu_info.has(Cpu::tSSE41)) f |= HostFeature::SSE41;
+        features |= HostFeature::SSSE3;
-    if (cpu_info.has(Cpu::tSSE42)) f |= HostFeature::SSE42;
+    if (cpu_info.has(Cpu::tSSE41))
-    if (cpu_info.has(Cpu::tAVX)) f |= HostFeature::AVX;
+        features |= HostFeature::SSE41;
-    if (cpu_info.has(Cpu::tAVX2)) f |= HostFeature::AVX2;
+    if (cpu_info.has(Cpu::tSSE42))
-    if (cpu_info.has(Cpu::tAVX512F)) f |= HostFeature::AVX512F;
+        features |= HostFeature::SSE42;
-    if (cpu_info.has(Cpu::tAVX512CD)) f |= HostFeature::AVX512CD;
+    if (cpu_info.has(Cpu::tAVX))
-    if (cpu_info.has(Cpu::tAVX512VL)) f |= HostFeature::AVX512VL;
+        features |= HostFeature::AVX;
-    if (cpu_info.has(Cpu::tAVX512BW)) f |= HostFeature::AVX512BW;
+    if (cpu_info.has(Cpu::tAVX2))
-    if (cpu_info.has(Cpu::tAVX512DQ)) f |= HostFeature::AVX512DQ;
+        features |= HostFeature::AVX2;
-    if (cpu_info.has(Cpu::tAVX512_BITALG)) f |= HostFeature::AVX512BITALG;
+    if (cpu_info.has(Cpu::tAVX512F))
-    if (cpu_info.has(Cpu::tAVX512VBMI)) f |= HostFeature::AVX512VBMI;
+        features |= HostFeature::AVX512F;
-    if (cpu_info.has(Cpu::tPCLMULQDQ)) f |= HostFeature::PCLMULQDQ;
+    if (cpu_info.has(Cpu::tAVX512CD))
-    if (cpu_info.has(Cpu::tF16C)) f |= HostFeature::F16C;
+        features |= HostFeature::AVX512CD;
-    if (cpu_info.has(Cpu::tFMA)) f |= HostFeature::FMA;
+    if (cpu_info.has(Cpu::tAVX512VL))
-    if (cpu_info.has(Cpu::tAESNI)) f |= HostFeature::AES;
+        features |= HostFeature::AVX512VL;
-    if (cpu_info.has(Cpu::tSHA)) f |= HostFeature::SHA;
+    if (cpu_info.has(Cpu::tAVX512BW))
-    if (cpu_info.has(Cpu::tPOPCNT)) f |= HostFeature::POPCNT;
+        features |= HostFeature::AVX512BW;
-    if (cpu_info.has(Cpu::tBMI1)) f |= HostFeature::BMI1;
+    if (cpu_info.has(Cpu::tAVX512DQ))
-    if (cpu_info.has(Cpu::tBMI2)) f |= HostFeature::BMI2;
+        features |= HostFeature::AVX512DQ;
-    if (cpu_info.has(Cpu::tLZCNT)) f |= HostFeature::LZCNT;
+    if (cpu_info.has(Cpu::tAVX512_BITALG))
-    if (cpu_info.has(Cpu::tGFNI)) f |= HostFeature::GFNI;
+        features |= HostFeature::AVX512BITALG;
-    if (cpu_info.has(Cpu::tWAITPKG)) f |= HostFeature::WAITPKG;
+    if (cpu_info.has(Cpu::tAVX512VBMI))
+        features |= HostFeature::AVX512VBMI;
+    if (cpu_info.has(Cpu::tPCLMULQDQ))
+        features |= HostFeature::PCLMULQDQ;
+    if (cpu_info.has(Cpu::tF16C))
+        features |= HostFeature::F16C;
+    if (cpu_info.has(Cpu::tFMA))
+        features |= HostFeature::FMA;
+    if (cpu_info.has(Cpu::tAESNI))
+        features |= HostFeature::AES;
+    if (cpu_info.has(Cpu::tSHA))
+        features |= HostFeature::SHA;
+    if (cpu_info.has(Cpu::tPOPCNT))
+        features |= HostFeature::POPCNT;
+    if (cpu_info.has(Cpu::tBMI1))
+        features |= HostFeature::BMI1;
+    if (cpu_info.has(Cpu::tBMI2))
+        features |= HostFeature::BMI2;
+    if (cpu_info.has(Cpu::tLZCNT))
+        features |= HostFeature::LZCNT;
+    if (cpu_info.has(Cpu::tGFNI))
+        features |= HostFeature::GFNI;
+    if (cpu_info.has(Cpu::tWAITPKG))
+        features |= HostFeature::WAITPKG;
     if (cpu_info.has(Cpu::tBMI2)) {
         // BMI2 instructions such as pdep and pext have been very slow up until Zen 3.
         // Check for Zen 3 or newer by its family (0x19).
@@ -115,15 +138,12 @@ static const HostFeature features = []() {
             const u32 family_extended = mcl::bit::get_bits<20, 27>(data[0]);
             const u32 family = family_base + family_extended;
             if (family >= 0x19)
-                f |= HostFeature::FastBMI2;
+                features |= HostFeature::FastBMI2;
         } else {
-            f |= HostFeature::FastBMI2;
+            features |= HostFeature::FastBMI2;
         }
     }
-    return f;
 #endif
-}();
-HostFeature GetHostFeatures() {
     return features;
 }
 

src/video_core/buffer_cache/usage_tracker.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -12,13 +9,13 @@
 namespace VideoCommon {
 
 class UsageTracker {
-    // PAGE_SHIFT is a macro on FreeBSD
+    static constexpr size_t BYTES_PER_BIT_SHIFT = 6;
-    static constexpr size_t BUFFER_BYTES_PER_BITSHIFT = 6;
+    static constexpr size_t PAGE_SHIFT = 6 + BYTES_PER_BIT_SHIFT;
-    static constexpr size_t BUFFER_PAGE_SHIFT = 6 + BUFFER_BYTES_PER_BITSHIFT;
+    static constexpr size_t PAGE_BYTES = 1 << PAGE_SHIFT;
-    static constexpr size_t BUFFER_PAGE_BYTES = 1 << BUFFER_PAGE_SHIFT;
+
 public:
     explicit UsageTracker(size_t size) {
-        const size_t num_pages = (size >> BUFFER_PAGE_SHIFT) + 1;
+        const size_t num_pages = (size >> PAGE_SHIFT) + 1;
         pages.resize(num_pages, 0ULL);
     }
 
@@ -27,8 +24,8 @@ public:
     }
 
     void Track(u64 offset, u64 size) noexcept {
-        const size_t page = offset >> BUFFER_PAGE_SHIFT;
+        const size_t page = offset >> PAGE_SHIFT;
-        const size_t page_end = (offset + size) >> BUFFER_PAGE_SHIFT;
+        const size_t page_end = (offset + size) >> PAGE_SHIFT;
         if (page_end < page || page_end >= pages.size()) {
             return;
         }
@@ -40,13 +37,13 @@ public:
             pages[i] = ~u64{0};
         }
         const size_t offset_end = offset + size;
-        const size_t offset_end_page_aligned = Common::AlignDown(offset_end, BUFFER_PAGE_BYTES);
+        const size_t offset_end_page_aligned = Common::AlignDown(offset_end, PAGE_BYTES);
         TrackPage(page_end, offset_end_page_aligned, offset_end - offset_end_page_aligned);
     }
 
     [[nodiscard]] bool IsUsed(u64 offset, u64 size) const noexcept {
-        const size_t page = offset >> BUFFER_PAGE_SHIFT;
+        const size_t page = offset >> PAGE_SHIFT;
-        const size_t page_end = (offset + size) >> BUFFER_PAGE_SHIFT;
+        const size_t page_end = (offset + size) >> PAGE_SHIFT;
         if (page_end < page || page_end >= pages.size()) {
             return false;
         }
@@ -59,23 +56,23 @@ public:
             }
         }
         const size_t offset_end = offset + size;
-        const size_t offset_end_page_aligned = Common::AlignDown(offset_end, BUFFER_PAGE_BYTES);
+        const size_t offset_end_page_aligned = Common::AlignDown(offset_end, PAGE_BYTES);
         return IsPageUsed(page_end, offset_end_page_aligned, offset_end - offset_end_page_aligned);
     }
 
 private:
     void TrackPage(u64 page, u64 offset, u64 size) noexcept {
-        const size_t offset_in_page = offset % BUFFER_PAGE_BYTES;
+        const size_t offset_in_page = offset % PAGE_BYTES;
-        const size_t first_bit = offset_in_page >> BUFFER_BYTES_PER_BITSHIFT;
+        const size_t first_bit = offset_in_page >> BYTES_PER_BIT_SHIFT;
-        const size_t num_bits = std::min<size_t>(size, BUFFER_PAGE_BYTES) >> BUFFER_BYTES_PER_BITSHIFT;
+        const size_t num_bits = std::min<size_t>(size, PAGE_BYTES) >> BYTES_PER_BIT_SHIFT;
         const size_t mask = ~u64{0} >> (64 - num_bits);
         pages[page] |= (~u64{0} & mask) << first_bit;
     }
 
     bool IsPageUsed(u64 page, u64 offset, u64 size) const noexcept {
-        const size_t offset_in_page = offset % BUFFER_PAGE_BYTES;
+        const size_t offset_in_page = offset % PAGE_BYTES;
-        const size_t first_bit = offset_in_page >> BUFFER_BYTES_PER_BITSHIFT;
+        const size_t first_bit = offset_in_page >> BYTES_PER_BIT_SHIFT;
-        const size_t num_bits = std::min<size_t>(size, BUFFER_PAGE_BYTES) >> BUFFER_BYTES_PER_BITSHIFT;
+        const size_t num_bits = std::min<size_t>(size, PAGE_BYTES) >> BYTES_PER_BIT_SHIFT;
         const size_t mask = ~u64{0} >> (64 - num_bits);
         const size_t mask2 = (~u64{0} & mask) << first_bit;
         return (pages[page] & mask2) != 0;

tools/cpm/cmake/package/version.cmake

@@ -65,7 +65,7 @@ else()
 endif()
 
 # update cached cpmfile content
-string(JSON cpmfile SET "${cpmfile}" "${key}" "${new_object}")
+string(JSON cpmfile SET "${cpmfile}" "${KEY}" "${new_object}")
 
 # write cached cpmfile
 get_cpmfile_path(file)