Fix license headers

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

CMakeLists.txt

@@ -66,6 +66,26 @@ if (YUZU_STATIC_ROOM)
     set(fmt_FORCE_BUNDLED ON)
 endif()
 
+# my unity/jumbo build
+option(ENABLE_UNITY_BUILD "Enable Unity/Jumbo build" OFF)
+
+# 0 compiles all files in
+# not ideal, but if you're going gung-ho with a unity build, expect failure
+# MSVC physically can't compile that many files into one TU, so we limit it to 100.
+if (MSVC)
+    set(_unity_default 100)
+else()
+    set(_unity_default 0)
+endif()
+
+set(UNITY_BATCH_SIZE ${_unity_default} CACHE STRING "Unity build batch size")
+
+if(MSVC AND ENABLE_UNITY_BUILD)
+    message(STATUS "Unity build")
+    # Unity builds need big objects for MSVC...
+    add_compile_options(/bigobj)
+endif()
+
 # qt stuff
 option(ENABLE_QT "Enable the Qt frontend" ON)
 option(ENABLE_QT_TRANSLATION "Enable translations for the Qt frontend" OFF)

docs/Options.md

@@ -40,6 +40,7 @@ These options control dependencies.
   - This option is subject for removal.
 - `YUZU_TESTS` (ON) Compile tests - requires Catch2
 - `ENABLE_LTO` (OFF) Enable link-time optimization
+- `ENABLE_UNITY_BUILD` (OFF) Enables "Unity/Jumbo" builds
   - Not recommended on Windows
   - UNIX may be better off appending `-flto=thin` to compiler args
 - `USE_FASTER_LINKER` (OFF) Check if a faster linker is available

src/CMakeLists.txt

@@ -7,6 +7,11 @@
 # Enable modules to include each other's files
 include_directories(.)
 
+if (ENABLE_UNITY_BUILD)
+    set(CMAKE_UNITY_BUILD ON)
+    set(CMAKE_UNITY_BUILD_BATCH_SIZE ${UNITY_BATCH_SIZE})
+endif()
+
 # Dynarmic
 if (ARCHITECTURE_x86_64 OR ARCHITECTURE_arm64 AND NOT YUZU_STATIC_ROOM)
     add_subdirectory(dynarmic)

src/audio_core/adsp/apps/opus/opus_decode_object.cpp

@@ -1,3 +1,6 @@
+// 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-2.0-or-later
 
@@ -5,17 +8,11 @@
 #include "common/assert.h"
 
 namespace AudioCore::ADSP::OpusDecoder {
-namespace {
-bool IsValidChannelCount(u32 channel_count) {
-    return channel_count == 1 || channel_count == 2;
-}
-} // namespace
 
 u32 OpusDecodeObject::GetWorkBufferSize(u32 channel_count) {
-    if (!IsValidChannelCount(channel_count)) {
+    if (channel_count == 1 || channel_count == 2)
         return 0;
-    }
-    return static_cast<u32>(sizeof(OpusDecodeObject)) + opus_decoder_get_size(channel_count);
+    return u32(sizeof(OpusDecodeObject)) + opus_decoder_get_size(channel_count);
 }
 
 OpusDecodeObject& OpusDecodeObject::Initialize(u64 buffer, u64 buffer2) {

src/audio_core/adsp/apps/opus/opus_decoder.cpp

@@ -22,10 +22,6 @@ namespace AudioCore::ADSP::OpusDecoder {
 namespace {
 constexpr size_t OpusStreamCountMax = 255;
 
-bool IsValidChannelCount(u32 channel_count) {
-    return channel_count == 1 || channel_count == 2;
-}
-
 bool IsValidMultiStreamChannelCount(u32 channel_count) {
     return channel_count <= OpusStreamCountMax;
 }
@@ -90,7 +86,7 @@ void OpusDecoder::Main(std::stop_token stop_token) {
         case GetWorkBufferSize: {
             auto channel_count = static_cast<s32>(shared_memory->host_send_data[0]);
 
-            ASSERT(IsValidChannelCount(channel_count));
+            ASSERT(channel_count == 1 || channel_count == 2);
 
             shared_memory->dsp_return_data[0] = OpusDecodeObject::GetWorkBufferSize(channel_count);
             Send(Direction::Host, Message::GetWorkBufferSizeOK);
@@ -103,7 +99,7 @@ void OpusDecoder::Main(std::stop_token stop_token) {
             auto channel_count = static_cast<s32>(shared_memory->host_send_data[3]);
 
             ASSERT(sample_rate >= 0);
-            ASSERT(IsValidChannelCount(channel_count));
+            ASSERT(channel_count == 1 || channel_count == 2);
             ASSERT(buffer_size >= OpusDecodeObject::GetWorkBufferSize(channel_count));
 
             auto& decoder_object = OpusDecodeObject::Initialize(buffer, buffer);

src/audio_core/adsp/apps/opus/opus_multistream_decode_object.cpp

@@ -1,3 +1,6 @@
+// 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-2.0-or-later
 
@@ -7,13 +10,10 @@
 namespace AudioCore::ADSP::OpusDecoder {
 
 namespace {
-bool IsValidChannelCount(u32 channel_count) {
-    return channel_count == 1 || channel_count == 2;
-}
-
 bool IsValidStreamCounts(u32 total_stream_count, u32 stereo_stream_count) {
-    return total_stream_count > 0 && static_cast<s32>(stereo_stream_count) >= 0 &&
-           stereo_stream_count <= total_stream_count && IsValidChannelCount(total_stream_count);
+    return total_stream_count > 0 && s32(stereo_stream_count) >= 0
+        && stereo_stream_count <= total_stream_count
+        && (total_stream_count == 1 || total_stream_count == 2);
 }
 } // namespace
 

src/audio_core/in/audio_in.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 

src/audio_core/in/audio_in_system.cpp

@@ -14,14 +14,16 @@
 #include "core/core_timing.h"
 #include "core/hle/kernel/k_event.h"
 
+namespace AudioCore::AudioIn {
+
 // See texture_cache/util.h
 template<typename T, size_t N>
 #if BOOST_VERSION >= 108100 || __GNUC__ > 12
-[[nodiscard]] boost::container::static_vector<T, N> FixStaticVectorADL(const boost::container::static_vector<T, N>& v) {
+[[nodiscard]] static inline boost::container::static_vector<T, N> FixStaticVectorADL(const boost::container::static_vector<T, N>& v) {
     return v;
 }
 #else
-[[nodiscard]] std::vector<T> FixStaticVectorADL(const boost::container::static_vector<T, N>& v) {
+[[nodiscard]] static inline std::vector<T> FixStaticVectorADL(const boost::container::static_vector<T, N>& v) {
     std::vector<T> u;
     for (auto const& e : v)
         u.push_back(e);
@@ -29,8 +31,6 @@ template<typename T, size_t N>
 }
 #endif
 
-namespace AudioCore::AudioIn {
-
 System::System(Core::System& system_, Kernel::KEvent* event_, const size_t session_id_)
     : system{system_}, buffer_event{event_},
       session_id{session_id_}, session{std::make_unique<DeviceSession>(system_)} {}

src/audio_core/out/audio_out_system.cpp

@@ -14,14 +14,15 @@
 #include "core/core_timing.h"
 #include "core/hle/kernel/k_event.h"
 
+namespace AudioCore::AudioOut {
 // See texture_cache/util.h
 template<typename T, size_t N>
 #if BOOST_VERSION >= 108100 || __GNUC__ > 12
-[[nodiscard]] boost::container::static_vector<T, N> FixStaticVectorADL(const boost::container::static_vector<T, N>& v) {
+[[nodiscard]] static inline boost::container::static_vector<T, N> FixStaticVectorADL(const boost::container::static_vector<T, N>& v) {
     return v;
 }
 #else
-[[nodiscard]] std::vector<T> FixStaticVectorADL(const boost::container::static_vector<T, N>& v) {
+[[nodiscard]] static inline std::vector<T> FixStaticVectorADL(const boost::container::static_vector<T, N>& v) {
     std::vector<T> u;
     for (auto const& e : v)
         u.push_back(e);
@@ -29,8 +30,6 @@ template<typename T, size_t N>
 }
 #endif
 
-namespace AudioCore::AudioOut {
-
 System::System(Core::System& system_, Kernel::KEvent* event_, size_t session_id_)
     : system{system_}, buffer_event{event_},
       session_id{session_id_}, session{std::make_unique<DeviceSession>(system_)} {}

src/audio_core/renderer/command/effect/capture.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
@@ -16,7 +16,7 @@ namespace AudioCore::Renderer {
  * @param memory   - Core memory for writing.
  * @param aux_info - Memory address pointing to the AuxInfo to reset.
  */
-static void ResetAuxBufferDsp(Core::Memory::Memory& memory, const CpuAddr aux_info) {
+static void CaptureResetAuxBufferDsp(Core::Memory::Memory& memory, const CpuAddr aux_info) {
     if (aux_info == 0) {
         LOG_ERROR(Service_Audio, "Aux info is 0!");
         return;
@@ -134,7 +134,7 @@ void CaptureCommand::Process(const AudioRenderer::CommandListProcessor& processo
         WriteAuxBufferDsp(*processor.memory, send_buffer_info, send_buffer, count_max, input_buffer,
                           processor.sample_count, write_offset, update_count);
     } else {
-        ResetAuxBufferDsp(*processor.memory, send_buffer_info);
+        CaptureResetAuxBufferDsp(*processor.memory, send_buffer_info);
     }
 }
 

src/common/cityhash.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: 2011 Google, Inc.
 // SPDX-FileContributor: Geoff Pike
 // SPDX-FileContributor: Jyrki Alakuijala
@@ -27,8 +30,6 @@
 #define WORDS_BIGENDIAN 1
 #endif
 
-using namespace std;
-
 namespace Common {
 
 static u64 unaligned_load64(const char* p) {
@@ -135,18 +136,18 @@ static u64 HashLen17to32(const char* s, size_t len) {
 
 // Return a 16-byte hash for 48 bytes.  Quick and dirty.
 // Callers do best to use "random-looking" values for a and b.
-static pair<u64, u64> WeakHashLen32WithSeeds(u64 w, u64 x, u64 y, u64 z, u64 a, u64 b) {
+static std::pair<u64, u64> WeakHashLen32WithSeeds(u64 w, u64 x, u64 y, u64 z, u64 a, u64 b) {
     a += w;
     b = Rotate(b + a + z, 21);
     u64 c = a;
     a += x;
     a += y;
     b += Rotate(a, 44);
-    return make_pair(a + z, b + c);
+    return std::make_pair(a + z, b + c);
 }
 
 // Return a 16-byte hash for s[0] ... s[31], a, and b.  Quick and dirty.
-static pair<u64, u64> WeakHashLen32WithSeeds(const char* s, u64 a, u64 b) {
+static std::pair<u64, u64> WeakHashLen32WithSeeds(const char* s, u64 a, u64 b) {
     return WeakHashLen32WithSeeds(Fetch64(s), Fetch64(s + 8), Fetch64(s + 16), Fetch64(s + 24), a,
                                   b);
 }
@@ -189,8 +190,8 @@ u64 CityHash64(const char* s, size_t len) {
     u64 x = Fetch64(s + len - 40);
     u64 y = Fetch64(s + len - 16) + Fetch64(s + len - 56);
     u64 z = HashLen16(Fetch64(s + len - 48) + len, Fetch64(s + len - 24));
-    pair<u64, u64> v = WeakHashLen32WithSeeds(s + len - 64, len, z);
-    pair<u64, u64> w = WeakHashLen32WithSeeds(s + len - 32, y + k1, x);
+    std::pair<u64, u64> v = WeakHashLen32WithSeeds(s + len - 64, len, z);
+    std::pair<u64, u64> w = WeakHashLen32WithSeeds(s + len - 32, y + k1, x);
     x = x * k1 + Fetch64(s);
 
     // Decrease len to the nearest multiple of 64, and operate on 64-byte chunks.
@@ -258,7 +259,7 @@ u128 CityHash128WithSeed(const char* s, size_t len, u128 seed) {
 
     // We expect len >= 128 to be the common case.  Keep 56 bytes of state:
     // v, w, x, y, and z.
-    pair<u64, u64> v, w;
+    std::pair<u64, u64> v, w;
     u64 x = seed[0];
     u64 y = seed[1];
     u64 z = len * k1;

src/common/x64/cpu_detect.cpp

@@ -77,7 +77,7 @@ CPUCaps::Manufacturer CPUCaps::ParseManufacturer(std::string_view brand_string)
 }
 
 // Detects the various CPU features
-static CPUCaps Detect() {
+static CPUCaps DetectCPUCapabilities() {
     CPUCaps caps = {};
 
     // Assumes the CPU supports the CPUID instruction. Those that don't would likely not support
@@ -208,7 +208,7 @@ static CPUCaps Detect() {
 }
 
 const CPUCaps& GetCPUCaps() {
-    static CPUCaps caps = Detect();
+    static CPUCaps caps = DetectCPUCapabilities();
     return caps;
 }
 

src/core/arm/dynarmic/arm_dynarmic.h

@@ -1,23 +1,24 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// 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-2.0-or-later
 
-#include <dynarmic/interface/halt_reason.h>
+#pragma once
 
+#include <dynarmic/interface/halt_reason.h>
 #include "core/arm/arm_interface.h"
 
 namespace Core {
 
-constexpr Dynarmic::HaltReason StepThread = Dynarmic::HaltReason::Step;
-constexpr Dynarmic::HaltReason DataAbort = Dynarmic::HaltReason::MemoryAbort;
-constexpr Dynarmic::HaltReason BreakLoop = Dynarmic::HaltReason::UserDefined2;
-constexpr Dynarmic::HaltReason SupervisorCall = Dynarmic::HaltReason::UserDefined3;
-constexpr Dynarmic::HaltReason InstructionBreakpoint = Dynarmic::HaltReason::UserDefined4;
-constexpr Dynarmic::HaltReason PrefetchAbort = Dynarmic::HaltReason::UserDefined6;
+inline constexpr Dynarmic::HaltReason StepThread = Dynarmic::HaltReason::Step;
+inline constexpr Dynarmic::HaltReason DataAbort = Dynarmic::HaltReason::MemoryAbort;
+inline constexpr Dynarmic::HaltReason BreakLoop = Dynarmic::HaltReason::UserDefined2;
+inline constexpr Dynarmic::HaltReason SupervisorCall = Dynarmic::HaltReason::UserDefined3;
+inline constexpr Dynarmic::HaltReason InstructionBreakpoint = Dynarmic::HaltReason::UserDefined4;
+inline constexpr Dynarmic::HaltReason PrefetchAbort = Dynarmic::HaltReason::UserDefined6;
 
-constexpr HaltReason TranslateHaltReason(Dynarmic::HaltReason hr) {
+[[nodiscard]] inline constexpr HaltReason TranslateHaltReason(Dynarmic::HaltReason hr) {
     static_assert(u64(HaltReason::StepThread) == u64(StepThread));
     static_assert(u64(HaltReason::DataAbort) == u64(DataAbort));
     static_assert(u64(HaltReason::BreakLoop) == u64(BreakLoop));

src/core/core_timing.cpp

@@ -25,6 +25,7 @@ namespace Core::Timing {
 
 constexpr s64 MAX_SLICE_LENGTH = 10000;
 
+#undef CreateEvent
 std::shared_ptr<EventType> CreateEvent(std::string name, TimedCallback&& callback) {
     return std::make_shared<EventType>(std::move(callback), std::move(name));
 }

src/core/file_sys/fs_save_data_types.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
@@ -185,13 +185,13 @@ static_assert(sizeof(SaveDataFilter) == 0x48, "SaveDataFilter has invalid size."
 static_assert(std::is_trivially_copyable_v<SaveDataFilter>,
               "Data type must be trivially copyable.");
 
-struct HashSalt {
+struct SaveDataHashSalt {
     static constexpr size_t Size = 32;
 
     std::array<u8, Size> value;
 };
-static_assert(std::is_trivially_copyable_v<HashSalt>, "Data type must be trivially copyable.");
-static_assert(sizeof(HashSalt) == HashSalt::Size);
+static_assert(std::is_trivially_copyable_v<SaveDataHashSalt>, "Data type must be trivially copyable.");
+static_assert(sizeof(SaveDataHashSalt) == SaveDataHashSalt::Size);
 
 struct SaveDataCreationInfo2 {
 
@@ -210,7 +210,7 @@ struct SaveDataCreationInfo2 {
     u8 reserved1;
     bool is_hash_salt_enabled;
     u8 reserved2;
-    HashSalt hash_salt;
+    SaveDataHashSalt hash_salt;
     SaveDataMetaType meta_type;
     u8 reserved3;
     s32 meta_size;

src/core/file_sys/fsmitm_romfsbuild.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -11,7 +14,7 @@
 #include "core/file_sys/vfs/vfs.h"
 #include "core/file_sys/vfs/vfs_vector.h"
 
-namespace FileSys {
+namespace FileSys::RomFSBuilder {
 
 constexpr u64 FS_MAX_PATH = 0x301;
 

src/core/file_sys/fsmitm_romfsbuild.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -9,7 +12,7 @@
 #include "common/common_types.h"
 #include "core/file_sys/vfs/vfs.h"
 
-namespace FileSys {
+namespace FileSys::RomFSBuilder {
 
 struct RomFSBuildDirectoryContext;
 struct RomFSBuildFileContext;

src/core/file_sys/romfs.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
@@ -38,7 +38,7 @@ struct RomFSHeader {
 };
 static_assert(sizeof(RomFSHeader) == 0x50, "RomFSHeader has incorrect size.");
 
-struct DirectoryEntry {
+struct RomFSDirectoryEntry {
     u32_le parent;
     u32_le sibling;
     u32_le child_dir;
@@ -46,9 +46,9 @@ struct DirectoryEntry {
     u32_le hash;
     u32_le name_length;
 };
-static_assert(sizeof(DirectoryEntry) == 0x18, "DirectoryEntry has incorrect size.");
+static_assert(sizeof(RomFSDirectoryEntry) == 0x18, "RomFSDirectoryEntry has incorrect size.");
 
-struct FileEntry {
+struct RomFSFileEntry {
     u32_le parent;
     u32_le sibling;
     u64_le offset;
@@ -56,7 +56,7 @@ struct FileEntry {
     u32_le hash;
     u32_le name_length;
 };
-static_assert(sizeof(FileEntry) == 0x20, "FileEntry has incorrect size.");
+static_assert(sizeof(RomFSFileEntry) == 0x20, "RomFSFileEntry has incorrect size.");
 
 struct RomFSTraversalContext {
     RomFSHeader header;
@@ -84,14 +84,14 @@ std::pair<EntryType, std::string> GetEntry(const RomFSTraversalContext& ctx, siz
     return {entry, std::move(name)};
 }
 
-std::pair<DirectoryEntry, std::string> GetDirectoryEntry(const RomFSTraversalContext& ctx,
+std::pair<RomFSDirectoryEntry, std::string> GetDirectoryEntry(const RomFSTraversalContext& ctx,
                                                          size_t directory_offset) {
-    return GetEntry<DirectoryEntry, &RomFSTraversalContext::directory_meta>(ctx, directory_offset);
+    return GetEntry<RomFSDirectoryEntry, &RomFSTraversalContext::directory_meta>(ctx, directory_offset);
 }
 
-std::pair<FileEntry, std::string> GetFileEntry(const RomFSTraversalContext& ctx,
+std::pair<RomFSFileEntry, std::string> GetFileEntry(const RomFSTraversalContext& ctx,
                                                size_t file_offset) {
-    return GetEntry<FileEntry, &RomFSTraversalContext::file_meta>(ctx, file_offset);
+    return GetEntry<RomFSFileEntry, &RomFSTraversalContext::file_meta>(ctx, file_offset);
 }
 
 void ProcessFile(const RomFSTraversalContext& ctx, u32 this_file_offset,
@@ -163,7 +163,7 @@ VirtualFile CreateRomFS(VirtualDir dir, VirtualDir ext) {
     if (dir == nullptr)
         return nullptr;
 
-    RomFSBuildContext ctx{dir, ext};
+    RomFSBuilder::RomFSBuildContext ctx{dir, ext};
     return ConcatenatedVfsFile::MakeConcatenatedFile(0, dir->GetName(), ctx.Build());
 }
 

src/core/file_sys/vfs/vfs.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
@@ -10,6 +10,12 @@
 #include "common/fs/path_util.h"
 #include "core/file_sys/vfs/vfs.h"
 
+#undef CreateFile
+#undef DeleteFile
+#undef CreateDirectory
+#undef CopyFile
+#undef MoveFile
+
 namespace FileSys {
 
 VfsFilesystem::VfsFilesystem(VirtualDir root_) : root(std::move(root_)) {}

src/core/file_sys/vfs/vfs_vector.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
@@ -99,6 +99,10 @@ private:
     std::string name;
 };
 
+#undef CreateFile
+#undef DeleteFile
+#undef CreateDirectory
+
 // An implementation of VfsDirectory that maintains two vectors for subdirectories and files.
 // Vector data is supplied upon construction.
 class VectorVfsDirectory : public VfsDirectory {

src/core/hle/kernel/svc.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// 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-2.0-or-late
@@ -13,6 +13,10 @@
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/svc.h"
 
+#undef OutputDebugString
+#undef GetObject
+#undef CreateProcess
+
 namespace Kernel::Svc {
 
 static uint32_t GetArg32(std::span<uint64_t, 8> args, int n) {

src/core/hle/kernel/svc/svc_memory.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
@@ -11,7 +11,11 @@
 namespace Kernel::Svc {
 namespace {
 
-constexpr bool IsValidSetMemoryPermission(MemoryPermission perm) {
+[[nodiscard]] inline constexpr bool IsValidSetAddressRange(u64 address, u64 size) {
+    return address + size > address;
+}
+
+[[nodiscard]] inline constexpr bool IsValidSetMemoryPermission(MemoryPermission perm) {
     switch (perm) {
     case MemoryPermission::None:
     case MemoryPermission::Read:
@@ -22,13 +26,6 @@ constexpr bool IsValidSetMemoryPermission(MemoryPermission perm) {
     }
 }
 
-// Checks if address + size is greater than the given address
-// This can return false if the size causes an overflow of a 64-bit type
-// or if the given size is zero.
-constexpr bool IsValidAddressRange(u64 address, u64 size) {
-    return address + size > address;
-}
-
 // Helper function that performs the common sanity checks for svcMapMemory
 // and svcUnmapMemory. This is doable, as both functions perform their sanitizing
 // in the same order.
@@ -54,14 +51,17 @@ Result MapUnmapMemorySanityChecks(const KProcessPageTable& manager, u64 dst_addr
         R_THROW(ResultInvalidSize);
     }
 
-    if (!IsValidAddressRange(dst_addr, size)) {
+    // Checks if address + size is greater than the given address
+    // This can return false if the size causes an overflow of a 64-bit type
+    // or if the given size is zero.
+    if (!IsValidSetAddressRange(dst_addr, size)) {
         LOG_ERROR(Kernel_SVC,
                   "Destination is not a valid address range, addr=0x{:016X}, size=0x{:016X}",
                   dst_addr, size);
         R_THROW(ResultInvalidCurrentMemory);
     }
 
-    if (!IsValidAddressRange(src_addr, size)) {
+    if (!IsValidSetAddressRange(src_addr, size)) {
         LOG_ERROR(Kernel_SVC, "Source is not a valid address range, addr=0x{:016X}, size=0x{:016X}",
                   src_addr, size);
         R_THROW(ResultInvalidCurrentMemory);

src/core/hle/kernel/svc/svc_process_memory.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
@@ -11,11 +11,11 @@
 namespace Kernel::Svc {
 namespace {
 
-constexpr bool IsValidAddressRange(u64 address, u64 size) {
+[[nodiscard]] inline constexpr bool IsValidAddressRange(u64 address, u64 size) {
     return address + size > address;
 }
 
-constexpr bool IsValidProcessMemoryPermission(Svc::MemoryPermission perm) {
+[[nodiscard]] inline constexpr bool IsValidProcessMemoryPermission(Svc::MemoryPermission perm) {
     switch (perm) {
     case Svc::MemoryPermission::None:
     case Svc::MemoryPermission::Read:

src/core/hle/service/audio/audio_in.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -6,13 +9,12 @@
 #include "core/hle/service/ipc_helpers.h"
 
 namespace Service::Audio {
-using namespace AudioCore::AudioIn;
 
-IAudioIn::IAudioIn(Core::System& system_, Manager& manager, size_t session_id,
-                   const std::string& device_name, const AudioInParameter& in_params,
+IAudioIn::IAudioIn(Core::System& system_, AudioCore::AudioIn::Manager& manager, size_t session_id,
+                   const std::string& device_name, const AudioCore::AudioIn::AudioInParameter& in_params,
                    Kernel::KProcess* handle, u64 applet_resource_user_id)
     : ServiceFramework{system_, "IAudioIn"}, process{handle}, service_context{system_, "IAudioIn"},
-      event{service_context.CreateEvent("AudioInEvent")}, impl{std::make_shared<In>(system_,
+      event{service_context.CreateEvent("AudioInEvent")}, impl{std::make_shared<AudioCore::AudioIn::In>(system_,
                                                                                     manager, event,
                                                                                     session_id)} {
     // clang-format off
@@ -68,12 +70,12 @@ Result IAudioIn::Stop() {
     R_RETURN(impl->StopSystem());
 }
 
-Result IAudioIn::AppendAudioInBuffer(InArray<AudioInBuffer, BufferAttr_HipcMapAlias> buffer,
+Result IAudioIn::AppendAudioInBuffer(InArray<AudioCore::AudioIn::AudioInBuffer, BufferAttr_HipcMapAlias> buffer,
                                      u64 buffer_client_ptr) {
     R_RETURN(this->AppendAudioInBufferAuto(buffer, buffer_client_ptr));
 }
 
-Result IAudioIn::AppendAudioInBufferAuto(InArray<AudioInBuffer, BufferAttr_HipcAutoSelect> buffer,
+Result IAudioIn::AppendAudioInBufferAuto(InArray<AudioCore::AudioIn::AudioInBuffer, BufferAttr_HipcAutoSelect> buffer,
                                          u64 buffer_client_ptr) {
     if (buffer.empty()) {
         LOG_ERROR(Service_Audio, "Input buffer is too small for an AudioInBuffer!");

src/core/hle/service/audio/audio_in_manager.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -7,7 +10,6 @@
 #include "core/hle/service/cmif_serialization.h"
 
 namespace Service::Audio {
-using namespace AudioCore::AudioIn;
 
 IAudioInManager::IAudioInManager(Core::System& system_)
     : ServiceFramework{system_, "audin:u"}, impl{std::make_unique<AudioCore::AudioIn::Manager>(
@@ -34,11 +36,11 @@ Result IAudioInManager::ListAudioIns(
     R_RETURN(this->ListAudioInsAutoFiltered(out_audio_ins, out_count));
 }
 
-Result IAudioInManager::OpenAudioIn(Out<AudioInParameterInternal> out_parameter_internal,
+Result IAudioInManager::OpenAudioIn(Out<AudioCore::AudioIn::AudioInParameterInternal> out_parameter_internal,
                                     Out<SharedPointer<IAudioIn>> out_audio_in,
                                     OutArray<AudioDeviceName, BufferAttr_HipcMapAlias> out_name,
                                     InArray<AudioDeviceName, BufferAttr_HipcMapAlias> name,
-                                    AudioInParameter parameter,
+                                    AudioCore::AudioIn::AudioInParameter parameter,
                                     InCopyHandle<Kernel::KProcess> process_handle,
                                     ClientAppletResourceUserId aruid) {
     LOG_DEBUG(Service_Audio, "called");
@@ -53,9 +55,9 @@ Result IAudioInManager::ListAudioInsAuto(
 }
 
 Result IAudioInManager::OpenAudioInAuto(
-    Out<AudioInParameterInternal> out_parameter_internal, Out<SharedPointer<IAudioIn>> out_audio_in,
+    Out<AudioCore::AudioIn::AudioInParameterInternal> out_parameter_internal, Out<SharedPointer<IAudioIn>> out_audio_in,
     OutArray<AudioDeviceName, BufferAttr_HipcAutoSelect> out_name,
-    InArray<AudioDeviceName, BufferAttr_HipcAutoSelect> name, AudioInParameter parameter,
+    InArray<AudioDeviceName, BufferAttr_HipcAutoSelect> name, AudioCore::AudioIn::AudioInParameter parameter,
     InCopyHandle<Kernel::KProcess> process_handle, ClientAppletResourceUserId aruid) {
     LOG_DEBUG(Service_Audio, "called");
     R_RETURN(this->OpenAudioInProtocolSpecified(out_parameter_internal, out_audio_in, out_name,
@@ -70,10 +72,10 @@ Result IAudioInManager::ListAudioInsAutoFiltered(
 }
 
 Result IAudioInManager::OpenAudioInProtocolSpecified(
-    Out<AudioInParameterInternal> out_parameter_internal, Out<SharedPointer<IAudioIn>> out_audio_in,
+    Out<AudioCore::AudioIn::AudioInParameterInternal> out_parameter_internal, Out<SharedPointer<IAudioIn>> out_audio_in,
     OutArray<AudioDeviceName, BufferAttr_HipcAutoSelect> out_name,
     InArray<AudioDeviceName, BufferAttr_HipcAutoSelect> name, Protocol protocol,
-    AudioInParameter parameter, InCopyHandle<Kernel::KProcess> process_handle,
+    AudioCore::AudioIn::AudioInParameter parameter, InCopyHandle<Kernel::KProcess> process_handle,
     ClientAppletResourceUserId aruid) {
     LOG_DEBUG(Service_Audio, "called");
 
@@ -104,7 +106,7 @@ Result IAudioInManager::OpenAudioInProtocolSpecified(
 
     auto& out_system = impl->sessions[new_session_id]->GetSystem();
     *out_parameter_internal =
-        AudioInParameterInternal{.sample_rate = out_system.GetSampleRate(),
+        AudioCore::AudioIn::AudioInParameterInternal{.sample_rate = out_system.GetSampleRate(),
                                  .channel_count = out_system.GetChannelCount(),
                                  .sample_format = static_cast<u32>(out_system.GetSampleFormat()),
                                  .state = static_cast<u32>(out_system.GetState())};

src/core/hle/service/audio/audio_out.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -10,10 +13,9 @@
 #include "core/hle/service/service.h"
 
 namespace Service::Audio {
-using namespace AudioCore::AudioOut;
 
-IAudioOut::IAudioOut(Core::System& system_, Manager& manager, size_t session_id,
-                     const std::string& device_name, const AudioOutParameter& in_params,
+IAudioOut::IAudioOut(Core::System& system_, AudioCore::AudioOut::Manager& manager, size_t session_id,
+                     const std::string& device_name, const AudioCore::AudioOut::AudioOutParameter& in_params,
                      Kernel::KProcess* handle, u64 applet_resource_user_id)
     : ServiceFramework{system_, "IAudioOut"}, service_context{system_, "IAudioOut"},
       event{service_context.CreateEvent("AudioOutEvent")}, process{handle},
@@ -65,12 +67,12 @@ Result IAudioOut::Stop() {
 }
 
 Result IAudioOut::AppendAudioOutBuffer(
-    InArray<AudioOutBuffer, BufferAttr_HipcMapAlias> audio_out_buffer, u64 buffer_client_ptr) {
+    InArray<AudioCore::AudioOut::AudioOutBuffer, BufferAttr_HipcMapAlias> audio_out_buffer, u64 buffer_client_ptr) {
     R_RETURN(this->AppendAudioOutBufferAuto(audio_out_buffer, buffer_client_ptr));
 }
 
 Result IAudioOut::AppendAudioOutBufferAuto(
-    InArray<AudioOutBuffer, BufferAttr_HipcAutoSelect> audio_out_buffer, u64 buffer_client_ptr) {
+    InArray<AudioCore::AudioOut::AudioOutBuffer, BufferAttr_HipcAutoSelect> audio_out_buffer, u64 buffer_client_ptr) {
     if (audio_out_buffer.empty()) {
         LOG_ERROR(Service_Audio, "Input buffer is too small for an AudioOutBuffer!");
         R_THROW(Audio::ResultInsufficientBuffer);

src/core/hle/service/audio/audio_out_manager.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
@@ -11,10 +11,9 @@
 #include "core/memory.h"
 
 namespace Service::Audio {
-using namespace AudioCore::AudioOut;
 
 IAudioOutManager::IAudioOutManager(Core::System& system_)
-    : ServiceFramework{system_, "audout:u"}, impl{std::make_unique<Manager>(system_)} {
+    : ServiceFramework{system_, "audout:u"}, impl{std::make_unique<AudioCore::AudioOut::Manager>(system_)} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, D<&IAudioOutManager::ListAudioOuts>, "ListAudioOuts"},
@@ -34,11 +33,11 @@ Result IAudioOutManager::ListAudioOuts(
     R_RETURN(this->ListAudioOutsAuto(out_audio_outs, out_count));
 }
 
-Result IAudioOutManager::OpenAudioOut(Out<AudioOutParameterInternal> out_parameter_internal,
+Result IAudioOutManager::OpenAudioOut(Out<AudioCore::AudioOut::AudioOutParameterInternal> out_parameter_internal,
                                       Out<SharedPointer<IAudioOut>> out_audio_out,
                                       OutArray<AudioDeviceName, BufferAttr_HipcMapAlias> out_name,
                                       InArray<AudioDeviceName, BufferAttr_HipcMapAlias> name,
-                                      AudioOutParameter parameter,
+                                      AudioCore::AudioOut::AudioOutParameter parameter,
                                       InCopyHandle<Kernel::KProcess> process_handle,
                                       ClientAppletResourceUserId aruid) {
     R_RETURN(this->OpenAudioOutAuto(out_parameter_internal, out_audio_out, out_name, name,
@@ -60,10 +59,10 @@ Result IAudioOutManager::ListAudioOutsAuto(
 }
 
 Result IAudioOutManager::OpenAudioOutAuto(
-    Out<AudioOutParameterInternal> out_parameter_internal,
+    Out<AudioCore::AudioOut::AudioOutParameterInternal> out_parameter_internal,
     Out<SharedPointer<IAudioOut>> out_audio_out,
     OutArray<AudioDeviceName, BufferAttr_HipcAutoSelect> out_name,
-    InArray<AudioDeviceName, BufferAttr_HipcAutoSelect> name, AudioOutParameter parameter,
+    InArray<AudioDeviceName, BufferAttr_HipcAutoSelect> name, AudioCore::AudioOut::AudioOutParameter parameter,
     InCopyHandle<Kernel::KProcess> process_handle, ClientAppletResourceUserId aruid) {
     if (!process_handle) {
         LOG_ERROR(Service_Audio, "Failed to get process handle");
@@ -93,7 +92,7 @@ Result IAudioOutManager::OpenAudioOutAuto(
 
     auto& out_system = impl->sessions[new_session_id]->GetSystem();
     *out_parameter_internal =
-        AudioOutParameterInternal{.sample_rate = out_system.GetSampleRate(),
+        AudioCore::AudioOut::AudioOutParameterInternal{.sample_rate = out_system.GetSampleRate(),
                                   .channel_count = out_system.GetChannelCount(),
                                   .sample_format = static_cast<u32>(out_system.GetSampleFormat()),
                                   .state = static_cast<u32>(out_system.GetState())};

src/core/hle/service/audio/audio_renderer.cpp

@@ -1,24 +1,23 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include "audio_core/renderer/audio_renderer.h"
 #include "core/hle/service/audio/audio_renderer.h"
 #include "core/hle/service/cmif_serialization.h"
 
 namespace Service::Audio {
-using namespace AudioCore::Renderer;
 
-IAudioRenderer::IAudioRenderer(Core::System& system_, Manager& manager_,
+IAudioRenderer::IAudioRenderer(Core::System& system_, AudioCore::Renderer::Manager& manager_,
                                AudioCore::AudioRendererParameterInternal& params,
                                Kernel::KTransferMemory* transfer_memory, u64 transfer_memory_size,
                                Kernel::KProcess* process_handle_, u64 applet_resource_user_id,
                                s32 session_id)
     : ServiceFramework{system_, "IAudioRenderer"}, service_context{system_, "IAudioRenderer"},
       rendered_event{service_context.CreateEvent("IAudioRendererEvent")}, manager{manager_},
-      impl{std::make_unique<Renderer>(system_, manager, rendered_event)}, process_handle{
-                                                                              process_handle_} {
+      impl{std::make_unique<AudioCore::Renderer::Renderer>(system_, manager, rendered_event)}, process_handle{process_handle_} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, D<&IAudioRenderer::GetSampleRate>, "GetSampleRate"},

src/core/hle/service/audio/audio_renderer_manager.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -15,7 +18,7 @@ namespace Service::Audio {
 using namespace AudioCore::Renderer;
 
 IAudioRendererManager::IAudioRendererManager(Core::System& system_)
-    : ServiceFramework{system_, "audren:u"}, impl{std::make_unique<Manager>(system_)} {
+    : ServiceFramework{system_, "audren:u"}, impl{std::make_unique<Service::Audio::Manager>(system_)} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, D<&IAudioRendererManager::OpenAudioRenderer>, "OpenAudioRenderer"},

src/core/hle/service/bcat/news/builtin_news.cpp

@@ -17,6 +17,7 @@
 
 #ifdef CPPHTTPLIB_OPENSSL_SUPPORT
 #include <httplib.h>
+#undef INVALID_SOCKET
 #endif
 
 #include <chrono>

src/core/hle/service/bcat/news/news_data_service.cpp

@@ -14,16 +14,13 @@
 #include <cstring>
 
 namespace Service::News {
-namespace {
 
-std::string_view ToStringView(std::span<const char> buf) {
+[[nodiscard]] inline std::string_view ToStringViewNDS(std::span<const char> buf) {
     const std::string_view sv{buf.data(), buf.size()};
     const auto nul = sv.find('\0');
     return nul == std::string_view::npos ? sv : sv.substr(0, nul);
 }
 
-} // namespace
-
 INewsDataService::INewsDataService(Core::System& system_)
     : ServiceFramework{system_, "INewsDataService"} {
     static const FunctionInfo functions[] = {
@@ -55,7 +52,7 @@ bool INewsDataService::TryOpen(std::string_view key, std::string_view user) {
 
     const auto list = NewsStorage::Instance().ListAll();
     if (!list.empty()) {
-        if (auto found = NewsStorage::Instance().FindByNewsId(ToStringView(list.front().news_id))) {
+        if (auto found = NewsStorage::Instance().FindByNewsId(ToStringViewNDS(list.front().news_id))) {
             opened_payload = std::move(found->payload);
             return true;
         }
@@ -67,7 +64,7 @@ bool INewsDataService::TryOpen(std::string_view key, std::string_view user) {
 Result INewsDataService::Open(InBuffer<BufferAttr_HipcMapAlias> name) {
     EnsureBuiltinNewsLoaded();
 
-    const auto key = ToStringView({reinterpret_cast<const char*>(name.data()), name.size()});
+    const auto key = ToStringViewNDS({reinterpret_cast<const char*>(name.data()), name.size()});
 
     if (TryOpen(key, {})) {
         R_SUCCEED();
@@ -79,8 +76,8 @@ Result INewsDataService::Open(InBuffer<BufferAttr_HipcMapAlias> name) {
 Result INewsDataService::OpenWithNewsRecordV1(NewsRecordV1 record) {
     EnsureBuiltinNewsLoaded();
 
-    const auto key = ToStringView(record.news_id);
-    const auto user = ToStringView(record.user_id);
+    const auto key = ToStringViewNDS(record.news_id);
+    const auto user = ToStringViewNDS(record.user_id);
 
     if (TryOpen(key, user)) {
         R_SUCCEED();
@@ -92,8 +89,8 @@ Result INewsDataService::OpenWithNewsRecordV1(NewsRecordV1 record) {
 Result INewsDataService::OpenWithNewsRecord(NewsRecord record) {
     EnsureBuiltinNewsLoaded();
 
-    const auto key = ToStringView(record.news_id);
-    const auto user = ToStringView(record.user_id);
+    const auto key = ToStringViewNDS(record.news_id);
+    const auto user = ToStringViewNDS(record.user_id);
 
     if (TryOpen(key, user)) {
         R_SUCCEED();

src/core/hle/service/bcat/news/news_database_service.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
@@ -15,13 +15,13 @@
 namespace Service::News {
 namespace {
 
-std::string_view ToStringView(std::span<const u8> buf) {
+[[nodiscard]] inline std::string_view ToStringView(std::span<const u8> buf) {
     if (buf.empty()) return {};
     auto data = reinterpret_cast<const char*>(buf.data());
     return {data, strnlen(data, buf.size())};
 }
 
-std::string_view ToStringView(std::span<const char> buf) {
+[[nodiscard]] inline std::string_view ToStringView(std::span<const char> buf) {
     if (buf.empty()) return {};
     return {buf.data(), strnlen(buf.data(), buf.size())};
 }

src/core/hle/service/bcat/news/overwrite_event_holder.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -6,6 +9,8 @@
 
 namespace Service::News {
 
+#undef CreateEvent
+
 IOverwriteEventHolder::IOverwriteEventHolder(Core::System& system_)
     : ServiceFramework{system_, "IOverwriteEventHolder"}, service_context{system_,
                                                                           "IOverwriteEventHolder"} {

src/core/hle/service/caps/caps_manager.cpp

@@ -18,6 +18,8 @@
 #include "core/hle/service/service.h"
 #include "core/hle/service/sm/sm.h"
 
+#undef GetCurrentTime
+
 namespace Service::Capture {
 
 AlbumManager::AlbumManager(Core::System& system_) : system{system_} {}

src/core/hle/service/fatal/fatal.cpp

@@ -19,6 +19,8 @@
 #include "core/hle/service/server_manager.h"
 #include "core/reporter.h"
 
+#undef far
+
 namespace Service::Fatal {
 
 Module::Interface::Interface(std::shared_ptr<Module> module_, Core::System& system_,

src/core/hle/service/filesystem/filesystem.cpp

@@ -32,6 +32,10 @@
 #include "core/hle/service/server_manager.h"
 #include "core/loader/loader.h"
 
+#undef CreateFile
+#undef DeleteFile
+#undef CreateDirectory
+
 namespace Service::FileSystem {
 
 static FileSys::VirtualDir GetDirectoryRelativeWrapped(FileSys::VirtualDir base,

src/core/hle/service/hle_ipc.cpp

@@ -27,6 +27,8 @@
 #include "core/hle/service/ipc_helpers.h"
 #include "core/memory.h"
 
+#undef SendMessage
+
 namespace Service {
 
 SessionRequestHandler::SessionRequestHandler(Kernel::KernelCore& kernel_, const char* service_name_)

src/core/hle/service/nifm/nifm.cpp

@@ -212,8 +212,9 @@ struct NifmNetworkProfileData {
     NifmWirelessSettingData wireless_setting_data{};
     IpSettingData ip_setting_data{};
 };
+static_assert(sizeof(NifmNetworkProfileData) == 0x18E,
+              "NifmNetworkProfileData has incorrect size.");
 #pragma pack(pop)
-static_assert(sizeof(NifmNetworkProfileData) == 0x18E, "NifmNetworkProfileData has incorrect size.");
 
 struct PendingProfile {
     std::array<char, 0x21> ssid{};

src/core/hle/service/nvnflinger/hos_binder_driver.h

@@ -1,6 +1,11 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#pragma once
+
 #include "core/hle/service/cmif_types.h"
 #include "core/hle/service/service.h"
 

src/core/hle/service/olsc/daemon_controller.h

@@ -4,6 +4,8 @@
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#pragma once
+
 #include <ankerl/unordered_dense.h>
 
 #include "common/uuid.h"

src/core/hle/service/olsc/native_handle_holder.h

@@ -4,6 +4,8 @@
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#pragma once
+
 #include "core/hle/service/cmif_types.h"
 #include "core/hle/service/service.h"
 

src/core/hle/service/olsc/olsc_service_for_application.h

@@ -1,6 +1,11 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#pragma once
+
 #include "core/hle/service/cmif_types.h"
 #include "core/hle/service/ns/ns_types.h"
 #include "core/hle/service/service.h"

src/core/hle/service/olsc/olsc_service_for_system_service.h

@@ -4,6 +4,8 @@
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#pragma once
+
 #include <array>
 
 #include "common/uuid.h"

src/core/hle/service/olsc/remote_storage_controller.h

@@ -4,6 +4,8 @@
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#pragma once
+
 #include "core/hle/service/cmif_types.h"
 #include "core/hle/service/service.h"
 

src/core/hle/service/olsc/transfer_task_list_controller.h

@@ -4,6 +4,8 @@
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#pragma once
+
 #include "core/hle/service/cmif_types.h"
 #include "core/hle/service/service.h"
 

src/core/hle/service/psc/time/clocks/system_clock_core.h

@@ -1,3 +1,6 @@
+// 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-2.0-or-later
 
@@ -10,6 +13,8 @@
 namespace Service::PSC::Time {
 class ContextWriter;
 
+#undef GetCurrentTime
+
 class SystemClockCore {
 public:
     explicit SystemClockCore(SteadyClockCore& steady_clock) : m_steady_clock{steady_clock} {}

src/core/hle/service/psc/time/system_clock.h

@@ -1,3 +1,6 @@
+// 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-2.0-or-later
 
@@ -16,6 +19,8 @@ class System;
 
 namespace Service::PSC::Time {
 
+#undef GetCurrentTime
+
 class SystemClock final : public ServiceFramework<SystemClock> {
 public:
     explicit SystemClock(Core::System& system, SystemClockCore& system_clock_core,

src/core/hle/service/ro/ro_results.h

@@ -1,6 +1,11 @@
+// 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-2.0-or-later
 
+#pragma once
+
 #include "core/hle/result.h"
 
 namespace Service::RO {

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

@@ -56,11 +56,11 @@ void PutValue(std::span<u8> buffer, const T& t) {
 
 } // Anonymous namespace
 
-void BSD::PollWork::Execute(BSD* bsd) {
+void NetworkBSD::PollWork::Execute(NetworkBSD* bsd) {
     std::tie(ret, bsd_errno) = bsd->PollImpl(write_buffer, read_buffer, nfds, timeout);
 }
 
-void BSD::PollWork::Response(HLERequestContext& ctx) {
+void NetworkBSD::PollWork::Response(HLERequestContext& ctx) {
     if (write_buffer.size() > 0) {
         ctx.WriteBuffer(write_buffer);
     }
@@ -71,11 +71,11 @@ void BSD::PollWork::Response(HLERequestContext& ctx) {
     rb.PushEnum(bsd_errno);
 }
 
-void BSD::AcceptWork::Execute(BSD* bsd) {
+void NetworkBSD::AcceptWork::Execute(NetworkBSD* bsd) {
     std::tie(ret, bsd_errno) = bsd->AcceptImpl(fd, write_buffer);
 }
 
-void BSD::AcceptWork::Response(HLERequestContext& ctx) {
+void NetworkBSD::AcceptWork::Response(HLERequestContext& ctx) {
     if (write_buffer.size() > 0) {
         ctx.WriteBuffer(write_buffer);
     }
@@ -87,22 +87,22 @@ void BSD::AcceptWork::Response(HLERequestContext& ctx) {
     rb.Push<u32>(static_cast<u32>(write_buffer.size()));
 }
 
-void BSD::ConnectWork::Execute(BSD* bsd) {
+void NetworkBSD::ConnectWork::Execute(NetworkBSD* bsd) {
     bsd_errno = bsd->ConnectImpl(fd, addr);
 }
 
-void BSD::ConnectWork::Response(HLERequestContext& ctx) {
+void NetworkBSD::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::RecvWork::Execute(BSD* bsd) {
+void NetworkBSD::RecvWork::Execute(NetworkBSD* bsd) {
     std::tie(ret, bsd_errno) = bsd->RecvImpl(fd, flags, message);
 }
 
-void BSD::RecvWork::Response(HLERequestContext& ctx) {
+void NetworkBSD::RecvWork::Response(HLERequestContext& ctx) {
     ctx.WriteBuffer(message);
 
     IPC::ResponseBuilder rb{ctx, 4};
@@ -111,11 +111,11 @@ void BSD::RecvWork::Response(HLERequestContext& ctx) {
     rb.PushEnum(bsd_errno);
 }
 
-void BSD::RecvFromWork::Execute(BSD* bsd) {
+void NetworkBSD::RecvFromWork::Execute(NetworkBSD* bsd) {
     std::tie(ret, bsd_errno) = bsd->RecvFromImpl(fd, flags, message, addr);
 }
 
-void BSD::RecvFromWork::Response(HLERequestContext& ctx) {
+void NetworkBSD::RecvFromWork::Response(HLERequestContext& ctx) {
     ctx.WriteBuffer(message, 0);
     if (!addr.empty()) {
         ctx.WriteBuffer(addr, 1);
@@ -128,29 +128,29 @@ void BSD::RecvFromWork::Response(HLERequestContext& ctx) {
     rb.Push<u32>(static_cast<u32>(addr.size()));
 }
 
-void BSD::SendWork::Execute(BSD* bsd) {
+void NetworkBSD::SendWork::Execute(NetworkBSD* bsd) {
     std::tie(ret, bsd_errno) = bsd->SendImpl(fd, flags, message);
 }
 
-void BSD::SendWork::Response(HLERequestContext& ctx) {
+void NetworkBSD::SendWork::Response(HLERequestContext& ctx) {
     IPC::ResponseBuilder rb{ctx, 4};
     rb.Push(ResultSuccess);
     rb.Push<s32>(ret);
     rb.PushEnum(bsd_errno);
 }
 
-void BSD::SendToWork::Execute(BSD* bsd) {
+void NetworkBSD::SendToWork::Execute(NetworkBSD* bsd) {
     std::tie(ret, bsd_errno) = bsd->SendToImpl(fd, flags, message, addr);
 }
 
-void BSD::SendToWork::Response(HLERequestContext& ctx) {
+void NetworkBSD::SendToWork::Response(HLERequestContext& ctx) {
     IPC::ResponseBuilder rb{ctx, 4};
     rb.Push(ResultSuccess);
     rb.Push<s32>(ret);
     rb.PushEnum(bsd_errno);
 }
 
-void BSD::RegisterClient(HLERequestContext& ctx) {
+void NetworkBSD::RegisterClient(HLERequestContext& ctx) {
     LOG_WARNING(Service, "(STUBBED) called");
 
     IPC::ResponseBuilder rb{ctx, 3};
@@ -159,7 +159,7 @@ void BSD::RegisterClient(HLERequestContext& ctx) {
     rb.Push<s32>(0); // bsd errno
 }
 
-void BSD::StartMonitoring(HLERequestContext& ctx) {
+void NetworkBSD::StartMonitoring(HLERequestContext& ctx) {
     LOG_WARNING(Service, "(STUBBED) called");
 
     IPC::ResponseBuilder rb{ctx, 2};
@@ -167,7 +167,7 @@ void BSD::StartMonitoring(HLERequestContext& ctx) {
     rb.Push(ResultSuccess);
 }
 
-void BSD::Socket(HLERequestContext& ctx) {
+void NetworkBSD::Socket(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const u32 domain = rp.Pop<u32>();
     const u32 type = rp.Pop<u32>();
@@ -184,7 +184,7 @@ void BSD::Socket(HLERequestContext& ctx) {
     rb.PushEnum(bsd_errno);
 }
 
-void BSD::Select(HLERequestContext& ctx) {
+void NetworkBSD::Select(HLERequestContext& ctx) {
     LOG_DEBUG(Service, "(STUBBED) called");
 
     IPC::ResponseBuilder rb{ctx, 4};
@@ -194,7 +194,7 @@ void BSD::Select(HLERequestContext& ctx) {
     rb.Push<u32>(0); // bsd errno
 }
 
-void BSD::Poll(HLERequestContext& ctx) {
+void NetworkBSD::Poll(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const s32 nfds = rp.Pop<s32>();
     const s32 timeout = rp.Pop<s32>();
@@ -209,7 +209,7 @@ void BSD::Poll(HLERequestContext& ctx) {
                      });
 }
 
-void BSD::Accept(HLERequestContext& ctx) {
+void NetworkBSD::Accept(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const s32 fd = rp.Pop<s32>();
 
@@ -221,7 +221,7 @@ void BSD::Accept(HLERequestContext& ctx) {
                      });
 }
 
-void BSD::Bind(HLERequestContext& ctx) {
+void NetworkBSD::Bind(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const s32 fd = rp.Pop<s32>();
 
@@ -229,7 +229,7 @@ void BSD::Bind(HLERequestContext& ctx) {
     BuildErrnoResponse(ctx, BindImpl(fd, ctx.ReadBuffer()));
 }
 
-void BSD::Connect(HLERequestContext& ctx) {
+void NetworkBSD::Connect(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const s32 fd = rp.Pop<s32>();
 
@@ -241,7 +241,7 @@ void BSD::Connect(HLERequestContext& ctx) {
                      });
 }
 
-void BSD::GetPeerName(HLERequestContext& ctx) {
+void NetworkBSD::GetPeerName(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const s32 fd = rp.Pop<s32>();
 
@@ -259,7 +259,7 @@ void BSD::GetPeerName(HLERequestContext& ctx) {
     rb.Push<u32>(static_cast<u32>(write_buffer.size()));
 }
 
-void BSD::GetSockName(HLERequestContext& ctx) {
+void NetworkBSD::GetSockName(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const s32 fd = rp.Pop<s32>();
 
@@ -277,7 +277,7 @@ void BSD::GetSockName(HLERequestContext& ctx) {
     rb.Push<u32>(static_cast<u32>(write_buffer.size()));
 }
 
-void BSD::GetSockOpt(HLERequestContext& ctx) {
+void NetworkBSD::GetSockOpt(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const s32 fd = rp.Pop<s32>();
     const u32 level = rp.Pop<u32>();
@@ -299,7 +299,7 @@ void BSD::GetSockOpt(HLERequestContext& ctx) {
     rb.Push<u32>(static_cast<u32>(optval.size()));
 }
 
-void BSD::Listen(HLERequestContext& ctx) {
+void NetworkBSD::Listen(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const s32 fd = rp.Pop<s32>();
     const s32 backlog = rp.Pop<s32>();
@@ -309,7 +309,7 @@ void BSD::Listen(HLERequestContext& ctx) {
     BuildErrnoResponse(ctx, ListenImpl(fd, backlog));
 }
 
-void BSD::Fcntl(HLERequestContext& ctx) {
+void NetworkBSD::Fcntl(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const s32 fd = rp.Pop<s32>();
     const s32 cmd = rp.Pop<s32>();
@@ -325,7 +325,7 @@ void BSD::Fcntl(HLERequestContext& ctx) {
     rb.PushEnum(bsd_errno);
 }
 
-void BSD::SetSockOpt(HLERequestContext& ctx) {
+void NetworkBSD::SetSockOpt(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
 
     const s32 fd = rp.Pop<s32>();
@@ -339,7 +339,7 @@ void BSD::SetSockOpt(HLERequestContext& ctx) {
     BuildErrnoResponse(ctx, SetSockOptImpl(fd, level, optname, optval));
 }
 
-void BSD::Shutdown(HLERequestContext& ctx) {
+void NetworkBSD::Shutdown(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
 
     const s32 fd = rp.Pop<s32>();
@@ -350,7 +350,7 @@ void BSD::Shutdown(HLERequestContext& ctx) {
     BuildErrnoResponse(ctx, ShutdownImpl(fd, how));
 }
 
-void BSD::Recv(HLERequestContext& ctx) {
+void NetworkBSD::Recv(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
 
     const s32 fd = rp.Pop<s32>();
@@ -365,7 +365,7 @@ void BSD::Recv(HLERequestContext& ctx) {
                      });
 }
 
-void BSD::RecvFrom(HLERequestContext& ctx) {
+void NetworkBSD::RecvFrom(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
 
     const s32 fd = rp.Pop<s32>();
@@ -382,7 +382,7 @@ void BSD::RecvFrom(HLERequestContext& ctx) {
                      });
 }
 
-void BSD::Send(HLERequestContext& ctx) {
+void NetworkBSD::Send(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
 
     const s32 fd = rp.Pop<s32>();
@@ -397,7 +397,7 @@ void BSD::Send(HLERequestContext& ctx) {
                      });
 }
 
-void BSD::SendTo(HLERequestContext& ctx) {
+void NetworkBSD::SendTo(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const s32 fd = rp.Pop<s32>();
     const u32 flags = rp.Pop<u32>();
@@ -413,7 +413,7 @@ void BSD::SendTo(HLERequestContext& ctx) {
                      });
 }
 
-void BSD::Write(HLERequestContext& ctx) {
+void NetworkBSD::Write(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const s32 fd = rp.Pop<s32>();
 
@@ -426,7 +426,7 @@ void BSD::Write(HLERequestContext& ctx) {
                      });
 }
 
-void BSD::Read(HLERequestContext& ctx) {
+void NetworkBSD::Read(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const s32 fd = rp.Pop<s32>();
 
@@ -438,7 +438,7 @@ void BSD::Read(HLERequestContext& ctx) {
     rb.Push<u32>(0); // bsd errno
 }
 
-void BSD::Close(HLERequestContext& ctx) {
+void NetworkBSD::Close(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const s32 fd = rp.Pop<s32>();
 
@@ -447,7 +447,7 @@ void BSD::Close(HLERequestContext& ctx) {
     BuildErrnoResponse(ctx, CloseImpl(fd));
 }
 
-void BSD::DuplicateSocket(HLERequestContext& ctx) {
+void NetworkBSD::DuplicateSocket(HLERequestContext& ctx) {
     struct InputParameters {
         s32 fd;
         u64 reserved;
@@ -472,7 +472,7 @@ void BSD::DuplicateSocket(HLERequestContext& ctx) {
     });
 }
 
-void BSD::EventFd(HLERequestContext& ctx) {
+void NetworkBSD::EventFd(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const u64 initval = rp.Pop<u64>();
     const u32 flags = rp.Pop<u32>();
@@ -483,12 +483,12 @@ void BSD::EventFd(HLERequestContext& ctx) {
 }
 
 template <typename Work>
-void BSD::ExecuteWork(HLERequestContext& ctx, Work work) {
+void NetworkBSD::ExecuteWork(HLERequestContext& ctx, Work work) {
     work.Execute(this);
     work.Response(ctx);
 }
 
-std::pair<s32, Errno> BSD::SocketImpl(Domain domain, Type type, Protocol protocol) {
+std::pair<s32, Errno> NetworkBSD::SocketImpl(Domain domain, Type type, Protocol protocol) {
 
     if (type == Type::SEQPACKET) {
         UNIMPLEMENTED_MSG("SOCK_SEQPACKET errno management");
@@ -530,7 +530,7 @@ std::pair<s32, Errno> BSD::SocketImpl(Domain domain, Type type, Protocol protoco
     return {fd, Errno::SUCCESS};
 }
 
-std::pair<s32, Errno> BSD::PollImpl(std::vector<u8>& write_buffer, std::span<const u8> read_buffer,
+std::pair<s32, Errno> NetworkBSD::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
@@ -597,7 +597,7 @@ std::pair<s32, Errno> BSD::PollImpl(std::vector<u8>& write_buffer, std::span<con
     return Translate(result);
 }
 
-std::pair<s32, Errno> BSD::AcceptImpl(s32 fd, std::vector<u8>& write_buffer) {
+std::pair<s32, Errno> NetworkBSD::AcceptImpl(s32 fd, std::vector<u8>& write_buffer) {
     if (!IsFileDescriptorValid(fd)) {
         return {-1, Errno::BADF};
     }
@@ -625,7 +625,7 @@ std::pair<s32, Errno> BSD::AcceptImpl(s32 fd, std::vector<u8>& write_buffer) {
     return {new_fd, Errno::SUCCESS};
 }
 
-Errno BSD::BindImpl(s32 fd, std::span<const u8> addr) {
+Errno NetworkBSD::BindImpl(s32 fd, std::span<const u8> addr) {
     if (!IsFileDescriptorValid(fd)) {
         return Errno::BADF;
     }
@@ -635,7 +635,7 @@ Errno BSD::BindImpl(s32 fd, std::span<const u8> addr) {
     return Translate(file_descriptors[fd]->socket->Bind(Translate(addr_in)));
 }
 
-Errno BSD::ConnectImpl(s32 fd, std::span<const u8> addr) {
+Errno NetworkBSD::ConnectImpl(s32 fd, std::span<const u8> addr) {
     if (!IsFileDescriptorValid(fd)) {
         return Errno::BADF;
     }
@@ -653,7 +653,7 @@ Errno BSD::ConnectImpl(s32 fd, std::span<const u8> addr) {
     return result;
 }
 
-Errno BSD::GetPeerNameImpl(s32 fd, std::vector<u8>& write_buffer) {
+Errno NetworkBSD::GetPeerNameImpl(s32 fd, std::vector<u8>& write_buffer) {
     if (!IsFileDescriptorValid(fd)) {
         return Errno::BADF;
     }
@@ -670,7 +670,7 @@ Errno BSD::GetPeerNameImpl(s32 fd, std::vector<u8>& write_buffer) {
     return Translate(bsd_errno);
 }
 
-Errno BSD::GetSockNameImpl(s32 fd, std::vector<u8>& write_buffer) {
+Errno NetworkBSD::GetSockNameImpl(s32 fd, std::vector<u8>& write_buffer) {
     if (!IsFileDescriptorValid(fd)) {
         return Errno::BADF;
     }
@@ -687,14 +687,14 @@ Errno BSD::GetSockNameImpl(s32 fd, std::vector<u8>& write_buffer) {
     return Translate(bsd_errno);
 }
 
-Errno BSD::ListenImpl(s32 fd, s32 backlog) {
+Errno NetworkBSD::ListenImpl(s32 fd, s32 backlog) {
     if (!IsFileDescriptorValid(fd)) {
         return Errno::BADF;
     }
     return Translate(file_descriptors[fd]->socket->Listen(backlog));
 }
 
-std::pair<s32, Errno> BSD::FcntlImpl(s32 fd, FcntlCmd cmd, s32 arg) {
+std::pair<s32, Errno> NetworkBSD::FcntlImpl(s32 fd, FcntlCmd cmd, s32 arg) {
     if (!IsFileDescriptorValid(fd)) {
         return {-1, Errno::BADF};
     }
@@ -720,7 +720,7 @@ std::pair<s32, Errno> BSD::FcntlImpl(s32 fd, FcntlCmd cmd, s32 arg) {
     }
 }
 
-Errno BSD::GetSockOptImpl(s32 fd, u32 level, OptName optname, std::vector<u8>& optval) {
+Errno NetworkBSD::GetSockOptImpl(s32 fd, u32 level, OptName optname, std::vector<u8>& optval) {
     if (!IsFileDescriptorValid(fd)) {
         return Errno::BADF;
     }
@@ -751,7 +751,7 @@ Errno BSD::GetSockOptImpl(s32 fd, u32 level, OptName optname, std::vector<u8>& o
     }
 }
 
-Errno BSD::SetSockOptImpl(s32 fd, u32 level, OptName optname, std::span<const u8> optval) {
+Errno NetworkBSD::SetSockOptImpl(s32 fd, u32 level, OptName optname, std::span<const u8> optval) {
     if (!IsFileDescriptorValid(fd)) {
         return Errno::BADF;
     }
@@ -801,7 +801,7 @@ Errno BSD::SetSockOptImpl(s32 fd, u32 level, OptName optname, std::span<const u8
     }
 }
 
-Errno BSD::ShutdownImpl(s32 fd, s32 how) {
+Errno NetworkBSD::ShutdownImpl(s32 fd, s32 how) {
     if (!IsFileDescriptorValid(fd)) {
         return Errno::BADF;
     }
@@ -809,7 +809,7 @@ Errno BSD::ShutdownImpl(s32 fd, s32 how) {
     return Translate(file_descriptors[fd]->socket->Shutdown(host_how));
 }
 
-std::pair<s32, Errno> BSD::RecvImpl(s32 fd, u32 flags, std::vector<u8>& message) {
+std::pair<s32, Errno> NetworkBSD::RecvImpl(s32 fd, u32 flags, std::vector<u8>& message) {
     if (!IsFileDescriptorValid(fd)) {
         return {-1, Errno::BADF};
     }
@@ -836,7 +836,7 @@ std::pair<s32, Errno> BSD::RecvImpl(s32 fd, u32 flags, std::vector<u8>& message)
     return {ret, bsd_errno};
 }
 
-std::pair<s32, Errno> BSD::RecvFromImpl(s32 fd, u32 flags, std::vector<u8>& message,
+std::pair<s32, Errno> NetworkBSD::RecvFromImpl(s32 fd, u32 flags, std::vector<u8>& message,
                                         std::vector<u8>& addr) {
     if (!IsFileDescriptorValid(fd)) {
         return {-1, Errno::BADF};
@@ -883,14 +883,14 @@ std::pair<s32, Errno> BSD::RecvFromImpl(s32 fd, u32 flags, std::vector<u8>& mess
     return {ret, bsd_errno};
 }
 
-std::pair<s32, Errno> BSD::SendImpl(s32 fd, u32 flags, std::span<const u8> message) {
+std::pair<s32, Errno> NetworkBSD::SendImpl(s32 fd, u32 flags, std::span<const u8> message) {
     if (!IsFileDescriptorValid(fd)) {
         return {-1, Errno::BADF};
     }
     return Translate(file_descriptors[fd]->socket->Send(message, flags));
 }
 
-std::pair<s32, Errno> BSD::SendToImpl(s32 fd, u32 flags, std::span<const u8> message,
+std::pair<s32, Errno> NetworkBSD::SendToImpl(s32 fd, u32 flags, std::span<const u8> message,
                                       std::span<const u8> addr) {
     if (!IsFileDescriptorValid(fd)) {
         return {-1, Errno::BADF};
@@ -908,7 +908,7 @@ std::pair<s32, Errno> BSD::SendToImpl(s32 fd, u32 flags, std::span<const u8> mes
     return Translate(file_descriptors[fd]->socket->SendTo(flags, message, p_addr_in));
 }
 
-Errno BSD::CloseImpl(s32 fd) {
+Errno NetworkBSD::CloseImpl(s32 fd) {
     if (!IsFileDescriptorValid(fd)) {
         return Errno::BADF;
     }
@@ -924,7 +924,7 @@ Errno BSD::CloseImpl(s32 fd) {
     return bsd_errno;
 }
 
-Expected<s32, Errno> BSD::DuplicateSocketImpl(s32 fd) {
+Expected<s32, Errno> NetworkBSD::DuplicateSocketImpl(s32 fd) {
     if (!IsFileDescriptorValid(fd)) {
         return Unexpected(Errno::BADF);
     }
@@ -943,14 +943,14 @@ Expected<s32, Errno> BSD::DuplicateSocketImpl(s32 fd) {
     return new_fd;
 }
 
-std::optional<std::shared_ptr<Network::SocketBase>> BSD::GetSocket(s32 fd) {
+std::optional<std::shared_ptr<Network::SocketBase>> NetworkBSD::GetSocket(s32 fd) {
     if (!IsFileDescriptorValid(fd)) {
         return std::nullopt;
     }
     return file_descriptors[fd]->socket;
 }
 
-s32 BSD::FindFreeFileDescriptorHandle() noexcept {
+s32 NetworkBSD::FindFreeFileDescriptorHandle() noexcept {
     for (s32 fd = 0; fd < static_cast<s32>(file_descriptors.size()); ++fd) {
         if (!file_descriptors[fd]) {
             return fd;
@@ -959,7 +959,7 @@ s32 BSD::FindFreeFileDescriptorHandle() noexcept {
     return -1;
 }
 
-bool BSD::IsFileDescriptorValid(s32 fd) const noexcept {
+bool NetworkBSD::IsFileDescriptorValid(s32 fd) const noexcept {
     if (fd > static_cast<s32>(MAX_FD) || fd < 0) {
         LOG_ERROR(Service, "Invalid file descriptor handle={}", fd);
         return false;
@@ -971,7 +971,7 @@ bool BSD::IsFileDescriptorValid(s32 fd) const noexcept {
     return true;
 }
 
-void BSD::BuildErrnoResponse(HLERequestContext& ctx, Errno bsd_errno) const noexcept {
+void NetworkBSD::BuildErrnoResponse(HLERequestContext& ctx, Errno bsd_errno) const noexcept {
     IPC::ResponseBuilder rb{ctx, 4};
 
     rb.Push(ResultSuccess);
@@ -979,7 +979,7 @@ void BSD::BuildErrnoResponse(HLERequestContext& ctx, Errno bsd_errno) const noex
     rb.PushEnum(bsd_errno);
 }
 
-void BSD::OnProxyPacketReceived(const Network::ProxyPacket& packet) {
+void NetworkBSD::OnProxyPacketReceived(const Network::ProxyPacket& packet) {
     for (auto& optional_descriptor : file_descriptors) {
         if (!optional_descriptor.has_value()) {
             continue;
@@ -989,42 +989,42 @@ void BSD::OnProxyPacketReceived(const Network::ProxyPacket& packet) {
     }
 }
 
-BSD::BSD(Core::System& system_, const char* name)
+NetworkBSD::NetworkBSD(Core::System& system_, const char* name)
     : ServiceFramework{system_, name} {
     // clang-format off
     static const FunctionInfo functions[] = {
-        {0, &BSD::RegisterClient, "RegisterClient"},
-        {1, &BSD::StartMonitoring, "StartMonitoring"},
-        {2, &BSD::Socket, "Socket"},
+        {0, &NetworkBSD::RegisterClient, "RegisterClient"},
+        {1, &NetworkBSD::StartMonitoring, "StartMonitoring"},
+        {2, &NetworkBSD::Socket, "Socket"},
         {3, nullptr, "SocketExempt"},
         {4, nullptr, "Open"},
-        {5, &BSD::Select, "Select"},
-        {6, &BSD::Poll, "Poll"},
+        {5, &NetworkBSD::Select, "Select"},
+        {6, &NetworkBSD::Poll, "Poll"},
         {7, nullptr, "Sysctl"},
-        {8, &BSD::Recv, "Recv"},
-        {9, &BSD::RecvFrom, "RecvFrom"},
-        {10, &BSD::Send, "Send"},
-        {11, &BSD::SendTo, "SendTo"},
-        {12, &BSD::Accept, "Accept"},
-        {13, &BSD::Bind, "Bind"},
-        {14, &BSD::Connect, "Connect"},
-        {15, &BSD::GetPeerName, "GetPeerName"},
-        {16, &BSD::GetSockName, "GetSockName"},
-        {17, &BSD::GetSockOpt, "GetSockOpt"},
-        {18, &BSD::Listen, "Listen"},
+        {8, &NetworkBSD::Recv, "Recv"},
+        {9, &NetworkBSD::RecvFrom, "RecvFrom"},
+        {10, &NetworkBSD::Send, "Send"},
+        {11, &NetworkBSD::SendTo, "SendTo"},
+        {12, &NetworkBSD::Accept, "Accept"},
+        {13, &NetworkBSD::Bind, "Bind"},
+        {14, &NetworkBSD::Connect, "Connect"},
+        {15, &NetworkBSD::GetPeerName, "GetPeerName"},
+        {16, &NetworkBSD::GetSockName, "GetSockName"},
+        {17, &NetworkBSD::GetSockOpt, "GetSockOpt"},
+        {18, &NetworkBSD::Listen, "Listen"},
         {19, nullptr, "Ioctl"},
-        {20, &BSD::Fcntl, "Fcntl"},
-        {21, &BSD::SetSockOpt, "SetSockOpt"},
-        {22, &BSD::Shutdown, "Shutdown"},
+        {20, &NetworkBSD::Fcntl, "Fcntl"},
+        {21, &NetworkBSD::SetSockOpt, "SetSockOpt"},
+        {22, &NetworkBSD::Shutdown, "Shutdown"},
         {23, nullptr, "ShutdownAllSockets"},
-        {24, &BSD::Write, "Write"},
-        {25, &BSD::Read, "Read"},
-        {26, &BSD::Close, "Close"},
-        {27, &BSD::DuplicateSocket, "DuplicateSocket"},
+        {24, &NetworkBSD::Write, "Write"},
+        {25, &NetworkBSD::Read, "Read"},
+        {26, &NetworkBSD::Close, "Close"},
+        {27, &NetworkBSD::DuplicateSocket, "DuplicateSocket"},
         {28, nullptr, "GetResourceStatistics"},
         {29, nullptr, "RecvMMsg"}, //3.0.0+
         {30, nullptr, "SendMMsg"}, //3.0.0+
-        {31, &BSD::EventFd, "EventFd"}, //7.0.0+
+        {31, &NetworkBSD::EventFd, "EventFd"}, //7.0.0+
         {32, nullptr, "RegisterResourceStatisticsName"}, //7.0.0+
         {33, nullptr, "RegisterClientShared"}, //10.0.0+
         {34, nullptr, "GetSocketStatistics"}, //15.0.0+
@@ -1052,13 +1052,13 @@ BSD::BSD(Core::System& system_, const char* name)
     }
 }
 
-BSD::~BSD() {
+NetworkBSD::~NetworkBSD() {
     if (auto room_member = Network::GetRoomMember().lock()) {
         room_member->Unbind(proxy_packet_received);
     }
 }
 
-std::unique_lock<std::mutex> BSD::LockService() noexcept {
+std::unique_lock<std::mutex> NetworkBSD::LockService() noexcept {
     return {};
 }
 

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

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
@@ -27,10 +27,10 @@ class Socket;
 
 namespace Service::Sockets {
 
-class BSD final : public ServiceFramework<BSD> {
+class NetworkBSD final : public ServiceFramework<NetworkBSD> {
 public:
-    explicit BSD(Core::System& system_, const char* name);
-    ~BSD() override;
+    explicit NetworkBSD(Core::System& system_, const char* name);
+    ~NetworkBSD() 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* bsd);
+        void Execute(NetworkBSD* bsd);
         void Response(HLERequestContext& ctx);
 
         s32 nfds;
@@ -62,7 +62,7 @@ private:
     };
 
     struct AcceptWork {
-        void Execute(BSD* bsd);
+        void Execute(NetworkBSD* bsd);
         void Response(HLERequestContext& ctx);
 
         s32 fd;
@@ -72,7 +72,7 @@ private:
     };
 
     struct ConnectWork {
-        void Execute(BSD* bsd);
+        void Execute(NetworkBSD* bsd);
         void Response(HLERequestContext& ctx);
 
         s32 fd;
@@ -81,7 +81,7 @@ private:
     };
 
     struct RecvWork {
-        void Execute(BSD* bsd);
+        void Execute(NetworkBSD* bsd);
         void Response(HLERequestContext& ctx);
 
         s32 fd;
@@ -92,7 +92,7 @@ private:
     };
 
     struct RecvFromWork {
-        void Execute(BSD* bsd);
+        void Execute(NetworkBSD* bsd);
         void Response(HLERequestContext& ctx);
 
         s32 fd;
@@ -104,7 +104,7 @@ private:
     };
 
     struct SendWork {
-        void Execute(BSD* bsd);
+        void Execute(NetworkBSD* bsd);
         void Response(HLERequestContext& ctx);
 
         s32 fd;
@@ -115,7 +115,7 @@ private:
     };
 
     struct SendToWork {
-        void Execute(BSD* bsd);
+        void Execute(NetworkBSD* bsd);
         void Response(HLERequestContext& ctx);
 
         s32 fd;

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

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -12,8 +15,8 @@ namespace Service::Sockets {
 void LoopProcess(Core::System& system) {
     auto server_manager = std::make_unique<ServerManager>(system);
 
-    server_manager->RegisterNamedService("bsd:s", std::make_shared<BSD>(system, "bsd:s"));
-    server_manager->RegisterNamedService("bsd:u", std::make_shared<BSD>(system, "bsd:u"));
+    server_manager->RegisterNamedService("bsd:s", std::make_shared<NetworkBSD>(system, "bsd:s"));
+    server_manager->RegisterNamedService("bsd:u", std::make_shared<NetworkBSD>(system, "bsd:u"));
     server_manager->RegisterNamedService("bsdcfg", std::make_shared<BSDCFG>(system));
     server_manager->RegisterNamedService("nsd:a", std::make_shared<NSD>(system, "nsd:a"));
     server_manager->RegisterNamedService("nsd:u", std::make_shared<NSD>(system, "nsd:u"));

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>("bsd:u");
+                auto bsd = system.ServiceManager().GetService<Service::Sockets::NetworkBSD>("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>("bsd:u");
+        auto bsd = system.ServiceManager().GetService<Service::Sockets::NetworkBSD>("bsd:u");
         ASSERT_OR_EXECUTE(bsd, { return ResultInternalError; });
 
         auto res = bsd->DuplicateSocketImpl(fd);

src/core/hle/service/vi/application_display_service.h

@@ -1,6 +1,11 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#pragma once
+
 #include <map>
 #include <set>
 

src/core/hle/service/vi/system_display_service.h

@@ -1,9 +1,11 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#pragma once
+
 #include "common/math_util.h"
 #include "core/hle/service/cmif_types.h"
 #include "core/hle/service/nvnflinger/ui/fence.h"

src/core/loader/kip.cpp

@@ -17,11 +17,9 @@
 
 namespace Loader {
 
-namespace {
-constexpr u32 PageAlignSize(u32 size) {
-    return static_cast<u32>((size + Core::Memory::YUZU_PAGEMASK) & ~Core::Memory::YUZU_PAGEMASK);
+[[nodiscard]] inline constexpr u32 PageAlignSizeKIP(u32 size) {
+    return u32((size + Core::Memory::YUZU_PAGEMASK) & ~Core::Memory::YUZU_PAGEMASK);
 }
-} // Anonymous namespace
 
 AppLoader_KIP::AppLoader_KIP(FileSys::VirtualFile file_)
     : AppLoader(std::move(file_)), kip(std::make_unique<FileSys::KIP>(file)) {}
@@ -76,11 +74,11 @@ AppLoader::LoadResult AppLoader_KIP::Load(Kernel::KProcess& process,
                         kip->GetKernelCapabilities());
 
     Kernel::CodeSet codeset;
-    codeset.memory.resize(PageAlignSize(kip->GetBSSOffset()) + kip->GetBSSSize());
+    codeset.memory.resize(PageAlignSizeKIP(kip->GetBSSOffset()) + kip->GetBSSSize());
     const auto load_segment = [&codeset](Kernel::CodeSet::Segment& segment, std::span<const u8> data, u32 offset) {
         segment.addr = offset;
         segment.offset = offset;
-        segment.size = PageAlignSize(u32(data.size()));
+        segment.size = PageAlignSizeKIP(u32(data.size()));
         std::memcpy(codeset.memory.data() + offset, data.data(), data.size());
     };
     load_segment(codeset.CodeSegment(), kip->GetTextSection(), kip->GetTextOffset());

src/core/loader/nro.cpp

@@ -143,8 +143,8 @@ bool AppLoader_NRO::IsHomebrew() {
            nro_header.magic_ext2 == Common::MakeMagic('B', 'R', 'E', 'W');
 }
 
-static constexpr u32 PageAlignSize(u32 size) {
-    return static_cast<u32>((size + Core::Memory::YUZU_PAGEMASK) & ~Core::Memory::YUZU_PAGEMASK);
+[[nodiscard]] inline constexpr u32 PageAlignSizeNRO(u32 size) {
+    return u32((size + Core::Memory::YUZU_PAGEMASK) & ~Core::Memory::YUZU_PAGEMASK);
 }
 
 static bool LoadNroImpl(Core::System& system, Kernel::KProcess& process,
@@ -161,9 +161,9 @@ static bool LoadNroImpl(Core::System& system, Kernel::KProcess& process,
     }
 
     // Build program image
-    std::vector<u8> program_image(PageAlignSize(nro_header.file_size));
+    std::vector<u8> program_image(PageAlignSizeNRO(nro_header.file_size));
     std::memcpy(program_image.data(), data.data(), program_image.size());
-    if (program_image.size() != PageAlignSize(nro_header.file_size)) {
+    if (program_image.size() != PageAlignSizeNRO(nro_header.file_size)) {
         return {};
     }
 
@@ -171,7 +171,7 @@ static bool LoadNroImpl(Core::System& system, Kernel::KProcess& process,
     for (std::size_t i = 0; i < nro_header.segments.size(); ++i) {
         codeset.segments[i].addr = nro_header.segments[i].offset;
         codeset.segments[i].offset = nro_header.segments[i].offset;
-        codeset.segments[i].size = PageAlignSize(nro_header.segments[i].size);
+        codeset.segments[i].size = PageAlignSizeNRO(nro_header.segments[i].size);
     }
 
     if (!Settings::values.program_args.GetValue().empty()) {
@@ -188,7 +188,7 @@ static bool LoadNroImpl(Core::System& system, Kernel::KProcess& process,
     }
 
     // Default .bss to NRO header bss size if MOD0 section doesn't exist
-    u32 bss_size{PageAlignSize(nro_header.bss_size)};
+    u32 bss_size{PageAlignSizeNRO(nro_header.bss_size)};
 
     // Read MOD header
     ModHeader mod_header{};
@@ -198,7 +198,7 @@ static bool LoadNroImpl(Core::System& system, Kernel::KProcess& process,
     const bool has_mod_header{mod_header.magic == Common::MakeMagic('M', 'O', 'D', '0')};
     if (has_mod_header) {
         // Resize program image to include .bss section and page align each section
-        bss_size = PageAlignSize(mod_header.bss_end_offset - mod_header.bss_start_offset);
+        bss_size = PageAlignSizeNRO(mod_header.bss_end_offset - mod_header.bss_start_offset);
     }
 
     codeset.DataSegment().size += bss_size;

src/core/loader/nso.cpp

@@ -41,8 +41,8 @@ struct MODHeader {
 };
 static_assert(sizeof(MODHeader) == 0x1c, "MODHeader has incorrect size.");
 
-constexpr u32 PageAlignSize(u32 size) {
-    return static_cast<u32>((size + Core::Memory::YUZU_PAGEMASK) & ~Core::Memory::YUZU_PAGEMASK);
+[[nodiscard]] inline constexpr u32 PageAlignSizeNSO(u32 size) {
+    return u32((size + Core::Memory::YUZU_PAGEMASK) & ~Core::Memory::YUZU_PAGEMASK);
 }
 } // Anonymous namespace
 
@@ -128,11 +128,11 @@ std::optional<VAddr> AppLoader_NSO::LoadModule(Kernel::KProcess& process, Core::
     }
 
     codeset.DataSegment().size += nso_header.segments[2].bss_size;
-    u32 image_size = PageAlignSize(u32(codeset.memory.size()) + nso_header.segments[2].bss_size);
+    u32 image_size = PageAlignSizeNSO(u32(codeset.memory.size()) + nso_header.segments[2].bss_size);
     codeset.memory.resize(image_size);
 
     for (std::size_t i = 0; i < nso_header.segments.size(); ++i) {
-        codeset.segments[i].size = PageAlignSize(codeset.segments[i].size);
+        codeset.segments[i].size = PageAlignSizeNSO(codeset.segments[i].size);
     }
 
     // Apply patches if necessary

src/core/memory/cheat_engine.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
@@ -21,6 +21,8 @@
 #include "hid_core/resource_manager.h"
 #include "hid_core/resources/npad/npad.h"
 
+#undef CreateEvent
+
 namespace Core::Memory {
 namespace {
 constexpr auto CHEAT_ENGINE_NS = std::chrono::nanoseconds{1000000000 / 12};

src/core/reporter.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
@@ -27,6 +27,8 @@
 #include "core/memory.h"
 #include "core/reporter.h"
 
+#undef far
+
 namespace {
 
 std::filesystem::path GetPath(std::string_view type, u64 title_id, std::string_view timestamp) {

src/core/tools/freezer.cpp

@@ -52,6 +52,8 @@ void MemoryWriteWidth(Core::Memory::Memory& memory, u32 width, VAddr addr, u64 v
 
 } // Anonymous namespace
 
+#undef CreateEvent
+
 Freezer::Freezer(Core::Timing::CoreTiming& core_timing_, Core::Memory::Memory& memory_)
     : core_timing{core_timing_}, memory{memory_} {
     event = Core::Timing::CreateEvent("MemoryFreezer::FrameCallback",

src/core/tools/renderdoc.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
@@ -51,10 +51,12 @@ void RenderdocAPI::ToggleCapture() {
     if (!rdoc_api) [[unlikely]] {
         return;
     }
+
+    auto* api = static_cast<RENDERDOC_API_1_6_0*>(rdoc_api);
     if (!is_capturing) {
-        rdoc_api->StartFrameCapture(NULL, NULL);
+        api->StartFrameCapture(NULL, NULL);
     } else {
-        rdoc_api->EndFrameCapture(NULL, NULL);
+        api->EndFrameCapture(NULL, NULL);
     }
     is_capturing = !is_capturing;
 }

src/core/tools/renderdoc.h

@@ -6,8 +6,6 @@
 
 #pragma once
 
-struct RENDERDOC_API_1_7_0;
-
 namespace Tools {
 
 class RenderdocAPI {
@@ -18,7 +16,7 @@ public:
     void ToggleCapture();
 
 private:
-    RENDERDOC_API_1_7_0* rdoc_api{};
+    void* rdoc_api{};
     bool is_capturing{false};
 };
 

src/dynarmic/src/dynarmic/backend/arm64/emit_arm64_memory.cpp

@@ -31,7 +31,7 @@ using namespace oaknut::util;
 
 namespace {
 
-bool IsOrdered(IR::AccType acctype) {
+[[nodiscard]] inline bool IsOrdered(IR::AccType acctype) {
     return acctype == IR::AccType::ORDERED || acctype == IR::AccType::ORDEREDRW || acctype == IR::AccType::LIMITEDORDERED;
 }
 

src/frontend_common/update_checker.cpp

@@ -14,6 +14,7 @@
 #include "update_checker.h"
 
 #include <httplib.h>
+#undef INVALID_SOCKET
 
 #ifdef YUZU_BUNDLED_OPENSSL
 #include <openssl/cert.h>

src/hid_core/hidbus/starlink.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -6,7 +9,6 @@
 #include "hid_core/hidbus/starlink.h"
 
 namespace Service::HID {
-constexpr u8 DEVICE_ID = 0x28;
 
 Starlink::Starlink(Core::System& system_, KernelHelpers::ServiceContext& service_context_)
     : HidbusBase(system_, service_context_) {}
@@ -35,7 +37,7 @@ void Starlink::OnUpdate() {
 }
 
 u8 Starlink::GetDeviceId() const {
-    return DEVICE_ID;
+    return 0x28;
 }
 
 u64 Starlink::GetReply(std::span<u8> out_data) const {

src/hid_core/hidbus/stubbed.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -6,7 +9,6 @@
 #include "hid_core/hidbus/stubbed.h"
 
 namespace Service::HID {
-constexpr u8 DEVICE_ID = 0xFF;
 
 HidbusStubbed::HidbusStubbed(Core::System& system_, KernelHelpers::ServiceContext& service_context_)
     : HidbusBase(system_, service_context_) {}
@@ -35,7 +37,7 @@ void HidbusStubbed::OnUpdate() {
 }
 
 u8 HidbusStubbed::GetDeviceId() const {
-    return DEVICE_ID;
+    return 0xFF;
 }
 
 u64 HidbusStubbed::GetReply(std::span<u8> out_data) const {

src/hid_core/irsensor/moment_processor.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -8,9 +11,6 @@
 #include "hid_core/irsensor/moment_processor.h"
 
 namespace Service::IRS {
-static constexpr auto format = Core::IrSensor::ImageTransferProcessorFormat::Size40x30;
-static constexpr std::size_t ImageWidth = 40;
-static constexpr std::size_t ImageHeight = 30;
 
 MomentProcessor::MomentProcessor(Core::System& system_, Core::IrSensor::DeviceFormat& device_format,
                                  std::size_t npad_index)
@@ -80,9 +80,9 @@ void MomentProcessor::OnControllerUpdate(Core::HID::ControllerTriggerType type)
 }
 
 u8 MomentProcessor::GetPixel(const std::vector<u8>& data, std::size_t x, std::size_t y) const {
-    if ((y * ImageWidth) + x >= data.size()) {
+    constexpr std::size_t ImageWidth = 40;
+    if ((y * ImageWidth) + x >= data.size())
         return 0;
-    }
     return data[(y * ImageWidth) + x];
 }
 
@@ -92,9 +92,12 @@ MomentProcessor::MomentStatistic MomentProcessor::GetStatistic(const std::vector
                                                                std::size_t width,
                                                                std::size_t height) const {
     // The actual implementation is always 320x240
-    static constexpr std::size_t RealWidth = 320;
-    static constexpr std::size_t RealHeight = 240;
-    static constexpr std::size_t Threshold = 30;
+    constexpr std::size_t RealWidth = 320;
+    constexpr std::size_t RealHeight = 240;
+    constexpr std::size_t Threshold = 30;
+    constexpr std::size_t ImageWidth = 40;
+    constexpr std::size_t ImageHeight = 30;
+
     MomentStatistic statistic{};
     std::size_t active_points{};
 
@@ -143,7 +146,7 @@ void MomentProcessor::SetConfig(Core::IrSensor::PackedMomentProcessorConfig conf
         static_cast<Core::IrSensor::MomentProcessorPreprocess>(config.preprocess);
     current_config.preprocess_intensity_threshold = config.preprocess_intensity_threshold;
 
-    npad_device->SetCameraFormat(format);
+    npad_device->SetCameraFormat(Core::IrSensor::ImageTransferProcessorFormat::Size40x30);
 }
 
 } // namespace Service::IRS

src/input_common/drivers/camera.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -7,14 +10,14 @@
 #include "input_common/drivers/camera.h"
 
 namespace InputCommon {
-constexpr PadIdentifier identifier = {
+constexpr PadIdentifier camera_identifier = {
     .guid = Common::UUID{},
     .port = 0,
     .pad = 0,
 };
 
 Camera::Camera(std::string input_engine_) : InputEngine(std::move(input_engine_)) {
-    PreSetController(identifier);
+    PreSetController(camera_identifier);
 }
 
 void Camera::SetCameraData(std::size_t width, std::size_t height, std::span<const u32> data) {
@@ -33,7 +36,7 @@ void Camera::SetCameraData(std::size_t width, std::size_t height, std::span<cons
         }
     }
 
-    SetCamera(identifier, status);
+    SetCamera(camera_identifier, status);
 }
 
 std::size_t Camera::getImageWidth() const {

src/input_common/drivers/mouse.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
@@ -26,7 +26,7 @@ constexpr int mouse_axis_x = 0;
 constexpr int mouse_axis_y = 1;
 constexpr int wheel_axis_x = 2;
 constexpr int wheel_axis_y = 3;
-constexpr PadIdentifier identifier = {
+constexpr PadIdentifier mouse_identifier = {
     .guid = Common::UUID{},
     .port = 0,
     .pad = 0,
@@ -51,16 +51,16 @@ constexpr PadIdentifier touch_identifier = {
 };
 
 Mouse::Mouse(std::string input_engine_) : InputEngine(std::move(input_engine_)) {
-    PreSetController(identifier);
+    PreSetController(mouse_identifier);
     PreSetController(real_mouse_identifier);
     PreSetController(touch_identifier);
     PreSetController(motion_identifier);
 
     // Initialize all mouse axis
-    PreSetAxis(identifier, mouse_axis_x);
-    PreSetAxis(identifier, mouse_axis_y);
-    PreSetAxis(identifier, wheel_axis_x);
-    PreSetAxis(identifier, wheel_axis_y);
+    PreSetAxis(mouse_identifier, mouse_axis_x);
+    PreSetAxis(mouse_identifier, mouse_axis_y);
+    PreSetAxis(mouse_identifier, wheel_axis_x);
+    PreSetAxis(mouse_identifier, wheel_axis_y);
     PreSetAxis(real_mouse_identifier, mouse_axis_x);
     PreSetAxis(real_mouse_identifier, mouse_axis_y);
     PreSetAxis(touch_identifier, mouse_axis_x);
@@ -97,8 +97,8 @@ void Mouse::UpdateStickInput() {
         last_mouse_change *= maximum_stick_range;
     }
 
-    SetAxis(identifier, mouse_axis_x, last_mouse_change.x);
-    SetAxis(identifier, mouse_axis_y, -last_mouse_change.y);
+    SetAxis(mouse_identifier, mouse_axis_x, last_mouse_change.x);
+    SetAxis(mouse_identifier, mouse_axis_y, -last_mouse_change.y);
 
     // Decay input over time
     const float clamped_length = (std::min)(1.0f, length);
@@ -174,8 +174,8 @@ void Mouse::Move(int x, int y, int center_x, int center_y) {
             Settings::values.mouse_panning_x_sensitivity.GetValue() * default_stick_sensitivity;
         const float y_sensitivity =
             Settings::values.mouse_panning_y_sensitivity.GetValue() * default_stick_sensitivity;
-        SetAxis(identifier, mouse_axis_x, static_cast<float>(mouse_move.x) * x_sensitivity);
-        SetAxis(identifier, mouse_axis_y, static_cast<float>(-mouse_move.y) * y_sensitivity);
+        SetAxis(mouse_identifier, mouse_axis_x, static_cast<float>(mouse_move.x) * x_sensitivity);
+        SetAxis(mouse_identifier, mouse_axis_y, static_cast<float>(-mouse_move.y) * y_sensitivity);
 
         last_motion_change = {
             static_cast<float>(-mouse_move.y) * x_sensitivity,
@@ -196,7 +196,7 @@ void Mouse::TouchMove(f32 touch_x, f32 touch_y) {
 }
 
 void Mouse::PressButton(int x, int y, MouseButton button) {
-    SetButton(identifier, static_cast<int>(button), true);
+    SetButton(mouse_identifier, static_cast<int>(button), true);
 
     // Set initial analog parameters
     mouse_origin = {x, y};
@@ -215,13 +215,13 @@ void Mouse::PressTouchButton(f32 touch_x, f32 touch_y, MouseButton button) {
 }
 
 void Mouse::ReleaseButton(MouseButton button) {
-    SetButton(identifier, static_cast<int>(button), false);
+    SetButton(mouse_identifier, static_cast<int>(button), false);
     SetButton(real_mouse_identifier, static_cast<int>(button), false);
     SetButton(touch_identifier, static_cast<int>(button), false);
 
     if (!IsMousePanningEnabled()) {
-        SetAxis(identifier, mouse_axis_x, 0);
-        SetAxis(identifier, mouse_axis_y, 0);
+        SetAxis(mouse_identifier, mouse_axis_x, 0);
+        SetAxis(mouse_identifier, mouse_axis_y, 0);
     }
 
     last_motion_change.x = 0;
@@ -234,8 +234,8 @@ void Mouse::MouseWheelChange(int x, int y) {
     wheel_position.x += x;
     wheel_position.y += y;
     last_motion_change.z += static_cast<f32>(y);
-    SetAxis(identifier, wheel_axis_x, static_cast<f32>(wheel_position.x));
-    SetAxis(identifier, wheel_axis_y, static_cast<f32>(wheel_position.y));
+    SetAxis(mouse_identifier, wheel_axis_x, static_cast<f32>(wheel_position.x));
+    SetAxis(mouse_identifier, wheel_axis_y, static_cast<f32>(wheel_position.y));
 }
 
 void Mouse::ReleaseAllButtons() {

src/input_common/drivers/touch_screen.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -6,14 +9,14 @@
 
 namespace InputCommon {
 
-constexpr PadIdentifier identifier = {
+constexpr PadIdentifier touch_screen_identifier = {
     .guid = Common::UUID{},
     .port = 0,
     .pad = 0,
 };
 
 TouchScreen::TouchScreen(std::string input_engine_) : InputEngine(std::move(input_engine_)) {
-    PreSetController(identifier);
+    PreSetController(touch_screen_identifier);
     ReleaseAllTouch();
 }
 
@@ -26,9 +29,9 @@ void TouchScreen::TouchMoved(float x, float y, std::size_t finger_id) {
     }
     const auto i = index.value();
     fingers[i].is_active = true;
-    SetButton(identifier, static_cast<int>(i), true);
-    SetAxis(identifier, static_cast<int>(i * 2), x);
-    SetAxis(identifier, static_cast<int>(i * 2 + 1), y);
+    SetButton(touch_screen_identifier, static_cast<int>(i), true);
+    SetAxis(touch_screen_identifier, static_cast<int>(i * 2), x);
+    SetAxis(touch_screen_identifier, static_cast<int>(i * 2 + 1), y);
 }
 
 void TouchScreen::TouchPressed(float x, float y, std::size_t finger_id) {
@@ -55,9 +58,9 @@ void TouchScreen::TouchReleased(std::size_t finger_id) {
     }
     const auto i = index.value();
     fingers[i].is_enabled = false;
-    SetButton(identifier, static_cast<int>(i), false);
-    SetAxis(identifier, static_cast<int>(i * 2), 0.0f);
-    SetAxis(identifier, static_cast<int>(i * 2 + 1), 0.0f);
+    SetButton(touch_screen_identifier, static_cast<int>(i), false);
+    SetAxis(touch_screen_identifier, static_cast<int>(i * 2), 0.0f);
+    SetAxis(touch_screen_identifier, static_cast<int>(i * 2 + 1), 0.0f);
 }
 
 std::optional<std::size_t> TouchScreen::GetIndexFromFingerId(std::size_t finger_id) const {

src/input_common/drivers/udp_client.cpp

@@ -591,7 +591,7 @@ void TestCommunication(const std::string& host, u16 port,
 }
 
 CalibrationConfigurationJob::CalibrationConfigurationJob(
-    const std::string& host, u16 port, std::function<void(Status)> status_callback,
+    const std::string& host, u16 port, std::function<void(CalibrationStatus)> status_callback,
     std::function<void(u16, u16, u16, u16)> data_callback) {
 
     std::thread([=, this] {
@@ -600,14 +600,14 @@ CalibrationConfigurationJob::CalibrationConfigurationJob(
         u16 max_x{};
         u16 max_y{};
 
-        Status current_status{Status::Initialized};
+        CalibrationStatus current_status{CalibrationStatus::Initialized};
         SocketCallback callback{[](Response::Version) {}, [](Response::PortInfo) {},
                                 [&](Response::PadData data) {
                                     constexpr u16 CALIBRATION_THRESHOLD = 100;
 
-                                    if (current_status == Status::Initialized) {
+                                    if (current_status == CalibrationStatus::Initialized) {
                                         // Receiving data means the communication is ready now
-                                        current_status = Status::Ready;
+                                        current_status = CalibrationStatus::Ready;
                                         status_callback(current_status);
                                     }
                                     if (data.touch[0].is_active == 0) {
@@ -617,9 +617,9 @@ CalibrationConfigurationJob::CalibrationConfigurationJob(
                                               data.touch[0].y);
                                     min_x = (std::min)(min_x, static_cast<u16>(data.touch[0].x));
                                     min_y = (std::min)(min_y, static_cast<u16>(data.touch[0].y));
-                                    if (current_status == Status::Ready) {
+                                    if (current_status == CalibrationStatus::Ready) {
                                         // First touch - min data (min_x/min_y)
-                                        current_status = Status::Stage1Completed;
+                                        current_status = CalibrationStatus::Stage1Completed;
                                         status_callback(current_status);
                                     }
                                     if (data.touch[0].x - min_x > CALIBRATION_THRESHOLD &&
@@ -628,7 +628,7 @@ CalibrationConfigurationJob::CalibrationConfigurationJob(
                                         // configuration
                                         max_x = data.touch[0].x;
                                         max_y = data.touch[0].y;
-                                        current_status = Status::Completed;
+                                        current_status = CalibrationStatus::Completed;
                                         data_callback(min_x, min_y, max_x, max_y);
                                         status_callback(current_status);
 

src/input_common/drivers/udp_client.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: 2018 Citra Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -163,7 +166,7 @@ private:
 /// An async job allowing configuration of the touchpad calibration.
 class CalibrationConfigurationJob {
 public:
-    enum class Status {
+    enum class CalibrationStatus {
         Initialized,
         Ready,
         Stage1Completed,
@@ -176,7 +179,7 @@ public:
      * @param data_callback Called when calibration data is ready
      */
     explicit CalibrationConfigurationJob(const std::string& host, u16 port,
-                                         std::function<void(Status)> status_callback,
+                                         std::function<void(CalibrationStatus)> status_callback,
                                          std::function<void(u16, u16, u16, u16)> data_callback);
     ~CalibrationConfigurationJob();
     void Stop();

src/input_common/drivers/virtual_amiibo.cpp

@@ -15,7 +15,7 @@
 #include "input_common/drivers/virtual_amiibo.h"
 
 namespace InputCommon {
-constexpr PadIdentifier identifier = {
+constexpr PadIdentifier virtual_amiibo_identifier = {
     .guid = Common::UUID{},
     .port = 0,
     .pad = 0,
@@ -228,13 +228,13 @@ VirtualAmiibo::Info VirtualAmiibo::LoadAmiibo(std::span<u8> data) {
     status.state = Common::Input::NfcState::NewAmiibo,
     memcpy(nfc_data.data(), data.data(), data.size_bytes());
     memcpy(status.uuid.data(), nfc_data.data(), status.uuid_length);
-    SetNfc(identifier, status);
+    SetNfc(virtual_amiibo_identifier, status);
     return Info::Success;
 }
 
 VirtualAmiibo::Info VirtualAmiibo::ReloadAmiibo() {
     if (state == State::TagNearby) {
-        SetNfc(identifier, status);
+        SetNfc(virtual_amiibo_identifier, status);
         return Info::Success;
     }
 
@@ -248,7 +248,7 @@ VirtualAmiibo::Info VirtualAmiibo::CloseAmiibo() {
 
     state = State::WaitingForAmiibo;
     status.state = Common::Input::NfcState::AmiiboRemoved;
-    SetNfc(identifier, status);
+    SetNfc(virtual_amiibo_identifier, status);
     status.tag_type = 0;
     return Info::Success;
 }

src/network/packet.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -5,6 +8,7 @@
 
 #include <array>
 #include <vector>
+#include <string>
 #include "common/common_types.h"
 
 namespace Network {
@@ -118,26 +122,21 @@ private:
 
 template <typename T>
 Packet& Packet::Read(std::vector<T>& out_data) {
-    // First extract the size
     u32 size = 0;
     Read(size);
     out_data.resize(size);
 
-    // Then extract the data
-    for (std::size_t i = 0; i < out_data.size(); ++i) {
-        T character;
-        Read(character);
-        out_data[i] = character;
+    for (auto& elem : out_data) {
+        Read(elem);
     }
+
     return *this;
 }
 
 template <typename T, std::size_t S>
 Packet& Packet::Read(std::array<T, S>& out_data) {
-    for (std::size_t i = 0; i < out_data.size(); ++i) {
-        T character;
-        Read(character);
-        out_data[i] = character;
+    for (auto& elem : out_data) {
+        Read(elem);
     }
     return *this;
 }

src/network/room.cpp

@@ -832,7 +832,7 @@ void Room::RoomImpl::HandleProxyPacket(const ENetEvent* event) {
 
     in_packet.IgnoreBytes(sizeof(u8)); // Protocol
 
-    bool broadcast;
+    bool broadcast = false;
     in_packet.Read(broadcast); // Broadcast
 
     Packet out_packet;
@@ -886,7 +886,7 @@ void Room::RoomImpl::HandleLdnPacket(const ENetEvent* event) {
     IPv4Address remote_ip;
     in_packet.Read(remote_ip); // Remote IP
 
-    bool broadcast;
+    bool broadcast = false;
     in_packet.Read(broadcast); // Broadcast
 
     Packet out_packet;

src/qt_common/discord/discord_impl.cpp

@@ -10,6 +10,7 @@
 #include <QEventLoop>
 #include <boost/algorithm/string/replace.hpp>
 #include <httplib.h>
+#undef INVALID_SOCKET
 
 #include <discord_rpc.h>
 #include <fmt/format.h>

src/shader_recompiler/backend/glasm/emit_glasm_context_get_set.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -45,11 +48,6 @@ void GetCbuf(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding, ScalarU
     }
 }
 
-bool IsInputArray(Stage stage) {
-    return stage == Stage::Geometry || stage == Stage::TessellationControl ||
-           stage == Stage::TessellationEval;
-}
-
 std::string VertexIndex(EmitContext& ctx, ScalarU32 vertex) {
     return IsInputArray(ctx.stage) ? fmt::format("[{}]", vertex) : "";
 }

src/shader_recompiler/backend/glasm/emit_glasm_instructions.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
@@ -7,6 +7,7 @@
 #pragma once
 
 #include "common/common_types.h"
+#include "shader_recompiler/stage.h"
 #include "shader_recompiler/backend/glasm/reg_alloc.h"
 
 namespace Shader::IR {
@@ -18,6 +19,11 @@ class Value;
 
 namespace Shader::Backend::GLASM {
 
+[[nodiscard]] inline bool IsInputArray(Stage stage) {
+    return stage == Stage::Geometry || stage == Stage::TessellationControl
+        || stage == Stage::TessellationEval;
+}
+
 class EmitContext;
 
 // Microinstruction emitters

src/shader_recompiler/backend/glasm/emit_glasm_not_implemented.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -7,94 +10,92 @@
 
 namespace Shader::Backend::GLASM {
 
-#define NotImplemented() throw NotImplementedException("GLASM instruction {}", __LINE__)
-
 void EmitGetRegister(EmitContext& ctx) {
-    NotImplemented();
+    throw NotImplementedException("GLASM instruction {}", __LINE__);
 }
 
 void EmitSetRegister(EmitContext& ctx) {
-    NotImplemented();
+    throw NotImplementedException("GLASM instruction {}", __LINE__);
 }
 
 void EmitGetPred(EmitContext& ctx) {
-    NotImplemented();
+    throw NotImplementedException("GLASM instruction {}", __LINE__);
 }
 
 void EmitSetPred(EmitContext& ctx) {
-    NotImplemented();
+    throw NotImplementedException("GLASM instruction {}", __LINE__);
 }
 
 void EmitSetGotoVariable(EmitContext& ctx) {
-    NotImplemented();
+    throw NotImplementedException("GLASM instruction {}", __LINE__);
 }
 
 void EmitGetGotoVariable(EmitContext& ctx) {
-    NotImplemented();
+    throw NotImplementedException("GLASM instruction {}", __LINE__);
 }
 
 void EmitSetIndirectBranchVariable(EmitContext& ctx) {
-    NotImplemented();
+    throw NotImplementedException("GLASM instruction {}", __LINE__);
 }
 
 void EmitGetIndirectBranchVariable(EmitContext& ctx) {
-    NotImplemented();
+    throw NotImplementedException("GLASM instruction {}", __LINE__);
 }
 
 void EmitGetZFlag(EmitContext& ctx) {
-    NotImplemented();
+    throw NotImplementedException("GLASM instruction {}", __LINE__);
 }
 
 void EmitGetSFlag(EmitContext& ctx) {
-    NotImplemented();
+    throw NotImplementedException("GLASM instruction {}", __LINE__);
 }
 
 void EmitGetCFlag(EmitContext& ctx) {
-    NotImplemented();
+    throw NotImplementedException("GLASM instruction {}", __LINE__);
 }
 
 void EmitGetOFlag(EmitContext& ctx) {
-    NotImplemented();
+    throw NotImplementedException("GLASM instruction {}", __LINE__);
 }
 
 void EmitSetZFlag(EmitContext& ctx) {
-    NotImplemented();
+    throw NotImplementedException("GLASM instruction {}", __LINE__);
 }
 
 void EmitSetSFlag(EmitContext& ctx) {
-    NotImplemented();
+    throw NotImplementedException("GLASM instruction {}", __LINE__);
 }
 
 void EmitSetCFlag(EmitContext& ctx) {
-    NotImplemented();
+    throw NotImplementedException("GLASM instruction {}", __LINE__);
 }
 
 void EmitSetOFlag(EmitContext& ctx) {
-    NotImplemented();
+    throw NotImplementedException("GLASM instruction {}", __LINE__);
 }
 
 void EmitGetZeroFromOp(EmitContext& ctx) {
-    NotImplemented();
+    throw NotImplementedException("GLASM instruction {}", __LINE__);
 }
 
 void EmitGetSignFromOp(EmitContext& ctx) {
-    NotImplemented();
+    throw NotImplementedException("GLASM instruction {}", __LINE__);
 }
 
 void EmitGetCarryFromOp(EmitContext& ctx) {
-    NotImplemented();
+    throw NotImplementedException("GLASM instruction {}", __LINE__);
 }
 
 void EmitGetOverflowFromOp(EmitContext& ctx) {
-    NotImplemented();
+    throw NotImplementedException("GLASM instruction {}", __LINE__);
 }
 
 void EmitGetSparseFromOp(EmitContext& ctx) {
-    NotImplemented();
+    throw NotImplementedException("GLASM instruction {}", __LINE__);
 }
 
 void EmitGetInBoundsFromOp(EmitContext& ctx) {
-    NotImplemented();
+    throw NotImplementedException("GLASM instruction {}", __LINE__);
 }
 
 } // namespace Shader::Backend::GLASM

src/shader_recompiler/backend/glasm/glasm_emit_context.cpp

@@ -1,8 +1,12 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "shader_recompiler/backend/bindings.h"
 #include "shader_recompiler/backend/glasm/emit_glasm.h"
+#include "shader_recompiler/backend/glasm/emit_glasm_instructions.h"
 #include "shader_recompiler/backend/glasm/glasm_emit_context.h"
 #include "shader_recompiler/frontend/ir/program.h"
 #include "shader_recompiler/profile.h"
@@ -21,11 +25,6 @@ std::string_view InterpDecorator(Interpolation interp) {
     }
     throw InvalidArgument("Invalid interpolation {}", interp);
 }
-
-bool IsInputArray(Stage stage) {
-    return stage == Stage::Geometry || stage == Stage::TessellationControl ||
-           stage == Stage::TessellationEval;
-}
 } // Anonymous namespace
 
 EmitContext::EmitContext(IR::Program& program, Bindings& bindings, const Profile& profile_,

src/shader_recompiler/backend/glsl/emit_glsl_composite.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -9,14 +12,13 @@
 
 namespace Shader::Backend::GLSL {
 namespace {
-constexpr std::string_view SWIZZLE{"xyzw"};
 void CompositeInsert(EmitContext& ctx, std::string_view result, std::string_view composite,
                      std::string_view object, u32 index) {
     if (result == composite) {
         // The result is aliased with the composite
-        ctx.Add("{}.{}={};", composite, SWIZZLE[index], object);
+        ctx.Add("{}.{}={};", composite, "xyzw"[index], object);
     } else {
-        ctx.Add("{}={};{}.{}={};", result, composite, result, SWIZZLE[index], object);
+        ctx.Add("{}={};{}.{}={};", result, composite, result, "xyzw"[index], object);
     }
 }
 } // Anonymous namespace
@@ -38,17 +40,17 @@ void EmitCompositeConstructU32x4(EmitContext& ctx, IR::Inst& inst, std::string_v
 
 void EmitCompositeExtractU32x2(EmitContext& ctx, IR::Inst& inst, std::string_view composite,
                                u32 index) {
-    ctx.AddU32("{}={}.{};", inst, composite, SWIZZLE[index]);
+    ctx.AddU32("{}={}.{};", inst, composite, "xyzw"[index]);
 }
 
 void EmitCompositeExtractU32x3(EmitContext& ctx, IR::Inst& inst, std::string_view composite,
                                u32 index) {
-    ctx.AddU32("{}={}.{};", inst, composite, SWIZZLE[index]);
+    ctx.AddU32("{}={}.{};", inst, composite, "xyzw"[index]);
 }
 
 void EmitCompositeExtractU32x4(EmitContext& ctx, IR::Inst& inst, std::string_view composite,
                                u32 index) {
-    ctx.AddU32("{}={}.{};", inst, composite, SWIZZLE[index]);
+    ctx.AddU32("{}={}.{};", inst, composite, "xyzw"[index]);
 }
 
 void EmitCompositeInsertU32x2(EmitContext& ctx, IR::Inst& inst, std::string_view composite,
@@ -146,17 +148,17 @@ void EmitCompositeConstructF32x4(EmitContext& ctx, IR::Inst& inst, std::string_v
 
 void EmitCompositeExtractF32x2(EmitContext& ctx, IR::Inst& inst, std::string_view composite,
                                u32 index) {
-    ctx.AddF32("{}={}.{};", inst, composite, SWIZZLE[index]);
+    ctx.AddF32("{}={}.{};", inst, composite, "xyzw"[index]);
 }
 
 void EmitCompositeExtractF32x3(EmitContext& ctx, IR::Inst& inst, std::string_view composite,
                                u32 index) {
-    ctx.AddF32("{}={}.{};", inst, composite, SWIZZLE[index]);
+    ctx.AddF32("{}={}.{};", inst, composite, "xyzw"[index]);
 }
 
 void EmitCompositeExtractF32x4(EmitContext& ctx, IR::Inst& inst, std::string_view composite,
                                u32 index) {
-    ctx.AddF32("{}={}.{};", inst, composite, SWIZZLE[index]);
+    ctx.AddF32("{}={}.{};", inst, composite, "xyzw"[index]);
 }
 
 void EmitCompositeInsertF32x2(EmitContext& ctx, IR::Inst& inst, std::string_view composite,
@@ -203,16 +205,16 @@ void EmitCompositeExtractF64x4([[maybe_unused]] EmitContext& ctx) {
 
 void EmitCompositeInsertF64x2(EmitContext& ctx, std::string_view composite, std::string_view object,
                               u32 index) {
-    ctx.Add("{}.{}={};", composite, SWIZZLE[index], object);
+    ctx.Add("{}.{}={};", composite, "xyzw"[index], object);
 }
 
 void EmitCompositeInsertF64x3(EmitContext& ctx, std::string_view composite, std::string_view object,
                               u32 index) {
-    ctx.Add("{}.{}={};", composite, SWIZZLE[index], object);
+    ctx.Add("{}.{}={};", composite, "xyzw"[index], object);
 }
 
 void EmitCompositeInsertF64x4(EmitContext& ctx, std::string_view composite, std::string_view object,
                               u32 index) {
-    ctx.Add("{}.{}={};", composite, SWIZZLE[index], object);
+    ctx.Add("{}.{}={};", composite, "xyzw"[index], object);
 }
 } // namespace Shader::Backend::GLSL

src/shader_recompiler/backend/glsl/emit_glsl_context_get_set.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -11,14 +14,13 @@
 
 namespace Shader::Backend::GLSL {
 namespace {
-constexpr char SWIZZLE[]{"xyzw"};
 
 u32 CbufIndex(u32 offset) {
     return (offset / 4) % 4;
 }
 
 char OffsetSwizzle(u32 offset) {
-    return SWIZZLE[CbufIndex(offset)];
+    return "xyzw"[CbufIndex(offset)];
 }
 
 bool IsInputArray(Stage stage) {
@@ -30,10 +32,6 @@ std::string InputVertexIndex(EmitContext& ctx, std::string_view vertex) {
     return IsInputArray(ctx.stage) ? fmt::format("[{}]", vertex) : "";
 }
 
-std::string_view OutputVertexIndex(EmitContext& ctx) {
-    return ctx.stage == Stage::TessellationControl ? "[gl_InvocationID]" : "";
-}
-
 std::string ChooseCbuf(EmitContext& ctx, const IR::Value& binding, std::string_view index) {
     if (binding.IsImmediate()) {
         return fmt::format("{}_cbuf{}[{}]", ctx.stage_name, binding.U32(), index);
@@ -279,7 +277,7 @@ void EmitSetAttribute(EmitContext& ctx, IR::Attribute attr, std::string_view val
         const u32 index{IR::GenericAttributeIndex(attr)};
         const u32 attr_element{IR::GenericAttributeElement(attr)};
         const GenericElementInfo& info{ctx.output_generics.at(index).at(attr_element)};
-        const auto output_decorator{OutputVertexIndex(ctx)};
+        const auto output_decorator = ctx.stage == Stage::TessellationControl ? "[gl_InvocationID]" : "";
         if (info.num_components == 1) {
             ctx.Add("{}{}={};", info.name, output_decorator, value);
         } else {

src/shader_recompiler/backend/glsl/emit_glsl_instructions.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project

src/shader_recompiler/backend/glsl/emit_glsl_memory.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -10,14 +13,13 @@
 
 namespace Shader::Backend::GLSL {
 namespace {
-constexpr char cas_loop[]{"for(;;){{uint old_value={};uint "
-                          "cas_result=atomicCompSwap({},old_value,bitfieldInsert({},{},{},{}));"
-                          "if(cas_result==old_value){{break;}}}}"};
-
 void SsboWriteCas(EmitContext& ctx, const IR::Value& binding, std::string_view offset_var,
                   std::string_view value, std::string_view bit_offset, u32 num_bits) {
     const auto ssbo{fmt::format("{}_ssbo{}[{}>>2]", ctx.stage_name, binding.U32(), offset_var)};
-    ctx.Add(cas_loop, ssbo, ssbo, ssbo, value, bit_offset, num_bits);
+    ctx.Add(
+        "for(;;){{uint old_value={};uint "
+        "cas_result=atomicCompSwap({},old_value,bitfieldInsert({},{},{},{}));"
+        "if(cas_result==old_value){{break;}}}}", ssbo, ssbo, ssbo, value, bit_offset, num_bits);
 }
 } // Anonymous namespace
 

src/shader_recompiler/backend/glsl/emit_glsl_shared_memory.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -7,14 +10,13 @@
 
 namespace Shader::Backend::GLSL {
 namespace {
-constexpr char cas_loop[]{"for(;;){{uint old_value={};uint "
-                          "cas_result=atomicCompSwap({},old_value,bitfieldInsert({},{},{},{}));"
-                          "if(cas_result==old_value){{break;}}}}"};
-
 void SharedWriteCas(EmitContext& ctx, std::string_view offset, std::string_view value,
                     std::string_view bit_offset, u32 num_bits) {
     const auto smem{fmt::format("smem[{}>>2]", offset)};
-    ctx.Add(cas_loop, smem, smem, smem, value, bit_offset, num_bits);
+    ctx.Add(
+        "for(;;){{uint old_value={};uint "
+        "cas_result=atomicCompSwap({},old_value,bitfieldInsert({},{},{},{}));"
+        "if(cas_result==old_value){{break;}}}}", smem, smem, smem, value, bit_offset, num_bits);
 }
 } // Anonymous namespace
 

src/shader_recompiler/backend/glsl/emit_glsl_special.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -9,9 +12,6 @@
 
 namespace Shader::Backend::GLSL {
 namespace {
-std::string_view OutputVertexIndex(EmitContext& ctx) {
-    return ctx.stage == Stage::TessellationControl ? "[gl_InvocationID]" : "";
-}
 
 void InitializeOutputVaryings(EmitContext& ctx) {
     if (ctx.uses_geometry_passthrough) {
@@ -25,7 +25,7 @@ void InitializeOutputVaryings(EmitContext& ctx) {
             continue;
         }
         const auto& info_array{ctx.output_generics.at(index)};
-        const auto output_decorator{OutputVertexIndex(ctx)};
+        const auto output_decorator = ctx.stage == Stage::TessellationControl ? "[gl_InvocationID]" : "";
         size_t element{};
         while (element < info_array.size()) {
             const auto& info{info_array.at(element)};

src/shader_recompiler/backend/spirv/emit_spirv_floating_point.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
@@ -9,7 +9,7 @@
 
 namespace Shader::Backend::SPIRV {
 namespace {
-Id Decorate(EmitContext& ctx, IR::Inst* inst, Id op) {
+Id DecorateNoContraction(EmitContext& ctx, IR::Inst* inst, Id op) {
     const auto flags{inst->Flags<IR::FpControl>()};
     if (flags.no_contraction) {
         ctx.Decorate(op, spv::Decoration::NoContraction);
@@ -61,27 +61,27 @@ Id EmitFPAbs64(EmitContext& ctx, Id value) {
 }
 
 Id EmitFPAdd16(EmitContext& ctx, IR::Inst* inst, Id a, Id b) {
-    return Decorate(ctx, inst, ctx.OpFAdd(ctx.F16[1], a, b));
+    return DecorateNoContraction(ctx, inst, ctx.OpFAdd(ctx.F16[1], a, b));
 }
 
 Id EmitFPAdd32(EmitContext& ctx, IR::Inst* inst, Id a, Id b) {
-    return Decorate(ctx, inst, ctx.OpFAdd(ctx.F32[1], a, b));
+    return DecorateNoContraction(ctx, inst, ctx.OpFAdd(ctx.F32[1], a, b));
 }
 
 Id EmitFPAdd64(EmitContext& ctx, IR::Inst* inst, Id a, Id b) {
-    return Decorate(ctx, inst, ctx.OpFAdd(ctx.F64[1], a, b));
+    return DecorateNoContraction(ctx, inst, ctx.OpFAdd(ctx.F64[1], a, b));
 }
 
 Id EmitFPFma16(EmitContext& ctx, IR::Inst* inst, Id a, Id b, Id c) {
-    return Decorate(ctx, inst, ctx.OpFma(ctx.F16[1], a, b, c));
+    return DecorateNoContraction(ctx, inst, ctx.OpFma(ctx.F16[1], a, b, c));
 }
 
 Id EmitFPFma32(EmitContext& ctx, IR::Inst* inst, Id a, Id b, Id c) {
-    return Decorate(ctx, inst, ctx.OpFma(ctx.F32[1], a, b, c));
+    return DecorateNoContraction(ctx, inst, ctx.OpFma(ctx.F32[1], a, b, c));
 }
 
 Id EmitFPFma64(EmitContext& ctx, IR::Inst* inst, Id a, Id b, Id c) {
-    return Decorate(ctx, inst, ctx.OpFma(ctx.F64[1], a, b, c));
+    return DecorateNoContraction(ctx, inst, ctx.OpFma(ctx.F64[1], a, b, c));
 }
 
 Id EmitFPMax32(EmitContext& ctx, Id a, Id b) {
@@ -101,15 +101,15 @@ Id EmitFPMin64(EmitContext& ctx, Id a, Id b) {
 }
 
 Id EmitFPMul16(EmitContext& ctx, IR::Inst* inst, Id a, Id b) {
-    return Decorate(ctx, inst, ctx.OpFMul(ctx.F16[1], a, b));
+    return DecorateNoContraction(ctx, inst, ctx.OpFMul(ctx.F16[1], a, b));
 }
 
 Id EmitFPMul32(EmitContext& ctx, IR::Inst* inst, Id a, Id b) {
-    return Decorate(ctx, inst, ctx.OpFMul(ctx.F32[1], a, b));
+    return DecorateNoContraction(ctx, inst, ctx.OpFMul(ctx.F32[1], a, b));
 }
 
 Id EmitFPMul64(EmitContext& ctx, IR::Inst* inst, Id a, Id b) {
-    return Decorate(ctx, inst, ctx.OpFMul(ctx.F64[1], a, b));
+    return DecorateNoContraction(ctx, inst, ctx.OpFMul(ctx.F64[1], a, b));
 }
 
 Id EmitFPNeg16(EmitContext& ctx, Id value) {

src/shader_recompiler/backend/spirv/emit_spirv_image.cpp

@@ -243,7 +243,7 @@ bool IsTextureMsaa(EmitContext& ctx, const IR::TextureInstInfo& info) {
     return ctx.textures.at(info.descriptor_index).is_multisample;
 }
 
-Id Decorate(EmitContext& ctx, IR::Inst* inst, Id sample) {
+Id DecorateRelaxedPrecision(EmitContext& ctx, IR::Inst* inst, Id sample) {
     const auto info{inst->Flags<IR::TextureInstInfo>()};
     if (info.relaxed_precision != 0) {
         ctx.Decorate(sample, spv::Decoration::RelaxedPrecision);
@@ -256,14 +256,14 @@ Id Emit(MethodPtrType sparse_ptr, MethodPtrType non_sparse_ptr, EmitContext& ctx
         Id result_type, Args&&... args) {
     IR::Inst* const sparse{inst->GetAssociatedPseudoOperation(IR::Opcode::GetSparseFromOp)};
     if (!sparse) {
-        return Decorate(ctx, inst, (ctx.*non_sparse_ptr)(result_type, std::forward<Args>(args)...));
+        return DecorateRelaxedPrecision(ctx, inst, (ctx.*non_sparse_ptr)(result_type, std::forward<Args>(args)...));
     }
     const Id struct_type{ctx.TypeStruct(ctx.U32[1], result_type)};
     const Id sample{(ctx.*sparse_ptr)(struct_type, std::forward<Args>(args)...)};
     const Id resident_code{ctx.OpCompositeExtract(ctx.U32[1], sample, 0U)};
     sparse->SetDefinition(ctx.OpImageSparseTexelsResident(ctx.U1, resident_code));
     sparse->Invalidate();
-    Decorate(ctx, inst, sample);
+    DecorateRelaxedPrecision(ctx, inst, sample);
     return ctx.OpCompositeExtract(result_type, sample, 1U);
 }
 

src/shader_recompiler/backend/spirv/emit_spirv_image_atomic.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -17,14 +20,13 @@ Id Image(EmitContext& ctx, IR::TextureInstInfo info) {
     }
 }
 
-std::pair<Id, Id> AtomicArgs(EmitContext& ctx) {
+std::pair<Id, Id> AtomicImageArgs(EmitContext& ctx) {
     const Id scope{ctx.Const(static_cast<u32>(spv::Scope::Device))};
     const Id semantics{ctx.u32_zero_value};
     return {scope, semantics};
 }
 
-Id ImageAtomicU32(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords, Id value,
-                  Id (Sirit::Module::*atomic_func)(Id, Id, Id, Id, Id)) {
+Id ImageAtomicU32(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords, Id value, Id (Sirit::Module::*atomic_func)(Id, Id, Id, Id, Id)) {
     if (!index.IsImmediate() || index.U32() != 0) {
         // TODO: handle layers
         throw NotImplementedException("Image indexing");
@@ -32,7 +34,7 @@ Id ImageAtomicU32(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id c
     const auto info{inst->Flags<IR::TextureInstInfo>()};
     const Id image{Image(ctx, info)};
     const Id pointer{ctx.OpImageTexelPointer(ctx.image_u32, image, coords, ctx.Const(0U))};
-    const auto [scope, semantics]{AtomicArgs(ctx)};
+    const auto [scope, semantics] = AtomicImageArgs(ctx);
     return (ctx.*atomic_func)(ctx.U32[1], pointer, scope, semantics, value);
 }
 } // Anonymous namespace

src/shader_recompiler/frontend/maxwell/indirect_branch_table_track.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -12,7 +15,7 @@
 
 namespace Shader::Maxwell {
 namespace {
-union Encoding {
+union EncodingIBTT {
     u64 raw;
     BitField<0, 8, IR::Reg> dest_reg;
     BitField<8, 8, IR::Reg> src_reg;
@@ -45,7 +48,7 @@ std::optional<u64> TrackLDC(Environment& env, Location block_begin, Location& po
 std::optional<u64> TrackSHL(Environment& env, Location block_begin, Location& pos,
                             IR::Reg ldc_reg) {
     return Track(env, block_begin, pos, [ldc_reg](u64 insn, Opcode opcode) {
-        const Encoding shl{insn};
+        const EncodingIBTT shl{insn};
         return opcode == Opcode::SHL_imm && shl.dest_reg == ldc_reg;
     });
 }
@@ -53,7 +56,7 @@ std::optional<u64> TrackSHL(Environment& env, Location block_begin, Location& po
 std::optional<u64> TrackIMNMX(Environment& env, Location block_begin, Location& pos,
                               IR::Reg shl_reg) {
     return Track(env, block_begin, pos, [shl_reg](u64 insn, Opcode opcode) {
-        const Encoding imnmx{insn};
+        const EncodingIBTT imnmx{insn};
         return opcode == Opcode::IMNMX_imm && imnmx.dest_reg == shl_reg;
     });
 }
@@ -66,8 +69,8 @@ std::optional<IndirectBranchTableInfo> TrackIndirectBranchTable(Environment& env
     if (brx_opcode != Opcode::BRX && brx_opcode != Opcode::JMX) {
         throw LogicError("Tracked instruction is not BRX or JMX");
     }
-    const IR::Reg brx_reg{Encoding{brx_insn}.src_reg};
-    const s32 brx_offset{static_cast<s32>(Encoding{brx_insn}.brx_offset)};
+    const IR::Reg brx_reg{EncodingIBTT{brx_insn}.src_reg};
+    const s32 brx_offset{static_cast<s32>(EncodingIBTT{brx_insn}.brx_offset)};
 
     Location pos{brx_pos};
     const std::optional<u64> ldc_insn{TrackLDC(env, block_begin, pos, brx_reg)};
@@ -83,14 +86,14 @@ std::optional<IndirectBranchTableInfo> TrackIndirectBranchTable(Environment& env
     if (!shl_insn) {
         return std::nullopt;
     }
-    const Encoding shl{*shl_insn};
+    const EncodingIBTT shl{*shl_insn};
     const IR::Reg shl_reg{shl.src_reg};
 
     const std::optional<u64> imnmx_insn{TrackIMNMX(env, block_begin, pos, shl_reg)};
     if (!imnmx_insn) {
         return std::nullopt;
     }
-    const Encoding imnmx{*imnmx_insn};
+    const EncodingIBTT imnmx{*imnmx_insn};
     if (imnmx.is_negative != 0) {
         return std::nullopt;
     }

src/shader_recompiler/frontend/maxwell/translate/impl/atomic_operations_global_memory.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
@@ -10,7 +10,7 @@
 
 namespace Shader::Maxwell {
 namespace {
-enum class AtomOp : u64 {
+enum class AtomicGlobalMemoryOp : u64 {
     ADD,
     MIN,
     MAX,
@@ -32,33 +32,33 @@ enum class AtomSize : u64 {
     S64,
 };
 
-IR::U32U64 ApplyIntegerAtomOp(IR::IREmitter& ir, const IR::U32U64& offset, const IR::U32U64& op_b, AtomOp op, AtomSize size) {
+IR::U32U64 ApplyIntegerAtomOp(IR::IREmitter& ir, const IR::U32U64& offset, const IR::U32U64& op_b, AtomicGlobalMemoryOp op, AtomSize size) {
     bool const is_signed = size == AtomSize::S64 || size == AtomSize::S32;
     switch (op) {
-    case AtomOp::ADD:
+    case AtomicGlobalMemoryOp::ADD:
         return ir.GlobalAtomicIAdd(offset, op_b);
-    case AtomOp::MIN:
+    case AtomicGlobalMemoryOp::MIN:
         return ir.GlobalAtomicIMin(offset, op_b, is_signed);
-    case AtomOp::MAX:
+    case AtomicGlobalMemoryOp::MAX:
         return ir.GlobalAtomicIMax(offset, op_b, is_signed);
-    case AtomOp::INC:
+    case AtomicGlobalMemoryOp::INC:
         return ir.GlobalAtomicInc(offset, op_b);
-    case AtomOp::DEC:
+    case AtomicGlobalMemoryOp::DEC:
         return ir.GlobalAtomicDec(offset, op_b);
-    case AtomOp::AND:
+    case AtomicGlobalMemoryOp::AND:
         return ir.GlobalAtomicAnd(offset, op_b);
-    case AtomOp::OR:
+    case AtomicGlobalMemoryOp::OR:
         return ir.GlobalAtomicOr(offset, op_b);
-    case AtomOp::XOR:
+    case AtomicGlobalMemoryOp::XOR:
         return ir.GlobalAtomicXor(offset, op_b);
-    case AtomOp::EXCH:
+    case AtomicGlobalMemoryOp::EXCH:
         return ir.GlobalAtomicExchange(offset, op_b);
     default:
         throw NotImplementedException("Integer Atom Operation {}", op);
     }
 }
 
-IR::Value ApplyFpAtomOp(IR::IREmitter& ir, const IR::U64& offset, const IR::Value& op_b, AtomOp op,
+IR::Value ApplyFpAtomOp(IR::IREmitter& ir, const IR::U64& offset, const IR::Value& op_b, AtomicGlobalMemoryOp op,
                         AtomSize size) {
     static constexpr IR::FpControl f16_control{
         .no_contraction = false,
@@ -71,12 +71,12 @@ IR::Value ApplyFpAtomOp(IR::IREmitter& ir, const IR::U64& offset, const IR::Valu
         .fmz_mode = IR::FmzMode::FTZ,
     };
     switch (op) {
-    case AtomOp::ADD:
+    case AtomicGlobalMemoryOp::ADD:
         return size == AtomSize::F32 ? ir.GlobalAtomicF32Add(offset, op_b, f32_control)
             : ir.GlobalAtomicF16x2Add(offset, op_b, f16_control);
-    case AtomOp::MIN:
+    case AtomicGlobalMemoryOp::MIN:
         return ir.GlobalAtomicF16x2Min(offset, op_b, f16_control);
-    case AtomOp::MAX:
+    case AtomicGlobalMemoryOp::MAX:
         return ir.GlobalAtomicF16x2Max(offset, op_b, f16_control);
     default:
         throw NotImplementedException("FP Atom Operation {}", op);
@@ -112,19 +112,19 @@ IR::U64 AtomOffset(TranslatorVisitor& v, u64 insn) {
 // ADD, INC, DEC for S64 does nothing
 // Only ADD does something for F32
 // Only ADD, MIN and MAX does something for F16x2
-bool AtomOpNotApplicable(AtomSize size, AtomOp op) {
+bool AtomOpNotApplicable(AtomSize size, AtomicGlobalMemoryOp op) {
     // TODO: SAFEADD
     switch (size) {
     case AtomSize::U32:
     case AtomSize::S32:
     case AtomSize::U64:
-        return (op == AtomOp::INC || op == AtomOp::DEC);
+        return (op == AtomicGlobalMemoryOp::INC || op == AtomicGlobalMemoryOp::DEC);
     case AtomSize::S64:
-        return (op == AtomOp::ADD || op == AtomOp::INC || op == AtomOp::DEC);
+        return (op == AtomicGlobalMemoryOp::ADD || op == AtomicGlobalMemoryOp::INC || op == AtomicGlobalMemoryOp::DEC);
     case AtomSize::F32:
-        return op != AtomOp::ADD;
+        return op != AtomicGlobalMemoryOp::ADD;
     case AtomSize::F16x2:
-        return !(op == AtomOp::ADD || op == AtomOp::MIN || op == AtomOp::MAX);
+        return !(op == AtomicGlobalMemoryOp::ADD || op == AtomicGlobalMemoryOp::MIN || op == AtomicGlobalMemoryOp::MAX);
     default:
         return false;
     }
@@ -162,7 +162,7 @@ void StoreResult(TranslatorVisitor& v, IR::Reg dest_reg, const IR::Value& result
 }
 
 IR::Value ApplyAtomOp(TranslatorVisitor& v, IR::Reg operand_reg, const IR::U64& offset,
-                      AtomSize size, AtomOp op) {
+                      AtomSize size, AtomicGlobalMemoryOp op) {
     switch (size) {
     case AtomSize::U32:
     case AtomSize::S32:
@@ -180,7 +180,7 @@ IR::Value ApplyAtomOp(TranslatorVisitor& v, IR::Reg operand_reg, const IR::U64&
 }
 
 void GlobalAtomic(TranslatorVisitor& v, IR::Reg dest_reg, IR::Reg operand_reg,
-                  const IR::U64& offset, AtomSize size, AtomOp op, bool write_dest) {
+                  const IR::U64& offset, AtomSize size, AtomicGlobalMemoryOp op, bool write_dest) {
     IR::Value result = AtomOpNotApplicable(size, op)
         ? LoadGlobal(v.ir, offset, size)
         : ApplyAtomOp(v, operand_reg, offset, size, op);
@@ -195,7 +195,7 @@ void TranslatorVisitor::ATOM(u64 insn) {
         BitField<0, 8, IR::Reg> dest_reg;
         BitField<20, 8, IR::Reg> operand_reg;
         BitField<49, 3, AtomSize> size;
-        BitField<52, 4, AtomOp> op;
+        BitField<52, 4, AtomicGlobalMemoryOp> op;
     } const atom{insn};
     const IR::U64 offset{AtomOffset(*this, insn)};
     GlobalAtomic(*this, atom.dest_reg, atom.operand_reg, offset, atom.size, atom.op, true);
@@ -206,7 +206,7 @@ void TranslatorVisitor::RED(u64 insn) {
         u64 raw;
         BitField<0, 8, IR::Reg> operand_reg;
         BitField<20, 3, AtomSize> size;
-        BitField<23, 3, AtomOp> op;
+        BitField<23, 3, AtomicGlobalMemoryOp> op;
     } const red{insn};
     const IR::U64 offset{AtomOffset(*this, insn)};
     GlobalAtomic(*this, IR::Reg::RZ, red.operand_reg, offset, red.size, red.op, true);

src/shader_recompiler/frontend/maxwell/translate/impl/atomic_operations_shared_memory.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -7,7 +10,7 @@
 
 namespace Shader::Maxwell {
 namespace {
-enum class AtomOp : u64 {
+enum class AtomicSharedMemoryOp : u64 {
     ADD,
     MIN,
     MAX,
@@ -25,26 +28,25 @@ enum class AtomsSize : u64 {
     U64,
 };
 
-IR::U32U64 ApplyAtomsOp(IR::IREmitter& ir, const IR::U32& offset, const IR::U32U64& op_b, AtomOp op,
-                        bool is_signed) {
+IR::U32U64 ApplyAtomsOp(IR::IREmitter& ir, const IR::U32& offset, const IR::U32U64& op_b, AtomicSharedMemoryOp op, bool is_signed) {
     switch (op) {
-    case AtomOp::ADD:
+    case AtomicSharedMemoryOp::ADD:
         return ir.SharedAtomicIAdd(offset, op_b);
-    case AtomOp::MIN:
+    case AtomicSharedMemoryOp::MIN:
         return ir.SharedAtomicIMin(offset, op_b, is_signed);
-    case AtomOp::MAX:
+    case AtomicSharedMemoryOp::MAX:
         return ir.SharedAtomicIMax(offset, op_b, is_signed);
-    case AtomOp::INC:
+    case AtomicSharedMemoryOp::INC:
         return ir.SharedAtomicInc(offset, op_b);
-    case AtomOp::DEC:
+    case AtomicSharedMemoryOp::DEC:
         return ir.SharedAtomicDec(offset, op_b);
-    case AtomOp::AND:
+    case AtomicSharedMemoryOp::AND:
         return ir.SharedAtomicAnd(offset, op_b);
-    case AtomOp::OR:
+    case AtomicSharedMemoryOp::OR:
         return ir.SharedAtomicOr(offset, op_b);
-    case AtomOp::XOR:
+    case AtomicSharedMemoryOp::XOR:
         return ir.SharedAtomicXor(offset, op_b);
-    case AtomOp::EXCH:
+    case AtomicSharedMemoryOp::EXCH:
         return ir.SharedAtomicExchange(offset, op_b);
     default:
         throw NotImplementedException("Integer Atoms Operation {}", op);
@@ -87,11 +89,11 @@ void TranslatorVisitor::ATOMS(u64 insn) {
         BitField<8, 8, IR::Reg> addr_reg;
         BitField<20, 8, IR::Reg> src_reg_b;
         BitField<28, 2, AtomsSize> size;
-        BitField<52, 4, AtomOp> op;
+        BitField<52, 4, AtomicSharedMemoryOp> op;
     } const atoms{insn};
 
     const bool size_64{atoms.size == AtomsSize::U64};
-    if (size_64 && atoms.op != AtomOp::EXCH) {
+    if (size_64 && atoms.op != AtomicSharedMemoryOp::EXCH) {
         throw NotImplementedException("64-bit Atoms Operation {}", atoms.op.Value());
     }
     const bool is_signed{atoms.size == AtomsSize::S32};

src/shader_recompiler/frontend/maxwell/translate/impl/floating_point_conversion_floating_point.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -6,7 +9,7 @@
 
 namespace Shader::Maxwell {
 namespace {
-enum class FloatFormat : u64 {
+enum class FloatConversionFormat : u64 {
     F16 = 1,
     F32 = 2,
     F64 = 3,
@@ -21,13 +24,13 @@ enum class RoundingOp : u64 {
     Trunc = 11,
 };
 
-[[nodiscard]] u32 WidthSize(FloatFormat width) {
+[[nodiscard]] u32 WidthSize(FloatConversionFormat width) {
     switch (width) {
-    case FloatFormat::F16:
+    case FloatConversionFormat::F16:
         return 16;
-    case FloatFormat::F32:
+    case FloatConversionFormat::F32:
         return 32;
-    case FloatFormat::F64:
+    case FloatConversionFormat::F64:
         return 64;
     default:
         throw NotImplementedException("Invalid width {}", width);
@@ -44,8 +47,8 @@ void F2F(TranslatorVisitor& v, u64 insn, const IR::F16F32F64& src_a, bool abs) {
         BitField<50, 1, u64> sat;
         BitField<39, 4, u64> rounding_op;
         BitField<39, 2, FpRounding> rounding;
-        BitField<10, 2, FloatFormat> src_size;
-        BitField<8, 2, FloatFormat> dst_size;
+        BitField<10, 2, FloatConversionFormat> src_size;
+        BitField<8, 2, FloatConversionFormat> dst_size;
 
         [[nodiscard]] RoundingOp RoundingOperation() const {
             constexpr u64 rounding_mask = 0x0B;
@@ -59,7 +62,7 @@ void F2F(TranslatorVisitor& v, u64 insn, const IR::F16F32F64& src_a, bool abs) {
 
     IR::F16F32F64 input{v.ir.FPAbsNeg(src_a, abs, f2f.neg != 0)};
 
-    const bool any_fp64{f2f.src_size == FloatFormat::F64 || f2f.dst_size == FloatFormat::F64};
+    const bool any_fp64{f2f.src_size == FloatConversionFormat::F64 || f2f.dst_size == FloatConversionFormat::F64};
     IR::FpControl fp_control{
         .no_contraction = false,
         .rounding = IR::FpRounding::DontCare,
@@ -74,13 +77,13 @@ void F2F(TranslatorVisitor& v, u64 insn, const IR::F16F32F64& src_a, bool abs) {
         case RoundingOp::Pass:
             // Make sure NANs are handled properly
             switch (f2f.src_size) {
-            case FloatFormat::F16:
+            case FloatConversionFormat::F16:
                 input = v.ir.FPAdd(input, v.ir.FPConvert(16, v.ir.Imm32(0.0f)), fp_control);
                 break;
-            case FloatFormat::F32:
+            case FloatConversionFormat::F32:
                 input = v.ir.FPAdd(input, v.ir.Imm32(0.0f), fp_control);
                 break;
-            case FloatFormat::F64:
+            case FloatConversionFormat::F64:
                 input = v.ir.FPAdd(input, v.ir.Imm64(0.0), fp_control);
                 break;
             }
@@ -106,15 +109,15 @@ void F2F(TranslatorVisitor& v, u64 insn, const IR::F16F32F64& src_a, bool abs) {
     }
 
     switch (f2f.dst_size) {
-    case FloatFormat::F16: {
+    case FloatConversionFormat::F16: {
         const IR::F16 imm{v.ir.FPConvert(16, v.ir.Imm32(0.0f))};
         v.X(f2f.dest_reg, v.ir.PackFloat2x16(v.ir.CompositeConstruct(input, imm)));
         break;
     }
-    case FloatFormat::F32:
+    case FloatConversionFormat::F32:
         v.F(f2f.dest_reg, input);
         break;
-    case FloatFormat::F64:
+    case FloatConversionFormat::F64:
         v.D(f2f.dest_reg, input);
         break;
     default:
@@ -127,21 +130,21 @@ void TranslatorVisitor::F2F_reg(u64 insn) {
     union {
         u64 insn;
         BitField<49, 1, u64> abs;
-        BitField<10, 2, FloatFormat> src_size;
+        BitField<10, 2, FloatConversionFormat> src_size;
         BitField<41, 1, u64> selector;
     } const f2f{insn};
 
     IR::F16F32F64 src_a;
     switch (f2f.src_size) {
-    case FloatFormat::F16: {
+    case FloatConversionFormat::F16: {
         auto [lhs_a, rhs_a]{Extract(ir, GetReg20(insn), Swizzle::H1_H0)};
         src_a = f2f.selector != 0 ? rhs_a : lhs_a;
         break;
     }
-    case FloatFormat::F32:
+    case FloatConversionFormat::F32:
         src_a = GetFloatReg20(insn);
         break;
-    case FloatFormat::F64:
+    case FloatConversionFormat::F64:
         src_a = GetDoubleReg20(insn);
         break;
     default:
@@ -154,21 +157,21 @@ void TranslatorVisitor::F2F_cbuf(u64 insn) {
     union {
         u64 insn;
         BitField<49, 1, u64> abs;
-        BitField<10, 2, FloatFormat> src_size;
+        BitField<10, 2, FloatConversionFormat> src_size;
         BitField<41, 1, u64> selector;
     } const f2f{insn};
 
     IR::F16F32F64 src_a;
     switch (f2f.src_size) {
-    case FloatFormat::F16: {
+    case FloatConversionFormat::F16: {
         auto [lhs_a, rhs_a]{Extract(ir, GetCbuf(insn), Swizzle::H1_H0)};
         src_a = f2f.selector != 0 ? rhs_a : lhs_a;
         break;
     }
-    case FloatFormat::F32:
+    case FloatConversionFormat::F32:
         src_a = GetFloatCbuf(insn);
         break;
-    case FloatFormat::F64:
+    case FloatConversionFormat::F64:
         src_a = GetDoubleCbuf(insn);
         break;
     default:
@@ -181,7 +184,7 @@ void TranslatorVisitor::F2F_imm([[maybe_unused]] u64 insn) {
     union {
         u64 insn;
         BitField<49, 1, u64> abs;
-        BitField<10, 2, FloatFormat> src_size;
+        BitField<10, 2, FloatConversionFormat> src_size;
         BitField<41, 1, u64> selector;
         BitField<20, 19, u64> imm;
         BitField<56, 1, u64> imm_neg;
@@ -189,7 +192,7 @@ void TranslatorVisitor::F2F_imm([[maybe_unused]] u64 insn) {
 
     IR::F16F32F64 src_a;
     switch (f2f.src_size) {
-    case FloatFormat::F16: {
+    case FloatConversionFormat::F16: {
         const u32 imm{static_cast<u32>(f2f.imm & 0x0000ffff)};
         const IR::Value vector{ir.UnpackFloat2x16(ir.Imm32(imm | (imm << 16)))};
         src_a = IR::F16{ir.CompositeExtract(vector, f2f.selector != 0 ? 0 : 1)};
@@ -198,10 +201,10 @@ void TranslatorVisitor::F2F_imm([[maybe_unused]] u64 insn) {
         }
         break;
     }
-    case FloatFormat::F32:
+    case FloatConversionFormat::F32:
         src_a = GetFloatImm20(insn);
         break;
-    case FloatFormat::F64:
+    case FloatConversionFormat::F64:
         src_a = GetDoubleImm20(insn);
         break;
     default:

src/shader_recompiler/frontend/maxwell/translate/impl/floating_point_range_reduction.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -7,7 +10,7 @@
 
 namespace Shader::Maxwell {
 namespace {
-enum class Mode : u64 {
+enum class FPReduceMode : u64 {
     SINCOS,
     EX2,
 };
@@ -16,7 +19,7 @@ void RRO(TranslatorVisitor& v, u64 insn, const IR::F32& src) {
     union {
         u64 raw;
         BitField<0, 8, IR::Reg> dest_reg;
-        BitField<39, 1, Mode> mode;
+        BitField<39, 1, FPReduceMode> mode;
         BitField<45, 1, u64> neg;
         BitField<49, 1, u64> abs;
     } const rro{insn};

src/shader_recompiler/frontend/maxwell/translate/impl/integer_add_three_input.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -7,48 +10,48 @@
 
 namespace Shader::Maxwell {
 namespace {
-enum class Shift : u64 {
+enum class IADD3Shift : u64 {
     None,
     Right,
     Left,
 };
-enum class Half : u64 {
+enum class IADD3Half : u64 {
     All,
     Lower,
     Upper,
 };
 
-[[nodiscard]] IR::U32 IntegerHalf(IR::IREmitter& ir, const IR::U32& value, Half half) {
+[[nodiscard]] IR::U32 IntegerHalf(IR::IREmitter& ir, const IR::U32& value, IADD3Half half) {
     constexpr bool is_signed{false};
     switch (half) {
-    case Half::All:
+    case IADD3Half::All:
         return value;
-    case Half::Lower:
+    case IADD3Half::Lower:
         return ir.BitFieldExtract(value, ir.Imm32(0), ir.Imm32(16), is_signed);
-    case Half::Upper:
+    case IADD3Half::Upper:
         return ir.BitFieldExtract(value, ir.Imm32(16), ir.Imm32(16), is_signed);
     }
     throw NotImplementedException("Invalid half");
 }
 
-[[nodiscard]] IR::U32 IntegerShift(IR::IREmitter& ir, const IR::U32& value, Shift shift) {
+[[nodiscard]] IR::U32 IntegerShift(IR::IREmitter& ir, const IR::U32& value, IADD3Shift shift) {
     switch (shift) {
-    case Shift::None:
+    case IADD3Shift::None:
         return value;
-    case Shift::Right: {
+    case IADD3Shift::Right: {
         // 33-bit RS IADD3 edge case
         const IR::U1 edge_case{ir.GetCarryFromOp(value)};
         const IR::U32 shifted{ir.ShiftRightLogical(value, ir.Imm32(16))};
         return IR::U32{ir.Select(edge_case, ir.IAdd(shifted, ir.Imm32(0x10000)), shifted)};
     }
-    case Shift::Left:
+    case IADD3Shift::Left:
         return ir.ShiftLeftLogical(value, ir.Imm32(16));
     }
     throw NotImplementedException("Invalid shift");
 }
 
 void IADD3(TranslatorVisitor& v, u64 insn, IR::U32 op_a, IR::U32 op_b, IR::U32 op_c,
-           Shift shift = Shift::None) {
+           IADD3Shift shift = IADD3Shift::None) {
     union {
         u64 insn;
         BitField<0, 8, IR::Reg> dest_reg;
@@ -71,7 +74,7 @@ void IADD3(TranslatorVisitor& v, u64 insn, IR::U32 op_a, IR::U32 op_b, IR::U32 o
     IR::U32 lhs_1{v.ir.IAdd(op_a, op_b)};
     if (iadd3.x != 0) {
         // TODO: How does RS behave when X is set?
-        if (shift == Shift::Right) {
+        if (shift == IADD3Shift::Right) {
             throw NotImplementedException("IADD3 X+RS");
         }
         const IR::U32 carry{v.ir.Select(v.ir.GetCFlag(), v.ir.Imm32(1), v.ir.Imm32(0))};
@@ -98,10 +101,10 @@ void IADD3(TranslatorVisitor& v, u64 insn, IR::U32 op_a, IR::U32 op_b, IR::U32 o
 void TranslatorVisitor::IADD3_reg(u64 insn) {
     union {
         u64 insn;
-        BitField<37, 2, Shift> shift;
-        BitField<35, 2, Half> half_a;
-        BitField<33, 2, Half> half_b;
-        BitField<31, 2, Half> half_c;
+        BitField<37, 2, IADD3Shift> shift;
+        BitField<35, 2, IADD3Half> half_a;
+        BitField<33, 2, IADD3Half> half_b;
+        BitField<31, 2, IADD3Half> half_c;
     } const iadd3{insn};
 
     const auto op_a{IntegerHalf(ir, GetReg8(insn), iadd3.half_a)};

src/shader_recompiler/frontend/maxwell/translate/impl/integer_floating_point_conversion.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
@@ -11,7 +11,7 @@
 
 namespace Shader::Maxwell {
 namespace {
-enum class FloatFormat : u64 {
+enum class IntegerToFloatFormat : u64 {
     F16 = 1,
     F32 = 2,
     F64 = 3,
@@ -24,10 +24,10 @@ enum class IntFormat : u64 {
     U64 = 3,
 };
 
-union Encoding {
+union EncodingIFPC {
     u64 raw;
     BitField<0, 8, IR::Reg> dest_reg;
-    BitField<8, 2, FloatFormat> float_format;
+    BitField<8, 2, IntegerToFloatFormat> float_format;
     BitField<10, 2, IntFormat> int_format;
     BitField<13, 1, u64> is_signed;
     BitField<39, 2, FpRounding> fp_rounding;
@@ -38,16 +38,16 @@ union Encoding {
 };
 
 bool Is64(u64 insn) {
-    return Encoding{insn}.int_format == IntFormat::U64;
+    return EncodingIFPC{insn}.int_format == IntFormat::U64;
 }
 
-int BitSize(FloatFormat format) {
+int BitSize(IntegerToFloatFormat format) {
     switch (format) {
-    case FloatFormat::F16:
+    case IntegerToFloatFormat::F16:
         return 16;
-    case FloatFormat::F32:
+    case IntegerToFloatFormat::F32:
         return 32;
-    case FloatFormat::F64:
+    case IntegerToFloatFormat::F64:
         return 64;
     }
     throw NotImplementedException("Invalid float format {}", format);
@@ -62,7 +62,7 @@ IR::U32 SmallAbs(TranslatorVisitor& v, const IR::U32& value, int bitsize) {
 }
 
 void I2F(TranslatorVisitor& v, u64 insn, IR::U32U64 src) {
-    const Encoding i2f{insn};
+    const EncodingIFPC i2f{insn};
     if (i2f.cc != 0) {
         throw NotImplementedException("I2F CC");
     }
@@ -119,15 +119,15 @@ void I2F(TranslatorVisitor& v, u64 insn, IR::U32U64 src) {
         }
     }
     switch (i2f.float_format) {
-    case FloatFormat::F16: {
+    case IntegerToFloatFormat::F16: {
         const IR::F16 zero{v.ir.FPConvert(16, v.ir.Imm32(0.0f))};
         v.X(i2f.dest_reg, v.ir.PackFloat2x16(v.ir.CompositeConstruct(value, zero)));
         break;
     }
-    case FloatFormat::F32:
+    case IntegerToFloatFormat::F32:
         v.F(i2f.dest_reg, value);
         break;
-    case FloatFormat::F64: {
+    case IntegerToFloatFormat::F64: {
         if (!IR::IsAligned(i2f.dest_reg, 2)) {
             throw NotImplementedException("Unaligned destination {}", i2f.dest_reg.Value());
         }

src/shader_recompiler/frontend/maxwell/translate/impl/integer_short_multiply_add.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -15,18 +18,18 @@ enum class SelectMode : u64 {
     CBCC,
 };
 
-enum class Half : u64 {
+enum class IMADHalf : u64 {
     H0, // Least-significant bits (15:0)
     H1, // Most-significant bits (31:16)
 };
 
-IR::U32 ExtractHalf(TranslatorVisitor& v, const IR::U32& src, Half half, bool is_signed) {
-    const IR::U32 offset{v.ir.Imm32(half == Half::H1 ? 16 : 0)};
+IR::U32 ExtractHalf(TranslatorVisitor& v, const IR::U32& src, IMADHalf half, bool is_signed) {
+    const IR::U32 offset{v.ir.Imm32(half == IMADHalf::H1 ? 16 : 0)};
     return v.ir.BitFieldExtract(src, offset, v.ir.Imm32(16), is_signed);
 }
 
 void XMAD(TranslatorVisitor& v, u64 insn, const IR::U32& src_b, const IR::U32& src_c,
-          SelectMode select_mode, Half half_b, bool psl, bool mrg, bool x) {
+          SelectMode select_mode, IMADHalf half_b, bool psl, bool mrg, bool x) {
     union {
         u64 raw;
         BitField<0, 8, IR::Reg> dest_reg;
@@ -34,7 +37,7 @@ void XMAD(TranslatorVisitor& v, u64 insn, const IR::U32& src_b, const IR::U32& s
         BitField<47, 1, u64> cc;
         BitField<48, 1, u64> is_a_signed;
         BitField<49, 1, u64> is_b_signed;
-        BitField<53, 1, Half> half_a;
+        BitField<53, 1, IMADHalf> half_a;
     } const xmad{insn};
 
     if (x) {
@@ -53,9 +56,9 @@ void XMAD(TranslatorVisitor& v, u64 insn, const IR::U32& src_b, const IR::U32& s
         case SelectMode::Default:
             return src_c;
         case SelectMode::CLO:
-            return ExtractHalf(v, src_c, Half::H0, false);
+            return ExtractHalf(v, src_c, IMADHalf::H0, false);
         case SelectMode::CHI:
-            return ExtractHalf(v, src_c, Half::H1, false);
+            return ExtractHalf(v, src_c, IMADHalf::H1, false);
         case SelectMode::CBCC:
             return v.ir.IAdd(v.ir.ShiftLeftLogical(src_b, v.ir.Imm32(16)), src_c);
         case SelectMode::CSFU:
@@ -66,7 +69,7 @@ void XMAD(TranslatorVisitor& v, u64 insn, const IR::U32& src_b, const IR::U32& s
     IR::U32 result{v.ir.IAdd(product, op_c)};
     if (mrg) {
         // .MRG inserts src_b [15:0] into result's [31:16].
-        const IR::U32 lsb_b{ExtractHalf(v, src_b, Half::H0, false)};
+        const IR::U32 lsb_b{ExtractHalf(v, src_b, IMADHalf::H0, false)};
         result = v.ir.BitFieldInsert(result, lsb_b, v.ir.Imm32(16), v.ir.Imm32(16));
     }
     if (xmad.cc) {
@@ -80,7 +83,7 @@ void XMAD(TranslatorVisitor& v, u64 insn, const IR::U32& src_b, const IR::U32& s
 void TranslatorVisitor::XMAD_reg(u64 insn) {
     union {
         u64 raw;
-        BitField<35, 1, Half> half_b;
+        BitField<35, 1, IMADHalf> half_b;
         BitField<36, 1, u64> psl;
         BitField<37, 1, u64> mrg;
         BitField<38, 1, u64> x;
@@ -95,7 +98,7 @@ void TranslatorVisitor::XMAD_rc(u64 insn) {
     union {
         u64 raw;
         BitField<50, 2, SelectMode> select_mode;
-        BitField<52, 1, Half> half_b;
+        BitField<52, 1, IMADHalf> half_b;
         BitField<54, 1, u64> x;
     } const xmad{insn};
 
@@ -107,7 +110,7 @@ void TranslatorVisitor::XMAD_cr(u64 insn) {
     union {
         u64 raw;
         BitField<50, 2, SelectMode> select_mode;
-        BitField<52, 1, Half> half_b;
+        BitField<52, 1, IMADHalf> half_b;
         BitField<54, 1, u64> x;
         BitField<55, 1, u64> psl;
         BitField<56, 1, u64> mrg;
@@ -128,7 +131,7 @@ void TranslatorVisitor::XMAD_imm(u64 insn) {
     } const xmad{insn};
 
     XMAD(*this, insn, ir.Imm32(static_cast<u32>(xmad.src_b)), GetReg39(insn), xmad.select_mode,
-         Half::H0, xmad.psl != 0, xmad.mrg != 0, xmad.x != 0);
+         IMADHalf::H0, xmad.psl != 0, xmad.mrg != 0, xmad.x != 0);
 }
 
 } // namespace Shader::Maxwell

src/shader_recompiler/frontend/maxwell/translate/impl/internal_stage_buffer_entry_read.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
@@ -10,7 +10,7 @@
 
 namespace Shader::Maxwell {
 namespace {
-enum class Mode : u64 {
+enum class ISBERDMode : u64 {
     Default,
     Patch,
     Prim,
@@ -24,17 +24,17 @@ enum class SZ : u64 {
     F32
 };
 
-enum class Shift : u64 {
+enum class ISBERDShift : u64 {
     Default,
     U16,
     B32,
 };
 
-IR::U32 scaleIndex(IR::IREmitter& ir, IR::U32 index, Shift shift) {
+IR::U32 scaleIndex(IR::IREmitter& ir, IR::U32 index, ISBERDShift shift) {
     switch (shift) {
-        case Shift::Default: return index;
-        case Shift::U16: return ir.ShiftLeftLogical(index, ir.Imm32(1));
-        case Shift::B32: return ir.ShiftLeftLogical(index, ir.Imm32(2));
+        case ISBERDShift::Default: return index;
+        case ISBERDShift::U16: return ir.ShiftLeftLogical(index, ir.Imm32(1));
+        case ISBERDShift::B32: return ir.ShiftLeftLogical(index, ir.Imm32(2));
         default: UNREACHABLE();
     }
 }
@@ -63,9 +63,9 @@ void TranslatorVisitor::ISBERD(u64 insn) {
         BitField<24, 8, u32> imm;
         BitField<31, 1, u64> skew;
         BitField<32, 1, u64> o;
-        BitField<33, 2, Mode> mode;
+        BitField<33, 2, ISBERDMode> mode;
         BitField<36, 4, SZ> sz;
-        BitField<47, 2, Shift> shift;
+        BitField<47, 2, ISBERDShift> shift;
     } const isberd{insn};
 
     IR::U32 index{};
@@ -95,18 +95,18 @@ void TranslatorVisitor::ISBERD(u64 insn) {
         return;
     }
 
-    if (isberd.mode.Value() != Mode::Default) {
+    if (isberd.mode.Value() != ISBERDMode::Default) {
         if (isberd.skew.Value()) {
             index = ir.IAdd(index, skewBytes(ir, SZ::U32));
         }
 
         IR::F32 float_index{};
         switch (isberd.mode.Value()) {
-        case Mode::Patch: float_index = ir.GetPatch(index.Patch());
+        case ISBERDMode::Patch: float_index = ir.GetPatch(index.Patch());
             break;
-        case Mode::Prim:  float_index = ir.GetAttribute(index.Attribute());
+        case ISBERDMode::Prim:  float_index = ir.GetAttribute(index.Attribute());
             break;
-        case Mode::Attr:  float_index = ir.GetAttributeIndexed(index);
+        case ISBERDMode::Attr:  float_index = ir.GetAttributeIndexed(index);
             break;
         default: UNREACHABLE();
         }

src/shader_recompiler/frontend/maxwell/translate/impl/load_store_attribute.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -9,7 +12,7 @@
 
 namespace Shader::Maxwell {
 namespace {
-enum class Size : u64 {
+enum class InterpolationSize : u64 {
     B32,
     B64,
     B96,
@@ -29,15 +32,15 @@ enum class SampleMode : u64 {
     Offset,
 };
 
-u32 NumElements(Size size) {
+u32 NumElements(InterpolationSize size) {
     switch (size) {
-    case Size::B32:
+    case InterpolationSize::B32:
         return 1;
-    case Size::B64:
+    case InterpolationSize::B64:
         return 2;
-    case Size::B96:
+    case InterpolationSize::B96:
         return 3;
-    case Size::B128:
+    case InterpolationSize::B128:
         return 4;
     }
     throw InvalidArgument("Invalid size {}", size);
@@ -65,7 +68,7 @@ void TranslatorVisitor::ALD(u64 insn) {
         BitField<39, 8, IR::Reg> vertex_reg;
         BitField<32, 1, u64> o;
         BitField<31, 1, u64> patch;
-        BitField<47, 2, Size> size;
+        BitField<47, 2, InterpolationSize> size;
     } const ald{insn};
 
     const u64 offset{ald.absolute_offset.Value()};
@@ -103,7 +106,7 @@ void TranslatorVisitor::AST(u64 insn) {
         BitField<20, 11, s64> relative_offset;
         BitField<31, 1, u64> patch;
         BitField<39, 8, IR::Reg> vertex_reg;
-        BitField<47, 2, Size> size;
+        BitField<47, 2, InterpolationSize> size;
     } const ast{insn};
 
     if (ast.index_reg != IR::Reg::RZ) {

src/shader_recompiler/frontend/maxwell/translate/impl/load_store_local_shared.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -7,7 +10,7 @@
 
 namespace Shader::Maxwell {
 namespace {
-enum class Size : u64 {
+enum class LoadStoreLocalSharedSize : u64 {
     U8,
     S8,
     U16,
@@ -45,23 +48,23 @@ std::pair<IR::U32, IR::U32> WordOffset(TranslatorVisitor& v, u64 insn) {
 std::pair<int, bool> GetSize(u64 insn) {
     union {
         u64 raw;
-        BitField<48, 3, Size> size;
+        BitField<48, 3, LoadStoreLocalSharedSize> size;
     } const encoding{insn};
 
     switch (encoding.size) {
-    case Size::U8:
+    case LoadStoreLocalSharedSize::U8:
         return {8, false};
-    case Size::S8:
+    case LoadStoreLocalSharedSize::S8:
         return {8, true};
-    case Size::U16:
+    case LoadStoreLocalSharedSize::U16:
         return {16, false};
-    case Size::S16:
+    case LoadStoreLocalSharedSize::S16:
         return {16, true};
-    case Size::B32:
+    case LoadStoreLocalSharedSize::B32:
         return {32, false};
-    case Size::B64:
+    case LoadStoreLocalSharedSize::B64:
         return {64, false};
-    case Size::B128:
+    case LoadStoreLocalSharedSize::B128:
         return {128, false};
     default:
         throw NotImplementedException("Invalid size {}", encoding.size.Value());