2026-09-25 13:00:48

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

docs/DesignOverview.md

@@ -1,6 +1,6 @@
 # Design Overview
 
-Modern game consoles require heavy power to emulate. This is why the emulator uses an approach known as HLE (High-Level-Emulation), in a nutshell: Instead of accurately emulating every subsystem that forms part of a component, emulate the resulting visible output of said interface instead.
+Modern game consoles require heavy power to be emulated appropriately. This is why the emulator uses an approach known as HLE (High-Level-Emulation), in a nutshell: Instead of accurately emulating every subsystem that forms part of a component, emulate the resulting visible I/O interface instead.
 
 For example, take a disk write, instead of emulating a proper SD card we instead use the C++ standard library for I/O. Additionally we use the abstractions provided by the `fs` service to "lie" to programs about certain SD card properties. Notably this includes making up sizes for the fake SD card, giving "realistic" values or expected outputs for a given card, and so on. And instead of writing to an actual SD card, the emulator simply writes to a file.
 

docs/HosKernel.md

@@ -1,6 +1,4 @@
-# Subsystem: HLE
-
-## HOS Kernel
+# HOS Kernel
 
 In brief, the HOS kernel is a microkernel, all services and programs run in userspace, the primary way to do communication between these is via `HIPC` (not covered here); otherwise most of the primitives reside in the forms of syscalls invoked via `svc #imm`. The kernel supports both 32-bit and 64-bit programs, and has the capacity to use 32, 36 and 39 bits of address space for spawned processes. Most of the networking stack is based off FreeBSD's network stack.
 
@@ -31,42 +29,3 @@ Every process keeps it's own tracking of the following structures:
 The emulator willingly restricts itself to only use 4 threads (to emulate 4 cores), this is because most existing applications do not benefit greatly from the added core count, and in fact can be detrimental due to extra contention. This translates equitatively to about 4 `ArmInterface` slots for each process, these are then redirected to whatever is the last `pc` of the last thread running on the core is meant to be; proceed to run it, then when returning (due to halt or interruption), proceed to reschedule the thread.
 
 The scheduler as-is isn't 100% faithful to the original (for example the original is cooperative and not preemptive), and has great timing variance (especially due to the fact the emulator can run in systems with wildly different timings).
-
-## Services
-
-Consult [SwitchBrew](https://switchbrew.org/) for per-service methods, and implementation details.
-
-All services are instatiated implicitly using `ServiceFramework`. To register a new interface or service, you can inherit from said class, providing additionally a template parameter that references `Self`, for example:
-
-```c++
-// Follows as:
-// class MyInterface [final] : public ServiceFramework<MyInterface> { ... };
-// [final] is optional, but should be used whenever there is no intention of this class itself being inherited.
-class IFloatingRegistrationRequest final : public ServiceFramework<IFloatingRegistrationRequest> {
-public:
-    // ctor, you can pass extra parameters here (if so required)
-    explicit IFloatingRegistrationRequest(Core::System& system_)
-        : ServiceFramework{system_, "IFloatingRegistrationRequest"}
-    {}
-
-    // Define here your functions and methods, please order them.
-    // Use FindRequestTipc for TIPC handlers.
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "GetSessionId"},
-            FunctionInfo{12, nullptr, "GetAccountId"},
-            FunctionInfo{13, nullptr, "GetLinkedNintendoAccountId"},
-            FunctionInfo{14, nullptr, "GetNickname"},
-            FunctionInfo{15, nullptr, "GetProfileImage"},
-            FunctionInfo{16, nullptr, "GetProfileLargeImage", MakeVersionGate({18,0,0})},
-            FunctionInfo{21, nullptr, "LoadIdTokenCache"},
-            FunctionInfo{100, nullptr, "RegisterUser"},
-            FunctionInfo{101, nullptr, "RegisterUserWithUid"},
-            FunctionInfo{102, nullptr, "RegisterNetworkServiceAccountAsync", MakeVersionGate({4,0,0})},
-            FunctionInfo{103, nullptr, "RegisterNetworkServiceAccountWithUidAsync", MakeVersionGate({4,0,0})},
-            FunctionInfo{110, nullptr, "SetSystemProgramIdentification"},
-            FunctionInfo{111, nullptr, "EnsureIdTokenCacheAsync"}
-        );
-    }
-};
-```

docs/README.md

@@ -21,7 +21,7 @@ This contains documentation created by developers, build instructions, guideline
 - Subsystems:
   - **[Design Overview](./DesignOverview.md)**
   - **[Dynarmic](./dynarmic/README.md)**
-  - **[Subsystem: HLE](./SubsystemHLE.md)**
+  - **[HOS Kernel](./HosKernel.md)**
   - **[Settings](./Settings.md)**
 
 ## Policies

src/common/sparse_large_vector.cpp

@@ -8,7 +8,14 @@
 #ifdef _WIN32
 #include <windows.h>
 #include <mutex>
-#else
+#include <algorithm>
+#include <vector>
+#endif
+
+#include <cerrno>
+#include <cstring>
+
+#ifndef _WIN32
 #include <sys/mman.h>
 #endif
 
@@ -19,54 +26,60 @@
 namespace Common {
 
 #ifdef _WIN32
-static std::vector<std::pair<u64, u64>> vector_regions {};
 
-// Workaround for handling non-commited memory accessed by Dynarmic; usually result of an error
+struct VectorRegion {
+    u64 start_page;
+    u64 end_page;
+};
+
+static std::mutex& GetVectorRegionsMutex() {
+    static std::mutex* m = new std::mutex();
+    return *m;
+}
+
+static std::vector<VectorRegion>& GetVectorRegions() {
+    static std::vector<VectorRegion>* v = new std::vector<VectorRegion>();
+    return *v;
+}
+
 static LONG WINAPI FakePageFaultHandler(PEXCEPTION_POINTERS info) {
-    DWORD code = info->ExceptionRecord->ExceptionCode;
-    u64 exception_addr = reinterpret_cast<u64>(info->ExceptionRecord->ExceptionAddress);
-
-    if (code != EXCEPTION_ACCESS_VIOLATION) {
-        // Not our problem
+    if (info->ExceptionRecord->ExceptionCode != EXCEPTION_ACCESS_VIOLATION) {
         return EXCEPTION_CONTINUE_SEARCH;
     }
 
-    u64 addr = 0, addr2 = 0;
+    const u64 fault_addr = info->ExceptionRecord->ExceptionInformation[1];
+    const u64 access_type = info->ExceptionRecord->ExceptionInformation[0];
+    const bool is_write = (access_type == 1);
+    const u64 fault_page = fault_addr >> HostPageBits;
 
-    for (auto region: vector_regions) {
-        auto addr_shifted = exception_addr >> HostPageBits;
-        if (region.first <= addr_shifted && addr_shifted <= region.second) {
-            addr = addr_shifted;
-        }
+    u64 addr = 0;
+    u64 addr2 = 0;
 
-        // Page-boundary accesses
-        if (auto addr_ = (exception_addr + 0x40) >> HostPageBits; addr_ != addr_shifted && region.first <= addr_ && addr_ <= region.second) {
-            addr2 = addr_;
-        }
-
-        if (addr != 0 || addr2 != 0) {
-            break;
+    {
+        std::lock_guard lock(GetVectorRegionsMutex());
+        for (const auto& region : GetVectorRegions()) {
+            if (fault_page >= region.start_page && fault_page < region.end_page) {
+                addr = fault_page;
+            }
+            const u64 page2 = (fault_addr + 0x3F) >> HostPageBits;
+            if (page2 != fault_page && page2 >= region.start_page && page2 < region.end_page) {
+                addr2 = page2;
+            }
+            if (addr != 0 || addr2 != 0) break;
         }
     }
 
     if (addr == 0 && addr2 == 0) {
-        // Not our problem
         return EXCEPTION_CONTINUE_SEARCH;
     }
 
-    LOG_ERROR(HW_Memory, "Accessing an unallocated region of a SparseLargeVector at {:#x}; this shouldn't happen and is likely a Dynarmic error!", exception_addr);
+    LOG_ERROR(HW_Memory, "Accessing an unallocated region of a SparseLargeVector at {:#x}; this shouldn't happen and is likely a Dynarmic error!", fault_addr);
 
-    // Commit this region
-    if (addr != 0) {
-        if (!CommitVectorPage(addr << HostPageBits, false)) {
-            return EXCEPTION_CONTINUE_SEARCH;
-        }
+    if (addr != 0 && !CommitVectorPage(addr << HostPageBits, is_write)) {
+        return EXCEPTION_CONTINUE_SEARCH;
     }
-    // Commit next region if needed
-    if (addr2 != 0) {
-        if (!CommitVectorPage(addr2 << HostPageBits, false)) {
-            return EXCEPTION_CONTINUE_SEARCH;
-        }
+    if (addr2 != 0 && !CommitVectorPage(addr2 << HostPageBits, is_write)) {
+        return EXCEPTION_CONTINUE_SEARCH;
     }
 
     return EXCEPTION_CONTINUE_EXECUTION;
@@ -74,23 +87,31 @@ static LONG WINAPI FakePageFaultHandler(PEXCEPTION_POINTERS info) {
 
 bool CommitVectorPage(uintptr_t addr, bool write) noexcept {
     MEMORY_BASIC_INFORMATION info {};
-    auto res = VirtualQuery(reinterpret_cast<void*>(addr), &info, sizeof(info));
+    const auto res = VirtualQuery(reinterpret_cast<void*>(addr), &info, sizeof(info));
+    const DWORD perm = write ? PAGE_READWRITE : PAGE_READONLY;
+
     if (res == 0) {
         LOG_CRITICAL(HW_Memory, "Failed to query large buffer region at {:#x} with error {}, will try committing anyway", addr, GetLastError());
+    } else if (info.State == MEM_COMMIT) {
+        DWORD old_protect {};
+        if (!VirtualProtect(reinterpret_cast<void*>(addr), HostPageSize, perm, &old_protect)) {
+            LOG_ERROR(HW_Memory, "VirtualProtect failed at {:#x}, error {}", addr, GetLastError());
+            return false;
+        }
+        return true;
     } else if (info.State != MEM_RESERVE) {
-        LOG_ERROR(HW_Memory, "Tried to commit an unreserved large buffer region at {:#x} that is not mapped or is already committed (state {:#x})", addr, info.State);
+        LOG_ERROR(HW_Memory, "Tried to commit an unreserved large buffer region at {:#x} (state {:#x})", addr, info.State);
         return false;
     }
 
-    auto perm = write ? PAGE_READWRITE : PAGE_READONLY;
-    void* res2 = VirtualAlloc(reinterpret_cast<LPVOID>(addr), HostPageSize, MEM_COMMIT, perm);
-    if (res2 == nullptr) {
+    if (VirtualAlloc(reinterpret_cast<LPVOID>(addr), HostPageSize, MEM_COMMIT, perm) == nullptr) {
         LOG_ERROR(HW_Memory, "Failed to commit large buffer region at {:#x}, error {}", addr, GetLastError());
         return false;
     }
 
     return true;
 }
+
 #endif
 
 #ifndef MAP_NOCORE
@@ -102,57 +123,103 @@ bool CommitVectorPage(uintptr_t addr, bool write) noexcept {
 
 void DecommitVectorPage(uintptr_t base) noexcept {
 #if defined(_WIN32)
-    VirtualFree(reinterpret_cast<LPVOID>(base), HostPageSize, MEM_DECOMMIT);
+    if (!VirtualFree(reinterpret_cast<LPVOID>(base), HostPageSize, MEM_DECOMMIT)) {
+        LOG_WARNING(HW_Memory, "VirtualFree(MEM_DECOMMIT) failed at {:#x}, error {}", base, GetLastError());
+    }
 #elif defined(__linux__)
-    // Linux's MADV_DONTNEED zeros out pages for us
-    madvise(reinterpret_cast<void*>(base), HostPageSize, MADV_DONTNEED);
+    if (madvise(reinterpret_cast<void*>(base), HostPageSize, MADV_DONTNEED) != 0) {
+        LOG_WARNING(HW_Memory, "madvise(MADV_DONTNEED) failed at {:#x}: {}", base, std::strerror(errno));
+    }
 #else
-    madvise(reinterpret_cast<void*>(base), HostPageSize, MADV_FREE);
+    if (madvise(reinterpret_cast<void*>(base), HostPageSize, MADV_FREE) != 0) {
+        LOG_WARNING(HW_Memory, "madvise(MADV_FREE) failed at {:#x}: {}", base, std::strerror(errno));
+    }
     std::memset(reinterpret_cast<void*>(base), 0, HostPageSize);
 #endif
 }
 
 void* AllocateMemoryPages(std::size_t size) noexcept {
-    if (auto page = HostPageSize; size % page != 0) {
+    if (size == 0) {
+        return nullptr;
+    }
+
+    const auto page = HostPageSize;
+    if (size % page != 0) {
         LOG_WARNING(HW_Memory, "Allocating unaligned large vector with size {:#x}; aligning to {} page size", size, page);
+        if (size > SIZE_MAX - (page - 1)) {
+            LOG_CRITICAL(HW_Memory, "Size {:#x} would overflow page alignment", size);
+            return nullptr;
+        }
         size = AlignUp(size, page);
     }
 
 #ifdef _WIN32
-    // We will never use this memory entirely so instead of committing it up front let's just reserve it and commit each page individually
     void* base = VirtualAlloc(nullptr, size, MEM_RESERVE, PAGE_READWRITE);
 
     if (base != nullptr) {
-        vector_regions.emplace_back(reinterpret_cast<u64>(base), reinterpret_cast<u64>(base) + size);
+        {
+            std::lock_guard lock(GetVectorRegionsMutex());
+            GetVectorRegions().push_back({
+                reinterpret_cast<u64>(base) >> HostPageBits,
+                (reinterpret_cast<u64>(base) + size) >> HostPageBits,
+            });
+        }
 
         static std::once_flag flag;
         std::call_once(flag, []() { AddVectoredExceptionHandler(1, FakePageFaultHandler); });
     } else {
-        // Try committing everything instead??
         LOG_WARNING(HW_Memory, "Failed to reserve large vector region with error {}, trying to commit instead..", GetLastError());
         base = VirtualAlloc(nullptr, size, MEM_COMMIT, PAGE_READWRITE);
     }
     ASSERT_MSG(base, "Failed to reserve {:#x} sized region with error {}", size, GetLastError());
 #else
-    void* base = mmap(nullptr, size, PROT_READ, MAP_ANON | MAP_PRIVATE | MAP_NOCORE, -1, 0);
-    if (base == MAP_FAILED)
-        base = nullptr;
-    ASSERT_MSG(base, "Failed to allocate {:#x} sized region with error {}", size, strerror(errno));
+    int flags = MAP_ANON | MAP_PRIVATE;
+#ifdef MAP_NORESERVE
+    flags |= MAP_NORESERVE;
 #endif
+#if defined(MAP_NOCORE)
+    flags |= MAP_NOCORE;
+#endif
+    void* base = mmap(nullptr, size, PROT_READ, flags, -1, 0);
+    if (base == MAP_FAILED) {
+        base = nullptr;
+    }
+#ifdef MADV_HUGEPAGE
+    if (base != nullptr) {
+        madvise(base, size, MADV_HUGEPAGE);
+    }
+#endif
+    ASSERT_MSG(base, "Failed to allocate {:#x} sized region with error {}", size, std::strerror(errno));
+#endif
+
     return base;
 }
 
 void FreeMemoryPages(void* base, [[maybe_unused]] std::size_t size) noexcept {
-    if (auto page = HostPageSize; size % page != 0) {
+    if (base == nullptr) {
+        return;
+    }
+
+    if (const auto page = HostPageSize; size % page != 0) {
         size = AlignUp(size, page);
     }
-    if (!base)
-        return;
+
 #ifdef _WIN32
-    ASSERT(VirtualFree(base, 0, MEM_RELEASE));
+    {
+        std::lock_guard lock(GetVectorRegionsMutex());
+        auto& regions = GetVectorRegions();
+        const u64 base_page = reinterpret_cast<u64>(base) >> HostPageBits;
+        regions.erase(std::remove_if(regions.begin(), regions.end(),
+            [base_page](const VectorRegion& r) { return r.start_page == base_page; }), regions.end());
+    }
+    if (!VirtualFree(base, 0, MEM_RELEASE)) {
+        LOG_ERROR(HW_Memory, "VirtualFree failed, error {}", GetLastError());
+    }
 #else
-    ASSERT(munmap(base, size) == 0);
+    if (munmap(base, size) != 0) {
+        LOG_ERROR(HW_Memory, "munmap failed: {}", std::strerror(errno));
+    }
 #endif
 }
 
-} // namespace Common
+} // namespace Common

src/common/sparse_large_vector.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 /* virtual_buffer.h */
@@ -7,10 +7,14 @@
 
 #pragma once
 
+#include <array>
 #include <atomic>
 #include <bit>
-#include <utility>
-#include <vector>
+#include <cerrno>
+#include <cstdlib>
+#include <cstring>
+#include <memory>
+#include <type_traits>
 
 #ifndef _WIN32
 #include <unistd.h>
@@ -28,9 +32,9 @@ constexpr u64 HostPageBits = 12;
 constexpr u64 HostPageMask = ~(HostPageSize - 1);
 bool CommitVectorPage(uintptr_t addr, bool write) noexcept;
 #else
-const u64 HostPageSize = sysconf(_SC_PAGESIZE);
-const u64 HostPageBits = std::countr_zero(HostPageSize);
-const u64 HostPageMask = ~(HostPageSize - 1);
+inline const u64 HostPageSize = static_cast<u64>(sysconf(_SC_PAGESIZE));
+inline const u64 HostPageBits = std::countr_zero(HostPageSize);
+inline const u64 HostPageMask = ~(HostPageSize - 1);
 #endif
 
 void* AllocateMemoryPages(std::size_t size) noexcept;
@@ -43,20 +47,18 @@ template <typename T>
     // requires std::is_trivially_copyable_v<T>
 class SparseLargeVector final {
 public:
-    constexpr SparseLargeVector() = default;
+    SparseLargeVector() = default;
 
-    explicit SparseLargeVector(std::size_t count) noexcept
-        : alloc_size{count * sizeof(T)}
-    {
-        base_ptr = static_cast<T*>(AllocateMemoryPages(alloc_size));
-
-        // each item in vector holds information for 64 pages
-        auto denom = HostPageSize * 64;
-        committed_pages = std::vector<std::atomic<u64>>((alloc_size + denom - 1) / denom);
+    explicit SparseLargeVector(std::size_t count) noexcept {
+        if (count > SIZE_MAX / sizeof(T)) {
+            LOG_CRITICAL(Common_Memory, "SparseLargeVector size overflow: {} elements", count);
+            return;
+        }
+        Allocate(count * sizeof(T));
     }
 
     ~SparseLargeVector() noexcept {
-        FreeMemoryPages(base_ptr, alloc_size);
+        Release();
     }
 
     SparseLargeVector(const SparseLargeVector&) = delete;
@@ -65,145 +67,181 @@ public:
     SparseLargeVector& operator=(SparseLargeVector&& other) = delete;
 
     void ResizeAndClear(std::size_t count) noexcept {
-        if (auto const new_size = count * sizeof(T); new_size != alloc_size) {
-            FreeMemoryPages(base_ptr, alloc_size);
-            alloc_size = new_size;
-            base_ptr = static_cast<T*>(AllocateMemoryPages(alloc_size));
-
-            auto denom = HostPageSize * 64;
-            committed_pages = std::vector<std::atomic<u64>>((alloc_size + denom - 1) / denom);
+        if (count > SIZE_MAX / sizeof(T)) {
+            LOG_CRITICAL(Common_Memory, "SparseLargeVector resize overflow: {} elements", count);
+            return;
         }
+        const std::size_t new_size = count * sizeof(T);
+        if (new_size == alloc_size) {
+            ZeroRegion(0, alloc_size / sizeof(T));
+            return;
+        }
+        Release();
+        Allocate(new_size);
     }
 
-    /// Returns a reference to the value of the requested index and allocates memory if needed.
     T& GetAndFault(std::size_t index) noexcept {
-        if (index > alloc_size / sizeof(T)) {
-            UNREACHABLE_MSG("Out of bounds RW access on SparseLargeVector @ {}", index);
+        if (base_ptr == nullptr || index >= size()) [[unlikely]] {
+            LOG_CRITICAL(Common_Memory, "SparseLargeVector RW access out of bounds @ {} (size {})", index, size());
+            std::abort();
         }
-
-        if (!IsCommittedPage(index)) {
-            CommitPage(index);
+        const u64 byte_offset = static_cast<u64>(index) * sizeof(T);
+        if (!CommitPage(byte_offset)) [[unlikely]] {
+            LOG_CRITICAL(Common_Memory, "SparseLargeVector commit failed @ {} (offset {:#x})", index, byte_offset);
+            std::abort();
         }
         return base_ptr[index];
     }
 
-    /// Returns a reference to the value of the requested index if initialized, or will otherwise return a zero-initialized object.
-    const T& GetOrDefault(std::size_t index) const {
+    const T& GetOrDefault(std::size_t index) const noexcept {
+        if (base_ptr == nullptr || index >= size()) [[unlikely]] {
+            LOG_CRITICAL(Common_Memory, "SparseLargeVector RO access out of bounds @ {}", index);
+            return DefaultValue();
+        }
 #ifdef _WIN32
-        if (!IsCommittedPage(index)) {
-            return *reinterpret_cast<const T*>(&default_val);
+        if (!IsPageCommitted(static_cast<u64>(index) * sizeof(T))) {
+            return DefaultValue();
         }
 #endif
-        // On non-Windows, OS page table should optimize this by pointing to a zero page if unallocated.
         return base_ptr[index];
     }
 
     void Set(std::size_t index, const T& value) noexcept {
-        if (index > alloc_size / sizeof(T)) {
-            LOG_CRITICAL(Common_Memory, "Out of bounds write on SparseLargeVector @ {}", index);
+        if (base_ptr == nullptr || index >= size()) [[unlikely]] {
+            LOG_CRITICAL(Common_Memory, "SparseLargeVector write out of bounds @ {}", index);
+            return;
+        }
+        const u64 byte_offset = static_cast<u64>(index) * sizeof(T);
+        if (!CommitPage(byte_offset)) [[unlikely]] {
+            LOG_CRITICAL(Common_Memory, "SparseLargeVector commit failed for write @ {}", index);
             return;
         }
-        if (!IsCommittedPage(index))
-            CommitPage(index);
         base_ptr[index] = value;
     }
 
     void ZeroRegion(std::size_t start, std::size_t end_) noexcept {
-        u64 base = reinterpret_cast<u64>(&base_ptr[start]);
-        const u64 end = reinterpret_cast<u64>(&base_ptr[end_]);
+        if (base_ptr == nullptr || start >= end_) return;
 
-        const u64 end_page = AlignUp(base, HostPageSize);
-        const u64 first_size = (std::min)(end_page, end) - base;
+        const u64 start_off = static_cast<u64>(start) * sizeof(T);
+        const u64 end_off = static_cast<u64>(end_) * sizeof(T);
+        const u64 first_page_end = (start_off + HostPageSize - 1) & HostPageMask;
 
-        if (IsCommittedPage(start)) {
-            std::memset(reinterpret_cast<void*>(base), 0, first_size);
+        if (start_off < first_page_end) {
+            const u64 chunk_end = (std::min)(first_page_end, end_off);
+            const u64 chunk_size = chunk_end - start_off;
+            if (chunk_size != 0 && IsPageCommitted(start_off)) {
+                std::memset(reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(base_ptr) + start_off), 0, chunk_size);
+            }
+            if (end_off <= first_page_end) return;
         }
 
-        if (end <= end_page)
-            return;
-
-        base = end_page;
-
-        for (u64 page = base; page < end; page += HostPageSize) {
-            auto index = (page - reinterpret_cast<u64>(base_ptr)) / sizeof(T);
-            if (!IsCommittedPage(index)) {
-                continue;
-            }
-
-            if (end - page >= HostPageSize) {
-                DecommitPage(index);
+        for (u64 off = first_page_end; off < end_off; off += HostPageSize) {
+            if (!IsPageCommitted(off)) continue;
+            const u64 remaining = end_off - off;
+            if (remaining >= HostPageSize) {
+                DecommitPage(off);
             } else {
-                std::memset(reinterpret_cast<void*>(page), 0, end - page);
+                std::memset(reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(base_ptr) + off), 0, remaining);
             }
         }
     }
 
-    constexpr void CommitRegion(size_t index, size_t end_) {
-        const u64 base = static_cast<u64>(index) * sizeof(T);
-        const u64 end = static_cast<u64>(end_) * sizeof(T);
-
-        for (u64 page = AlignDown(base, HostPageSize); page < end; page += HostPageSize) {
-            if (!IsCommittedPage(page / sizeof(T))) {
-                CommitPage(page / sizeof(T));
+    void CommitRegion(std::size_t index, std::size_t end_) noexcept {
+        if (base_ptr == nullptr || index >= end_) return;
+        const u64 start_off = static_cast<u64>(index) * sizeof(T);
+        const u64 end_off = static_cast<u64>(end_) * sizeof(T);
+        const u64 start_page = start_off & HostPageMask;
+        for (u64 off = start_page; off < end_off; off += HostPageSize) {
+            if (!IsPageCommitted(off)) {
+                (void)CommitPage(off);
             }
         }
     }
 
-    constexpr T& GetUnchecked(size_t index) {
-        return base_ptr[index];
-    }
+    T& GetUnchecked(std::size_t index) noexcept { return base_ptr[index]; }
 
-    [[nodiscard]] constexpr const T& operator[](std::size_t index) const noexcept {
-        return GetOrDefault(index);
-    }
-
-    [[nodiscard]] constexpr const T* data() const noexcept {
-        return base_ptr;
-    }
-
-    [[nodiscard]] constexpr std::size_t size() const noexcept {
-        return alloc_size / sizeof(T);
-    }
+    [[nodiscard]] const T& operator[](std::size_t index) const noexcept { return GetOrDefault(index); }
+    [[nodiscard]] const T* data() const noexcept { return base_ptr; }
+    [[nodiscard]] std::size_t size() const noexcept { return alloc_size / sizeof(T); }
 
 private:
-    [[nodiscard]] constexpr bool IsCommittedPage(std::size_t index) const noexcept {
-        if (index > alloc_size / sizeof(T)) {
-            LOG_CRITICAL(Common_Memory, "Out of bounds access on large vector @ {}", index);
+    void Allocate(std::size_t new_size) noexcept {
+        alloc_size = new_size;
+        if (alloc_size == 0) {
+            base_ptr = nullptr;
+            committed_pages.reset();
+            return;
+        }
+        base_ptr = static_cast<T*>(AllocateMemoryPages(alloc_size));
+        const std::size_t num_pages = NumPages();
+        const std::size_t num_words = (num_pages + 63) / 64;
+        committed_pages = std::make_unique<std::atomic<u64>[]>(num_words);
+    }
+
+    void Release() noexcept {
+        if (base_ptr != nullptr) {
+            FreeMemoryPages(base_ptr, alloc_size);
+            base_ptr = nullptr;
+        }
+        committed_pages.reset();
+        alloc_size = 0;
+    }
+
+    [[nodiscard]] u64 NumPages() const noexcept {
+        return (alloc_size + HostPageSize - 1) >> HostPageBits;
+    }
+
+    [[nodiscard]] bool IsPageCommitted(u64 byte_offset) const noexcept {
+        const u64 page_index = byte_offset >> HostPageBits;
+        if (committed_pages == nullptr || page_index >= NumPages()) return false;
+        const auto val = committed_pages[page_index >> 6].load(std::memory_order_acquire);
+        return (val >> (page_index & 63)) & 1;
+    }
+
+    void SetPageBit(u64 page_index, bool value) noexcept {
+        if (committed_pages == nullptr) return;
+        const u64 bit = 1ULL << (page_index & 63);
+        auto& atom = committed_pages[page_index >> 6];
+        if (value) {
+            atom.fetch_or(bit, std::memory_order_release);
+        } else {
+            atom.fetch_and(~bit, std::memory_order_release);
+        }
+    }
+
+    bool CommitPage(u64 byte_offset) noexcept {
+        const u64 page_index = byte_offset >> HostPageBits;
+        const uintptr_t page_addr = (reinterpret_cast<uintptr_t>(base_ptr) + byte_offset) & HostPageMask;
+
+        if (IsPageCommitted(byte_offset)) return true;
+
+#if defined(_WIN32)
+        if (!CommitVectorPage(page_addr, true)) return false;
+#else
+        if (mprotect(reinterpret_cast<void*>(page_addr), HostPageSize, PROT_READ | PROT_WRITE) != 0) {
+            LOG_ERROR(Common_Memory, "mprotect failed at {:#x}: {}", page_addr, std::strerror(errno));
             return false;
         }
-
-        auto page = (index * sizeof(T)) >> HostPageBits;
-        auto val = committed_pages[page >> 6].load(std::memory_order_acquire);
-        return (val >> (page & 63)) & 1;
-    }
-
-    constexpr void CommitPage(std::size_t index) noexcept {
-        auto page_index = (index * sizeof(T)) >> HostPageBits;
-        auto page = reinterpret_cast<uintptr_t>(base_ptr + index) & HostPageMask;
-#if defined(_WIN32)
-        CommitVectorPage(page, true);
-#else
-        mprotect(reinterpret_cast<void*>(page), HostPageSize, PROT_READ | PROT_WRITE);
 #endif
-
-        committed_pages[page_index >> 6].fetch_or(1ULL << (page_index & 63), std::memory_order_release);
+        SetPageBit(page_index, true);
+        return true;
     }
 
-    constexpr void DecommitPage(std::size_t index) noexcept {
-        auto page_index = (index * sizeof(T)) >> HostPageBits;
-        auto page = reinterpret_cast<uintptr_t>(base_ptr + index) & HostPageMask;
+    void DecommitPage(u64 byte_offset) noexcept {
+        const u64 page_index = byte_offset >> HostPageBits;
+        const uintptr_t page_addr = (reinterpret_cast<uintptr_t>(base_ptr) + byte_offset) & HostPageMask;
+        DecommitVectorPage(page_addr);
+        SetPageBit(page_index, false);
+    }
 
-        committed_pages[page_index >> 6].fetch_and(~(1ULL << (page_index & 63)), std::memory_order_release);
-        DecommitVectorPage(page);
+    [[nodiscard]] const T& DefaultValue() const noexcept {
+        return *reinterpret_cast<const T*>(&default_val);
     }
 
     std::size_t alloc_size{};
     T* base_ptr{};
-
-    std::vector<std::atomic<u64>> committed_pages{};
-#ifdef _WIN32
-    const std::array<u8, sizeof(T)> default_val{};
-#endif
+    std::unique_ptr<std::atomic<u64>[]> committed_pages{};
+    alignas(T) const std::array<u8, sizeof(T)> default_val{};
 };
 
-} // namespace Common
+} // namespace Common

src/core/CMakeLists.txt

@@ -1222,7 +1222,7 @@ target_link_libraries(core PRIVATE
     RenderDoc::API
     ZLIB::ZLIB)
 
-target_link_libraries(core PUBLIC httplib::httplib zstd::zstd frozen::frozen-headers)
+target_link_libraries(core PUBLIC httplib::httplib zstd::zstd)
 
 if (ENABLE_WEB_SERVICE)
     target_compile_definitions(core PUBLIC ENABLE_WEB_SERVICE)

src/core/hle/service/aoc/purchase_event_manager.cpp

@@ -1,6 +1,3 @@
-// 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
 
@@ -16,11 +13,11 @@ IPurchaseEventManager::IPurchaseEventManager(Core::System& system_)
                                                                           "IPurchaseEventManager"} {
     // clang-format off
         static const FunctionInfo functions[] = {
-            FunctionInfo{0, D<&IPurchaseEventManager::SetDefaultDeliveryTarget>, "SetDefaultDeliveryTarget"},
-            FunctionInfo{1, D<&IPurchaseEventManager::SetDeliveryTarget>, "SetDeliveryTarget"},
-            FunctionInfo{2, D<&IPurchaseEventManager::GetPurchasedEvent>, "GetPurchasedEvent"},
-            FunctionInfo{3, D<&IPurchaseEventManager::PopPurchasedProductInfo>, "PopPurchasedProductInfo"},
-            FunctionInfo{4, D<&IPurchaseEventManager::PopPurchasedProductInfoWithUid>, "PopPurchasedProductInfoWithUid"}
+            {0, D<&IPurchaseEventManager::SetDefaultDeliveryTarget>, "SetDefaultDeliveryTarget"},
+            {1, D<&IPurchaseEventManager::SetDeliveryTarget>, "SetDeliveryTarget"},
+            {2, D<&IPurchaseEventManager::GetPurchasedEvent>, "GetPurchasedEvent"},
+            {3, D<&IPurchaseEventManager::PopPurchasedProductInfo>, "PopPurchasedProductInfo"},
+            {4, D<&IPurchaseEventManager::PopPurchasedProductInfoWithUid>, "PopPurchasedProductInfoWithUid"},
         };
     // clang-format on
 

src/core/hle/service/apm/apm_interface.cpp

@@ -17,9 +17,9 @@ public:
     explicit ISession(Core::System& system_, Controller& controller_)
         : ServiceFramework{system_, "ISession"}, controller{controller_} {
         static const FunctionInfo functions[] = {
-            FunctionInfo{0, &ISession::SetPerformanceConfiguration, "SetPerformanceConfiguration"},
-            FunctionInfo{1, &ISession::GetPerformanceConfiguration, "GetPerformanceConfiguration"},
-            FunctionInfo{2, &ISession::SetCpuOverclockEnabled, "SetCpuOverclockEnabled"}
+            {0, &ISession::SetPerformanceConfiguration, "SetPerformanceConfiguration"},
+            {1, &ISession::GetPerformanceConfiguration, "GetPerformanceConfiguration"},
+            {2, &ISession::SetCpuOverclockEnabled, "SetCpuOverclockEnabled"},
         };
         RegisterHandlers(functions);
     }

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

@@ -21,154 +21,164 @@ namespace Service::Audio {
 class IAudioOutManagerForApplet final : public ServiceFramework<IAudioOutManagerForApplet> {
 public:
     explicit IAudioOutManagerForApplet(Core::System& system_)
-        : ServiceFramework{system_, "audout:a"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "RequestSuspend"},
-            FunctionInfo{1, nullptr, "RequestResume"},
-            FunctionInfo{2, nullptr, "GetProcessMasterVolume"},
-            FunctionInfo{3, nullptr, "SetProcessMasterVolume"},
-            FunctionInfo{4, nullptr, "GetProcessRecordVolume"},
-            FunctionInfo{5, nullptr, "SetProcessRecordVolume"}
-        );
+        : ServiceFramework{system_, "audout:a"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "RequestSuspend"},
+            {1, nullptr, "RequestResume"},
+            {2, nullptr, "GetProcessMasterVolume"},
+            {3, nullptr, "SetProcessMasterVolume"},
+            {4, nullptr, "GetProcessRecordVolume"},
+            {5, nullptr, "SetProcessRecordVolume"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 
 class IAudioSnoopManager final : public ServiceFramework<IAudioSnoopManager> {
 public:
     explicit IAudioSnoopManager(Core::System& system_)
-        : ServiceFramework{system_, "auddev"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "GetDspStatistics"},
-            FunctionInfo{1, nullptr, "GetAppletStateSummaries"},
-            FunctionInfo{2, nullptr, "SetDspStatisticsParameter"},
-            FunctionInfo{3, nullptr, "GetDspStatisticsParameter"},
-            FunctionInfo{6, nullptr, "GetDspUsage"}
-        );
+        : ServiceFramework{system_, "auddev"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "GetDspStatistics"},
+            {1, nullptr, "GetAppletStateSummaries"},
+            {2, nullptr, "SetDspStatisticsParameter"},
+            {3, nullptr, "GetDspStatisticsParameter"},
+            {6, nullptr, "GetDspUsage"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 
 class IAudioInManagerForApplet final : public ServiceFramework<IAudioInManagerForApplet> {
 public:
     explicit IAudioInManagerForApplet(Core::System& system_)
-        : ServiceFramework{system_, "audin:a"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "RequestSuspend"},
-            FunctionInfo{1, nullptr, "RequestResume"},
-            FunctionInfo{2, nullptr, "GetProcessMasterVolume"},
-            FunctionInfo{3, nullptr, "SetProcessMasterVolume"}
-        );
+        : ServiceFramework{system_, "audin:a"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "RequestSuspend"},
+            {1, nullptr, "RequestResume"},
+            {2, nullptr, "GetProcessMasterVolume"},
+            {3, nullptr, "SetProcessMasterVolume"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 
 class IAudioRendererManagerForApplet final : public ServiceFramework<IAudioRendererManagerForApplet> {
 public:
     explicit IAudioRendererManagerForApplet(Core::System& system_)
-        : ServiceFramework{system_, "audren:a"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "RequestSuspend"},
-            FunctionInfo{1, nullptr, "RequestResume"},
-            FunctionInfo{2, nullptr, "GetProcessMasterVolume"},
-            FunctionInfo{3, nullptr, "SetProcessMasterVolume"},
-            FunctionInfo{4, nullptr, "RegisterAppletResourceUserId"},
-            FunctionInfo{5, nullptr, "UnregisterAppletResourceUserId"},
-            FunctionInfo{6, nullptr, "GetProcessRecordVolume"},
-            FunctionInfo{7, nullptr, "SetProcessRecordVolume"}
-        );
+        : ServiceFramework{system_, "audren:a"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "RequestSuspend"},
+            {1, nullptr, "RequestResume"},
+            {2, nullptr, "GetProcessMasterVolume"},
+            {3, nullptr, "SetProcessMasterVolume"},
+            {4, nullptr, "RegisterAppletResourceUserId"},
+            {5, nullptr, "UnregisterAppletResourceUserId"},
+            {6, nullptr, "GetProcessRecordVolume"},
+            {7, nullptr, "SetProcessRecordVolume"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 
 class IAudioOutManagerForDebugger final : public ServiceFramework<IAudioOutManagerForDebugger> {
 public:
     explicit IAudioOutManagerForDebugger(Core::System& system_)
-        : ServiceFramework{system_, "audout:d"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "RequestSuspend"},
-            FunctionInfo{1, nullptr, "RequestResume"}
-        );
+        : ServiceFramework{system_, "audout:d"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "RequestSuspend"},
+            {1, nullptr, "RequestResume"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 
 class IAudioInManagerForDebugger final : public ServiceFramework<IAudioInManagerForDebugger> {
 public:
     explicit IAudioInManagerForDebugger(Core::System& system_)
-        : ServiceFramework{system_, "audin:d"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "RequestSuspend"},
-            FunctionInfo{1, nullptr, "RequestResume"}
-        );
+        : ServiceFramework{system_, "audin:d"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "RequestSuspend"},
+            {1, nullptr, "RequestResume"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 
 class IFinalOutputRecorderManagerForDebugger final : public ServiceFramework<IFinalOutputRecorderManagerForDebugger> {
 public:
     explicit IFinalOutputRecorderManagerForDebugger(Core::System& system_)
-        : ServiceFramework{system_, "audrec:d"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "RequestSuspend"},
-            FunctionInfo{1, nullptr, "RequestResume"}
-        );
+        : ServiceFramework{system_, "audrec:d"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "RequestSuspend"},
+            {1, nullptr, "RequestResume"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 
 class IAudioRendererManagerForDebugger final : public ServiceFramework<IAudioRendererManagerForDebugger> {
 public:
     explicit IAudioRendererManagerForDebugger(Core::System& system_)
-        : ServiceFramework{system_, "audren:d"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "RequestSuspend"},
-            FunctionInfo{1, nullptr, "RequestResume"}
-        );
+        : ServiceFramework{system_, "audren:d"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "RequestSuspend"},
+            {1, nullptr, "RequestResume"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 
 class IAudioSystemManagerForApplet final : public ServiceFramework<IAudioSystemManagerForApplet> {
 public:
     explicit IAudioSystemManagerForApplet(Core::System& system_)
-        : ServiceFramework{system_, "aud:a"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "RegisterAppletResourceUserId"},
-            FunctionInfo{1, nullptr, "UnregisterAppletResourceUserId"},
-            FunctionInfo{2, nullptr, "RequestSuspendAudio"},
-            FunctionInfo{3, nullptr, "RequestResumeAudio"},
-            FunctionInfo{4, nullptr, "GetAudioOutputProcessMasterVolume"},
-            FunctionInfo{5, nullptr, "SetAudioOutputProcessMasterVolume"},
-            FunctionInfo{6, nullptr, "GetAudioInputProcessMasterVolume"},
-            FunctionInfo{7, nullptr, "SetAudioInputProcessMasterVolume"},
-            FunctionInfo{8, nullptr, "GetAudioOutputProcessRecordVolume"},
-            FunctionInfo{9, nullptr, "SetAudioOutputProcessRecordVolume"},
-            FunctionInfo{10, nullptr, "GetAppletStateSummaries"}
-        );
+        : ServiceFramework{system_, "aud:a"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "RegisterAppletResourceUserId"},
+            {1, nullptr, "UnregisterAppletResourceUserId"},
+            {2, nullptr, "RequestSuspendAudio"},
+            {3, nullptr, "RequestResumeAudio"},
+            {4, nullptr, "GetAudioOutputProcessMasterVolume"},
+            {5, nullptr, "SetAudioOutputProcessMasterVolume"},
+            {6, nullptr, "GetAudioInputProcessMasterVolume"},
+            {7, nullptr, "SetAudioInputProcessMasterVolume"},
+            {8, nullptr, "GetAudioOutputProcessRecordVolume"},
+            {9, nullptr, "SetAudioOutputProcessRecordVolume"},
+            {10, nullptr, "GetAppletStateSummaries"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 
 class IAudioSystemManagerForDebugger final : public ServiceFramework<IAudioSystemManagerForDebugger> {
 public:
     explicit IAudioSystemManagerForDebugger(Core::System& system_)
-        : ServiceFramework{system_, "aud:d"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "RequestSuspendAudioForDebug"},
-            FunctionInfo{1, nullptr, "RequestResumeAudioForDebug"}
-        );
+        : ServiceFramework{system_, "aud:d"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "RequestSuspendAudioForDebug"},
+            {1, nullptr, "RequestResumeAudioForDebug"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 

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

@@ -1,6 +1,3 @@
-// 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,23 +8,25 @@ namespace Service::Audio {
 class IFinalOutputRecorder final : public ServiceFramework<IFinalOutputRecorder> {
 public:
     explicit IFinalOutputRecorder(Core::System& system_)
-        : ServiceFramework{system_, "IFinalOutputRecorder"} {}
+        : ServiceFramework{system_, "IFinalOutputRecorder"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "GetFinalOutputRecorderState"},
+            {1, nullptr, "Start"},
+            {2, nullptr, "Stop"},
+            {3, nullptr, "AppendFinalOutputRecorderBuffer"},
+            {4, nullptr, "RegisterBufferEvent"},
+            {5, nullptr, "GetReleasedFinalOutputRecorderBuffers"},
+            {6, nullptr, "ContainsFinalOutputRecorderBuffer"},
+            {7, nullptr, "GetFinalOutputRecorderBufferEndTime"},
+            {8, nullptr, "AppendFinalOutputRecorderBufferAuto"},
+            {9, nullptr, "GetReleasedFinalOutputRecorderBufferAuto"},
+            {10, nullptr, "FlushFinalOutputRecorderBuffers"},
+            {11, nullptr, "AttachWorkBuffer"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "GetFinalOutputRecorderState"},
-            FunctionInfo{1, nullptr, "Start"},
-            FunctionInfo{2, nullptr, "Stop"},
-            FunctionInfo{3, nullptr, "AppendFinalOutputRecorderBuffer"},
-            FunctionInfo{4, nullptr, "RegisterBufferEvent"},
-            FunctionInfo{5, nullptr, "GetReleasedFinalOutputRecorderBuffers"},
-            FunctionInfo{6, nullptr, "ContainsFinalOutputRecorderBuffer"},
-            FunctionInfo{7, nullptr, "GetFinalOutputRecorderBufferEndTime"},
-            FunctionInfo{8, nullptr, "AppendFinalOutputRecorderBufferAuto"},
-            FunctionInfo{9, nullptr, "GetReleasedFinalOutputRecorderBufferAuto"},
-            FunctionInfo{10, nullptr, "FlushFinalOutputRecorderBuffers"},
-            FunctionInfo{11, nullptr, "AttachWorkBuffer"}
-        );
+        RegisterHandlers(functions);
     }
 };
 

src/core/hle/service/bcat/bcat_service.cpp

@@ -32,32 +32,32 @@ IBcatService::IBcatService(Core::System& system_, BcatBackend& backend_, u64 pro
       }} {
     // clang-format off
         static const FunctionInfo functions[] = {
-            FunctionInfo{10100, D<&IBcatService::RequestSyncDeliveryCache>, "RequestSyncDeliveryCache"},
-            FunctionInfo{10101, D<&IBcatService::RequestSyncDeliveryCacheWithDirectoryName>, "RequestSyncDeliveryCacheWithDirectoryName"},
-            FunctionInfo{10200, nullptr, "CancelSyncDeliveryCacheRequest"},
-            FunctionInfo{20100, nullptr, "RequestSyncDeliveryCacheWithApplicationId"},
-            FunctionInfo{20101, nullptr, "RequestSyncDeliveryCacheWithApplicationIdAndDirectoryName"},
-            FunctionInfo{20300, nullptr, "GetDeliveryCacheStorageUpdateNotifier"},
-            FunctionInfo{20301, nullptr, "RequestSuspendDeliveryTask"},
-            FunctionInfo{20400, nullptr, "RegisterSystemApplicationDeliveryTask"},
-            FunctionInfo{20401, nullptr, "UnregisterSystemApplicationDeliveryTask"},
-            FunctionInfo{20410, nullptr, "SetSystemApplicationDeliveryTaskTimer"},
-            FunctionInfo{30100, D<&IBcatService::SetPassphrase>, "SetPassphrase"},
-            FunctionInfo{30101, nullptr, "Unknown30101"}, //2.0.0-2.3.0
-            FunctionInfo{30102, nullptr, "Unknown30102"}, //2.0.0-2.3.0
-            FunctionInfo{30200, nullptr, "RegisterBackgroundDeliveryTask"},
-            FunctionInfo{30201, nullptr, "UnregisterBackgroundDeliveryTask"},
-            FunctionInfo{30202, nullptr, "BlockDeliveryTask"},
-            FunctionInfo{30203, nullptr, "UnblockDeliveryTask"},
-            FunctionInfo{30210, nullptr, "SetDeliveryTaskTimer"},
-            FunctionInfo{30300, D<&IBcatService::RegisterSystemApplicationDeliveryTasks>, "RegisterSystemApplicationDeliveryTasks"},
-            FunctionInfo{90100, nullptr, "GetDeliveryTaskList"},
-            FunctionInfo{90101, nullptr, "GetDeliveryTaskListForSystem"}, //11.0.0+
-            FunctionInfo{90200, nullptr, "GetDeliveryList"},
-            FunctionInfo{90201, D<&IBcatService::ClearDeliveryCacheStorage>, "ClearDeliveryCacheStorage"},
-            FunctionInfo{90202, nullptr, "ClearDeliveryTaskSubscriptionStatus"},
-            FunctionInfo{90300, nullptr, "GetPushNotificationLog"},
-            FunctionInfo{90301, nullptr, "GetDeliveryCacheStorageUsage"}, //11.0.0+
+            {10100, D<&IBcatService::RequestSyncDeliveryCache>, "RequestSyncDeliveryCache"},
+            {10101, D<&IBcatService::RequestSyncDeliveryCacheWithDirectoryName>, "RequestSyncDeliveryCacheWithDirectoryName"},
+            {10200, nullptr, "CancelSyncDeliveryCacheRequest"},
+            {20100, nullptr, "RequestSyncDeliveryCacheWithApplicationId"},
+            {20101, nullptr, "RequestSyncDeliveryCacheWithApplicationIdAndDirectoryName"},
+            {20300, nullptr, "GetDeliveryCacheStorageUpdateNotifier"},
+            {20301, nullptr, "RequestSuspendDeliveryTask"},
+            {20400, nullptr, "RegisterSystemApplicationDeliveryTask"},
+            {20401, nullptr, "UnregisterSystemApplicationDeliveryTask"},
+            {20410, nullptr, "SetSystemApplicationDeliveryTaskTimer"},
+            {30100, D<&IBcatService::SetPassphrase>, "SetPassphrase"},
+            {30101, nullptr, "Unknown30101"}, //2.0.0-2.3.0
+            {30102, nullptr, "Unknown30102"}, //2.0.0-2.3.0
+            {30200, nullptr, "RegisterBackgroundDeliveryTask"},
+            {30201, nullptr, "UnregisterBackgroundDeliveryTask"},
+            {30202, nullptr, "BlockDeliveryTask"},
+            {30203, nullptr, "UnblockDeliveryTask"},
+            {30210, nullptr, "SetDeliveryTaskTimer"},
+            {30300, D<&IBcatService::RegisterSystemApplicationDeliveryTasks>, "RegisterSystemApplicationDeliveryTasks"},
+            {90100, nullptr, "GetDeliveryTaskList"},
+            {90101, nullptr, "GetDeliveryTaskListForSystem"}, //11.0.0+
+            {90200, nullptr, "GetDeliveryList"},
+            {90201, D<&IBcatService::ClearDeliveryCacheStorage>, "ClearDeliveryCacheStorage"},
+            {90202, nullptr, "ClearDeliveryTaskSubscriptionStatus"},
+            {90300, nullptr, "GetPushNotificationLog"},
+            {90301, nullptr, "GetDeliveryCacheStorageUsage"}, //11.0.0+
         };
     // clang-format on
     RegisterHandlers(functions);

src/core/hle/service/bpc/bpc.cpp

@@ -14,95 +14,103 @@ namespace Service::BPC {
 
 class BPC final : public ServiceFramework<BPC> {
 public:
-    explicit BPC(Core::System& system_) : ServiceFramework{system_, "bpc"} {}
+    explicit BPC(Core::System& system_) : ServiceFramework{system_, "bpc"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "ShutdownSystem"},
+            {1, nullptr, "RebootSystem"},
+            {2, nullptr, "GetWakeupReason"},
+            {3, nullptr, "GetShutdownReason"},
+            {4, nullptr, "GetAcOk"},
+            {5, nullptr, "GetBoardPowerControlEvent"},
+            {6, nullptr, "GetSleepButtonState"},
+            {7, nullptr, "GetPowerEvent"},
+            {8, nullptr, "CreateWakeupTimer"},
+            {9, nullptr, "CancelWakeupTimer"},
+            {10, nullptr, "EnableWakeupTimerOnDevice"},
+            {11, nullptr, "CreateWakeupTimerEx"},
+            {12, nullptr, "GetLastEnabledWakeupTimerType"},
+            {13, nullptr, "CleanAllWakeupTimers"},
+            {14, nullptr, "GetPowerButton"},
+            {15, nullptr, "SetEnableWakeupTimer"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "ShutdownSystem"},
-            FunctionInfo{1, nullptr, "RebootSystem"},
-            FunctionInfo{2, nullptr, "GetWakeupReason"},
-            FunctionInfo{3, nullptr, "GetShutdownReason"},
-            FunctionInfo{4, nullptr, "GetAcOk"},
-            FunctionInfo{5, nullptr, "GetBoardPowerControlEvent"},
-            FunctionInfo{6, nullptr, "GetSleepButtonState"},
-            FunctionInfo{7, nullptr, "GetPowerEvent"},
-            FunctionInfo{8, nullptr, "CreateWakeupTimer"},
-            FunctionInfo{9, nullptr, "CancelWakeupTimer"},
-            FunctionInfo{10, nullptr, "EnableWakeupTimerOnDevice"},
-            FunctionInfo{11, nullptr, "CreateWakeupTimerEx"},
-            FunctionInfo{12, nullptr, "GetLastEnabledWakeupTimerType"},
-            FunctionInfo{13, nullptr, "CleanAllWakeupTimers"},
-            FunctionInfo{14, nullptr, "GetPowerButton"},
-            FunctionInfo{15, nullptr, "SetEnableWakeupTimer"}
-        );
+        RegisterHandlers(functions);
     }
 };
 
 class BPC_R final : public ServiceFramework<BPC_R> {
 public:
-    explicit BPC_R(Core::System& system_) : ServiceFramework{system_, "bpc:r"} {}
+    explicit BPC_R(Core::System& system_) : ServiceFramework{system_, "bpc:r"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "GetRtcTime"},
+            {1, nullptr, "SetRtcTime"},
+            {2, nullptr, "GetRtcResetDetected"},
+            {3, nullptr, "ClearRtcResetDetected"},
+            {4, nullptr, "SetUpRtcResetOnShutdown"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "GetRtcTime"},
-            FunctionInfo{1, nullptr, "SetRtcTime"},
-            FunctionInfo{2, nullptr, "GetRtcResetDetected"},
-            FunctionInfo{3, nullptr, "ClearRtcResetDetected"},
-            FunctionInfo{4, nullptr, "SetUpRtcResetOnShutdown"}
-        );
+        RegisterHandlers(functions);
     }
 };
 
 class BPC_C final : public ServiceFramework<BPC_C> {
 public:
-    explicit BPC_C(Core::System& system_) : ServiceFramework{system_, "bpc:c"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "ShutdownSystem"},
-            FunctionInfo{1, nullptr, "RebootSystem"},
-            FunctionInfo{2, nullptr, "GetWakeupReason"},
-            FunctionInfo{3, nullptr, "GetShutdownReason"},
-            FunctionInfo{4, nullptr, "GetAcOk"},
-            FunctionInfo{5, nullptr, "GetPowerEvent"}
-        );
+    explicit BPC_C(Core::System& system_) : ServiceFramework{system_, "bpc:c"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "ShutdownSystem"},
+            {1, nullptr, "RebootSystem"},
+            {2, nullptr, "GetWakeupReason"},
+            {3, nullptr, "GetShutdownReason"},
+            {4, nullptr, "GetAcOk"},
+            {5, nullptr, "GetPowerEvent"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 
 class BPC_B final : public ServiceFramework<BPC_B> {
 public:
-    explicit BPC_B(Core::System& system_) : ServiceFramework{system_, "bpc:b"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "GetSleepButtonState"},
-            FunctionInfo{1, nullptr, "GetPowerButtonEvent"}
-        );
+    explicit BPC_B(Core::System& system_) : ServiceFramework{system_, "bpc:b"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "GetSleepButtonState"},
+            {1, nullptr, "GetPowerButtonEvent"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 
 class BPC_W final : public ServiceFramework<BPC_W> {
 public:
-    explicit BPC_W(Core::System& system_) : ServiceFramework{system_, "bpc:w"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "CreateWakeupTimer"},
-            FunctionInfo{1, nullptr, "CancelWakeupTimer"},
-            FunctionInfo{2, nullptr, "EnableWakeupTimerOnDevice"}
-        );
+    explicit BPC_W(Core::System& system_) : ServiceFramework{system_, "bpc:w"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "CreateWakeupTimer"},
+            {1, nullptr, "CancelWakeupTimer"},
+            {2, nullptr, "EnableWakeupTimerOnDevice"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 
 class BPC_AMS final : public ServiceFramework<BPC_AMS> {
 public:
-    explicit BPC_AMS(Core::System& system_) : ServiceFramework{system_, "bpc:ams"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{65000, nullptr, "RebootToFatalError"},
-            FunctionInfo{65001, nullptr, "SetRebootPayload"}
-        );
+    explicit BPC_AMS(Core::System& system_) : ServiceFramework{system_, "bpc:ams"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {65000, nullptr, "RebootToFatalError"},
+            {65001, nullptr, "SetRebootPayload"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 

src/core/hle/service/btdrv/btdrv.cpp

@@ -20,24 +20,24 @@ namespace Service::BtDrv {
 class IBluetoothUser final : public ServiceFramework<IBluetoothUser> {
 public:
     explicit IBluetoothUser(Core::System& system_)
-        : ServiceFramework{system_, "bt"}
-        , service_context{system_, "bt"} {
-        register_event = service_context.CreateEvent("BT:RegisterEvent");
-    }
+        : ServiceFramework{system_, "bt"}, service_context{system_, "bt"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "LeClientReadCharacteristic"},
+            {1, nullptr, "LeClientReadDescriptor"},
+            {2, nullptr, "LeClientWriteCharacteristic"},
+            {3, nullptr, "LeClientWriteDescriptor"},
+            {4, nullptr, "LeClientRegisterNotification"},
+            {5, nullptr, "LeClientDeregisterNotification"},
+            {6, nullptr, "SetLeResponse"},
+            {7, nullptr, "LeSendIndication"},
+            {8, nullptr, "GetLeEventInfo"},
+            {9, C<&IBluetoothUser::RegisterBleEvent>, "RegisterBleEvent"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "LeClientReadCharacteristic"},
-            FunctionInfo{1, nullptr, "LeClientReadDescriptor"},
-            FunctionInfo{2, nullptr, "LeClientWriteCharacteristic"},
-            FunctionInfo{3, nullptr, "LeClientWriteDescriptor"},
-            FunctionInfo{4, nullptr, "LeClientRegisterNotification"},
-            FunctionInfo{5, nullptr, "LeClientDeregisterNotification"},
-            FunctionInfo{6, nullptr, "SetLeResponse"},
-            FunctionInfo{7, nullptr, "LeSendIndication"},
-            FunctionInfo{8, nullptr, "GetLeEventInfo"},
-            FunctionInfo{9, C<&IBluetoothUser::RegisterBleEvent>, "RegisterBleEvent"}
-        );
+        register_event = service_context.CreateEvent("BT:RegisterEvent");
     }
 
     ~IBluetoothUser() override {
@@ -59,142 +59,144 @@ private:
 
 class IBluetoothDriver final : public ServiceFramework<IBluetoothDriver> {
 public:
-    explicit IBluetoothDriver(Core::System& system_) : ServiceFramework{system_, "btdrv"} {}
+    explicit IBluetoothDriver(Core::System& system_) : ServiceFramework{system_, "btdrv"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "InitializeBluetoothDriver"},
+            {1, nullptr, "InitializeBluetooth"},
+            {2, nullptr, "EnableBluetooth"},
+            {3, nullptr, "DisableBluetooth"},
+            {4, nullptr, "FinalizeBluetooth"},
+            {5, nullptr, "GetAdapterProperties"},
+            {6, nullptr, "GetAdapterProperty"},
+            {7, nullptr, "SetAdapterProperty"},
+            {8, nullptr, "StartInquiry"},
+            {9, nullptr, "StopInquiry"},
+            {10, nullptr, "CreateBond"},
+            {11, nullptr, "RemoveBond"},
+            {12, nullptr, "CancelBond"},
+            {13, nullptr, "RespondToPinRequest"},
+            {14, nullptr, "RespondToSspRequest"},
+            {15, nullptr, "GetEventInfo"},
+            {16, nullptr, "InitializeHid"},
+            {17, nullptr, "OpenHidConnection"},
+            {18, nullptr, "CloseHidConnection"},
+            {19, nullptr, "WriteHidData"},
+            {20, nullptr, "WriteHidData2"},
+            {21, nullptr, "SetHidReport"},
+            {22, nullptr, "GetHidReport"},
+            {23, nullptr, "TriggerConnection"},
+            {24, nullptr, "AddPairedDeviceInfo"},
+            {25, nullptr, "GetPairedDeviceInfo"},
+            {26, nullptr, "FinalizeHid"},
+            {27, nullptr, "GetHidEventInfo"},
+            {28, nullptr, "SetTsi"},
+            {29, nullptr, "EnableBurstMode"},
+            {30, nullptr, "SetZeroRetransmission"},
+            {31, nullptr, "EnableMcMode"},
+            {32, nullptr, "EnableLlrScan"},
+            {33, nullptr, "DisableLlrScan"},
+            {34, C<&IBluetoothDriver::EnableRadio>, "EnableRadio"},
+            {35, nullptr, "SetVisibility"},
+            {36, nullptr, "EnableTbfcScan"},
+            {37, nullptr, "RegisterHidReportEvent"},
+            {38, nullptr, "GetHidReportEventInfo"},
+            {39, nullptr, "GetLatestPlr"},
+            {40, nullptr, "GetPendingConnections"},
+            {41, nullptr, "GetChannelMap"},
+            {42, nullptr, "EnableTxPowerBoostSetting"},
+            {43, nullptr, "IsTxPowerBoostSettingEnabled"},
+            {44, nullptr, "EnableAfhSetting"},
+            {45, nullptr, "IsAfhSettingEnabled"},
+            {46, nullptr, "InitializeBle"},
+            {47, nullptr, "EnableBle"},
+            {48, nullptr, "DisableBle"},
+            {49, nullptr, "FinalizeBle"},
+            {50, nullptr, "SetBleVisibility"},
+            {51, nullptr, "SetBleConnectionParameter"},
+            {52, nullptr, "SetBleDefaultConnectionParameter"},
+            {53, nullptr, "SetBleAdvertiseData"},
+            {54, nullptr, "SetBleAdvertiseParameter"},
+            {55, nullptr, "StartBleScan"},
+            {56, nullptr, "StopBleScan"},
+            {57, nullptr, "AddBleScanFilterCondition"},
+            {58, nullptr, "DeleteBleScanFilterCondition"},
+            {59, nullptr, "DeleteBleScanFilter"},
+            {60, nullptr, "ClearBleScanFilters"},
+            {61, nullptr, "EnableBleScanFilter"},
+            {62, nullptr, "RegisterGattClient"},
+            {63, nullptr, "UnregisterGattClient"},
+            {64, nullptr, "UnregisterAllGattClients"},
+            {65, nullptr, "ConnectGattServer"},
+            {66, nullptr, "CancelConnectGattServer"},
+            {67, nullptr, "DisconnectGattServer"},
+            {68, nullptr, "GetGattAttribute"},
+            {69, nullptr, "GetGattService"},
+            {70, nullptr, "ConfigureAttMtu"},
+            {71, nullptr, "RegisterGattServer"},
+            {72, nullptr, "UnregisterGattServer"},
+            {73, nullptr, "ConnectGattClient"},
+            {74, nullptr, "DisconnectGattClient"},
+            {75, nullptr, "AddGattService"},
+            {76, nullptr, "EnableGattService"},
+            {77, nullptr, "AddGattCharacteristic"},
+            {78, nullptr, "AddGattDescriptor"},
+            {79, nullptr, "GetBleManagedEventInfo"},
+            {80, nullptr, "GetGattFirstCharacteristic"},
+            {81, nullptr, "GetGattNextCharacteristic"},
+            {82, nullptr, "GetGattFirstDescriptor"},
+            {83, nullptr, "GetGattNextDescriptor"},
+            {84, nullptr, "RegisterGattManagedDataPath"},
+            {85, nullptr, "UnregisterGattManagedDataPath"},
+            {86, nullptr, "RegisterGattHidDataPath"},
+            {87, nullptr, "UnregisterGattHidDataPath"},
+            {88, nullptr, "RegisterGattDataPath"},
+            {89, nullptr, "UnregisterGattDataPath"},
+            {90, nullptr, "ReadGattCharacteristic"},
+            {91, nullptr, "ReadGattDescriptor"},
+            {92, nullptr, "WriteGattCharacteristic"},
+            {93, nullptr, "WriteGattDescriptor"},
+            {94, nullptr, "RegisterGattNotification"},
+            {95, nullptr, "UnregisterGattNotification"},
+            {96, nullptr, "GetLeHidEventInfo"},
+            {97, nullptr, "RegisterBleHidEvent"},
+            {98, nullptr, "SetBleScanParameter"},
+            {99, nullptr, "MoveToSecondaryPiconet"},
+            {100, nullptr, "IsBluetoothEnabled"},
+            {128, nullptr, "AcquireAudioEvent"},
+            {129, nullptr, "GetAudioEventInfo"},
+            {130, nullptr, "OpenAudioConnection"},
+            {131, nullptr, "CloseAudioConnection"},
+            {132, nullptr, "OpenAudioOut"},
+            {133, nullptr, "CloseAudioOut"},
+            {134, nullptr, "AcquireAudioOutStateChangedEvent"},
+            {135, nullptr, "StartAudioOut"},
+            {136, nullptr, "StopAudioOut"},
+            {137, nullptr, "GetAudioOutState"},
+            {138, nullptr, "GetAudioOutFeedingCodec"},
+            {139, nullptr, "GetAudioOutFeedingParameter"},
+            {140, nullptr, "AcquireAudioOutBufferAvailableEvent"},
+            {141, nullptr, "SendAudioData"},
+            {142, nullptr, "AcquireAudioControlInputStateChangedEvent"},
+            {143, nullptr, "GetAudioControlInputState"},
+            {144, nullptr, "AcquireAudioConnectionStateChangedEvent"},
+            {145, nullptr, "GetConnectedAudioDevice"},
+            {146, nullptr, "CloseAudioControlInput"},
+            {147, nullptr, "RegisterAudioControlNotification"},
+            {148, nullptr, "SendAudioControlPassthroughCommand"},
+            {149, nullptr, "SendAudioControlSetAbsoluteVolumeCommand"},
+            {150, nullptr, "AcquireAudioSinkVolumeLocallyChangedEvent"},
+            {151, nullptr, "AcquireAudioSinkVolumeUpdateRequestCompletedEvent"},
+            {152, nullptr, "GetAudioSinkVolume"},
+            {153, nullptr, "RequestUpdateAudioSinkVolume"},
+            {154, nullptr, "IsAudioSinkVolumeSupported"},
+            {256, nullptr, "IsManufacturingMode"},
+            {257, nullptr, "EmulateBluetoothCrash"},
+            {258, nullptr, "GetBleChannelMap"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "InitializeBluetoothDriver"},
-            FunctionInfo{1, nullptr, "InitializeBluetooth"},
-            FunctionInfo{2, nullptr, "EnableBluetooth"},
-            FunctionInfo{3, nullptr, "DisableBluetooth"},
-            FunctionInfo{4, nullptr, "FinalizeBluetooth"},
-            FunctionInfo{5, nullptr, "GetAdapterProperties"},
-            FunctionInfo{6, nullptr, "GetAdapterProperty"},
-            FunctionInfo{7, nullptr, "SetAdapterProperty"},
-            FunctionInfo{8, nullptr, "StartInquiry"},
-            FunctionInfo{9, nullptr, "StopInquiry"},
-            FunctionInfo{10, nullptr, "CreateBond"},
-            FunctionInfo{11, nullptr, "RemoveBond"},
-            FunctionInfo{12, nullptr, "CancelBond"},
-            FunctionInfo{13, nullptr, "RespondToPinRequest"},
-            FunctionInfo{14, nullptr, "RespondToSspRequest"},
-            FunctionInfo{15, nullptr, "GetEventInfo"},
-            FunctionInfo{16, nullptr, "InitializeHid"},
-            FunctionInfo{17, nullptr, "OpenHidConnection"},
-            FunctionInfo{18, nullptr, "CloseHidConnection"},
-            FunctionInfo{19, nullptr, "WriteHidData"},
-            FunctionInfo{20, nullptr, "WriteHidData2"},
-            FunctionInfo{21, nullptr, "SetHidReport"},
-            FunctionInfo{22, nullptr, "GetHidReport"},
-            FunctionInfo{23, nullptr, "TriggerConnection"},
-            FunctionInfo{24, nullptr, "AddPairedDeviceInfo"},
-            FunctionInfo{25, nullptr, "GetPairedDeviceInfo"},
-            FunctionInfo{26, nullptr, "FinalizeHid"},
-            FunctionInfo{27, nullptr, "GetHidEventInfo"},
-            FunctionInfo{28, nullptr, "SetTsi"},
-            FunctionInfo{29, nullptr, "EnableBurstMode"},
-            FunctionInfo{30, nullptr, "SetZeroRetransmission"},
-            FunctionInfo{31, nullptr, "EnableMcMode"},
-            FunctionInfo{32, nullptr, "EnableLlrScan"},
-            FunctionInfo{33, nullptr, "DisableLlrScan"},
-            FunctionInfo{34, C<&IBluetoothDriver::EnableRadio>, "EnableRadio"},
-            FunctionInfo{35, nullptr, "SetVisibility"},
-            FunctionInfo{36, nullptr, "EnableTbfcScan"},
-            FunctionInfo{37, nullptr, "RegisterHidReportEvent"},
-            FunctionInfo{38, nullptr, "GetHidReportEventInfo"},
-            FunctionInfo{39, nullptr, "GetLatestPlr"},
-            FunctionInfo{40, nullptr, "GetPendingConnections"},
-            FunctionInfo{41, nullptr, "GetChannelMap"},
-            FunctionInfo{42, nullptr, "EnableTxPowerBoostSetting"},
-            FunctionInfo{43, nullptr, "IsTxPowerBoostSettingEnabled"},
-            FunctionInfo{44, nullptr, "EnableAfhSetting"},
-            FunctionInfo{45, nullptr, "IsAfhSettingEnabled"},
-            FunctionInfo{46, nullptr, "InitializeBle"},
-            FunctionInfo{47, nullptr, "EnableBle"},
-            FunctionInfo{48, nullptr, "DisableBle"},
-            FunctionInfo{49, nullptr, "FinalizeBle"},
-            FunctionInfo{50, nullptr, "SetBleVisibility"},
-            FunctionInfo{51, nullptr, "SetBleConnectionParameter"},
-            FunctionInfo{52, nullptr, "SetBleDefaultConnectionParameter"},
-            FunctionInfo{53, nullptr, "SetBleAdvertiseData"},
-            FunctionInfo{54, nullptr, "SetBleAdvertiseParameter"},
-            FunctionInfo{55, nullptr, "StartBleScan"},
-            FunctionInfo{56, nullptr, "StopBleScan"},
-            FunctionInfo{57, nullptr, "AddBleScanFilterCondition"},
-            FunctionInfo{58, nullptr, "DeleteBleScanFilterCondition"},
-            FunctionInfo{59, nullptr, "DeleteBleScanFilter"},
-            FunctionInfo{60, nullptr, "ClearBleScanFilters"},
-            FunctionInfo{61, nullptr, "EnableBleScanFilter"},
-            FunctionInfo{62, nullptr, "RegisterGattClient"},
-            FunctionInfo{63, nullptr, "UnregisterGattClient"},
-            FunctionInfo{64, nullptr, "UnregisterAllGattClients"},
-            FunctionInfo{65, nullptr, "ConnectGattServer"},
-            FunctionInfo{66, nullptr, "CancelConnectGattServer"},
-            FunctionInfo{67, nullptr, "DisconnectGattServer"},
-            FunctionInfo{68, nullptr, "GetGattAttribute"},
-            FunctionInfo{69, nullptr, "GetGattService"},
-            FunctionInfo{70, nullptr, "ConfigureAttMtu"},
-            FunctionInfo{71, nullptr, "RegisterGattServer"},
-            FunctionInfo{72, nullptr, "UnregisterGattServer"},
-            FunctionInfo{73, nullptr, "ConnectGattClient"},
-            FunctionInfo{74, nullptr, "DisconnectGattClient"},
-            FunctionInfo{75, nullptr, "AddGattService"},
-            FunctionInfo{76, nullptr, "EnableGattService"},
-            FunctionInfo{77, nullptr, "AddGattCharacteristic"},
-            FunctionInfo{78, nullptr, "AddGattDescriptor"},
-            FunctionInfo{79, nullptr, "GetBleManagedEventInfo"},
-            FunctionInfo{80, nullptr, "GetGattFirstCharacteristic"},
-            FunctionInfo{81, nullptr, "GetGattNextCharacteristic"},
-            FunctionInfo{82, nullptr, "GetGattFirstDescriptor"},
-            FunctionInfo{83, nullptr, "GetGattNextDescriptor"},
-            FunctionInfo{84, nullptr, "RegisterGattManagedDataPath"},
-            FunctionInfo{85, nullptr, "UnregisterGattManagedDataPath"},
-            FunctionInfo{86, nullptr, "RegisterGattHidDataPath"},
-            FunctionInfo{87, nullptr, "UnregisterGattHidDataPath"},
-            FunctionInfo{88, nullptr, "RegisterGattDataPath"},
-            FunctionInfo{89, nullptr, "UnregisterGattDataPath"},
-            FunctionInfo{90, nullptr, "ReadGattCharacteristic"},
-            FunctionInfo{91, nullptr, "ReadGattDescriptor"},
-            FunctionInfo{92, nullptr, "WriteGattCharacteristic"},
-            FunctionInfo{93, nullptr, "WriteGattDescriptor"},
-            FunctionInfo{94, nullptr, "RegisterGattNotification"},
-            FunctionInfo{95, nullptr, "UnregisterGattNotification"},
-            FunctionInfo{96, nullptr, "GetLeHidEventInfo"},
-            FunctionInfo{97, nullptr, "RegisterBleHidEvent"},
-            FunctionInfo{98, nullptr, "SetBleScanParameter"},
-            FunctionInfo{99, nullptr, "MoveToSecondaryPiconet"},
-            FunctionInfo{100, nullptr, "IsBluetoothEnabled"},
-            FunctionInfo{128, nullptr, "AcquireAudioEvent"},
-            FunctionInfo{129, nullptr, "GetAudioEventInfo"},
-            FunctionInfo{130, nullptr, "OpenAudioConnection"},
-            FunctionInfo{131, nullptr, "CloseAudioConnection"},
-            FunctionInfo{132, nullptr, "OpenAudioOut"},
-            FunctionInfo{133, nullptr, "CloseAudioOut"},
-            FunctionInfo{134, nullptr, "AcquireAudioOutStateChangedEvent"},
-            FunctionInfo{135, nullptr, "StartAudioOut"},
-            FunctionInfo{136, nullptr, "StopAudioOut"},
-            FunctionInfo{137, nullptr, "GetAudioOutState"},
-            FunctionInfo{138, nullptr, "GetAudioOutFeedingCodec"},
-            FunctionInfo{139, nullptr, "GetAudioOutFeedingParameter"},
-            FunctionInfo{140, nullptr, "AcquireAudioOutBufferAvailableEvent"},
-            FunctionInfo{141, nullptr, "SendAudioData"},
-            FunctionInfo{142, nullptr, "AcquireAudioControlInputStateChangedEvent"},
-            FunctionInfo{143, nullptr, "GetAudioControlInputState"},
-            FunctionInfo{144, nullptr, "AcquireAudioConnectionStateChangedEvent"},
-            FunctionInfo{145, nullptr, "GetConnectedAudioDevice"},
-            FunctionInfo{146, nullptr, "CloseAudioControlInput"},
-            FunctionInfo{147, nullptr, "RegisterAudioControlNotification"},
-            FunctionInfo{148, nullptr, "SendAudioControlPassthroughCommand"},
-            FunctionInfo{149, nullptr, "SendAudioControlSetAbsoluteVolumeCommand"},
-            FunctionInfo{150, nullptr, "AcquireAudioSinkVolumeLocallyChangedEvent"},
-            FunctionInfo{151, nullptr, "AcquireAudioSinkVolumeUpdateRequestCompletedEvent"},
-            FunctionInfo{152, nullptr, "GetAudioSinkVolume"},
-            FunctionInfo{153, nullptr, "RequestUpdateAudioSinkVolume"},
-            FunctionInfo{154, nullptr, "IsAudioSinkVolumeSupported"},
-            FunctionInfo{256, nullptr, "IsManufacturingMode"},
-            FunctionInfo{257, nullptr, "EmulateBluetoothCrash"},
-            FunctionInfo{258, nullptr, "GetBleChannelMap"}
-        );
+        RegisterHandlers(functions);
     }
 
 private:

src/core/hle/service/btm/btm.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
@@ -17,98 +17,100 @@ namespace Service::BTM {
 
 class IBtm final : public ServiceFramework<IBtm> {
 public:
-    explicit IBtm(Core::System& system_) : ServiceFramework{system_, "btm"} {}
+    explicit IBtm(Core::System& system_) : ServiceFramework{system_, "btm"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "GetState"},
+            {1, nullptr, "GetHostDeviceProperty"},
+            {2, nullptr, "AcquireDeviceConditionEvent"},
+            {3, nullptr, "GetDeviceCondition"},
+            {4, nullptr, "SetBurstMode"},
+            {5, nullptr, "SetSlotMode"},
+            {6, nullptr, "SetBluetoothMode"},
+            {7, nullptr, "SetWlanMode"},
+            {8, nullptr, "AcquireDeviceInfoEvent"},
+            {9, nullptr, "GetDeviceInfo"},
+            {10, nullptr, "AddDeviceInfo"},
+            {11, nullptr, "RemoveDeviceInfo"},
+            {12, nullptr, "IncreaseDeviceInfoOrder"},
+            {13, nullptr, "LlrNotify"},
+            {14, nullptr, "EnableRadio"},
+            {15, nullptr, "DisableRadio"},
+            {16, nullptr, "HidDisconnect"},
+            {17, nullptr, "HidSetRetransmissionMode"},
+            {18, nullptr, "AcquireAwakeReqEvent"},
+            {19, nullptr, "AcquireLlrStateEvent"},
+            {20, nullptr, "IsLlrStarted"},
+            {21, nullptr, "EnableSlotSaving"},
+            {22, nullptr, "ProtectDeviceInfo"},
+            {23, nullptr, "AcquireBleScanEvent"},
+            {24, nullptr, "GetBleScanParameterGeneral"},
+            {25, nullptr, "GetBleScanParameterSmartDevice"},
+            {26, nullptr, "StartBleScanForGeneral"},
+            {27, nullptr, "StopBleScanForGeneral"},
+            {28, nullptr, "GetBleScanResultsForGeneral"},
+            {29, nullptr, "StartBleScanForPairedDevice"},
+            {30, nullptr, "StopBleScanForPairedDevice"},
+            {31, nullptr, "StartBleScanForSmartDevice"},
+            {32, nullptr, "StopBleScanForSmartDevice"},
+            {33, nullptr, "GetBleScanResultsForSmartDevice"},
+            {34, nullptr, "AcquireBleConnectionEvent"},
+            {35, nullptr, "BleConnect"},
+            {36, nullptr, "BleOverrideConnection"},
+            {37, nullptr, "BleDisconnect"},
+            {38, nullptr, "BleGetConnectionState"},
+            {39, nullptr, "BleGetGattClientConditionList"},
+            {40, nullptr, "AcquireBlePairingEvent"},
+            {41, nullptr, "BlePairDevice"},
+            {42, nullptr, "BleUnpairDeviceOnBoth"},
+            {43, nullptr, "BleUnpairDevice"},
+            {44, nullptr, "BleGetPairedAddresses"},
+            {45, nullptr, "AcquireBleServiceDiscoveryEvent"},
+            {46, nullptr, "GetGattServices"},
+            {47, nullptr, "GetGattService"},
+            {48, nullptr, "GetGattIncludedServices"},
+            {49, nullptr, "GetBelongingService"},
+            {50, nullptr, "GetGattCharacteristics"},
+            {51, nullptr, "GetGattDescriptors"},
+            {52, nullptr, "AcquireBleMtuConfigEvent"},
+            {53, nullptr, "ConfigureBleMtu"},
+            {54, nullptr, "GetBleMtu"},
+            {55, nullptr, "RegisterBleGattDataPath"},
+            {56, nullptr, "UnregisterBleGattDataPath"},
+            {57, nullptr, "RegisterAppletResourceUserId"},
+            {58, nullptr, "UnregisterAppletResourceUserId"},
+            {59, nullptr, "SetAppletResourceUserId"},
+            {60, nullptr, "AcquireBleConnectionParameterUpdateEvent"}, //8.0.0+
+            {61, nullptr, "SetCeLength"}, //8.0.0+
+            {62, nullptr, "EnsureSlotExpansion"}, //9.0.0+
+            {63, nullptr, "IsSlotExpansionEnsured"}, //9.0.0+
+            {64, nullptr, "CancelConnectionTrigger"}, //10.0.0+
+            {65, nullptr, "GetConnectionCapacity"}, //13.0.0+
+            {66, nullptr, "GetWlanMode"}, //13.0.0+
+            {67, nullptr, "IsSlotSavingEnabled"}, //13.0.0+
+            {68, nullptr, "IsSlotSavingForPairingEnabled"}, //13.0.0+
+            {69, nullptr, "AcquireAudioDeviceConnectionEvent"}, //13.0.0+
+            {70, nullptr, "GetConnectedAudioDevices"}, //13.0.0+
+            {71, nullptr, "SetAudioSourceVolume"}, //13.0.0+
+            {72, nullptr, "GetAudioSourceVolume"}, //13.0.0+
+            {73, nullptr, "RequestAudioDeviceConnectionRejection"}, //13.0.0+
+            {74, nullptr, "CancelAudioDeviceConnectionRejection"}, //13.0.0+
+            {75, nullptr, "GetPairedAudioDevices"}, //13.0.0+
+            {76, nullptr, "SetWlanModeWithOption"}, //13.1.0+
+            {100, nullptr, "AcquireConnectionDisallowedEvent"}, //13.0.0+
+            {101, nullptr, "GetUsecaseViolationFactor"}, //13.0.0+
+            {110, nullptr, "GetShortenedDeviceInfo"}, //13.0.0+
+            {111, nullptr, "AcquirePairingCountUpdateEvent"},//13.0.0+
+            {112, nullptr, "Unknown112"}, //14.0.0-14.1.2
+            {113, nullptr, "Unknown113"}, //14.0.0-14.1.2
+            {114, nullptr, "IsFirstAudioControlConnection"}, //14.0.0+
+            {115, nullptr, "GetShortenedDeviceCondition"}, //14.0.0+
+            {116, nullptr, "SetAudioSinkVolume"}, //15.0.0+
+            {117, nullptr, "GetAudioSinkVolume"}, //15.0.0+
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "GetState"},
-            FunctionInfo{1, nullptr, "GetHostDeviceProperty"},
-            FunctionInfo{2, nullptr, "AcquireDeviceConditionEvent"},
-            FunctionInfo{3, nullptr, "GetDeviceCondition"},
-            FunctionInfo{4, nullptr, "SetBurstMode"},
-            FunctionInfo{5, nullptr, "SetSlotMode"},
-            FunctionInfo{6, nullptr, "SetBluetoothMode"},
-            FunctionInfo{7, nullptr, "SetWlanMode"},
-            FunctionInfo{8, nullptr, "AcquireDeviceInfoEvent"},
-            FunctionInfo{9, nullptr, "GetDeviceInfo"},
-            FunctionInfo{10, nullptr, "AddDeviceInfo"},
-            FunctionInfo{11, nullptr, "RemoveDeviceInfo"},
-            FunctionInfo{12, nullptr, "IncreaseDeviceInfoOrder"},
-            FunctionInfo{13, nullptr, "LlrNotify"},
-            FunctionInfo{14, nullptr, "EnableRadio"},
-            FunctionInfo{15, nullptr, "DisableRadio"},
-            FunctionInfo{16, nullptr, "HidDisconnect"},
-            FunctionInfo{17, nullptr, "HidSetRetransmissionMode"},
-            FunctionInfo{18, nullptr, "AcquireAwakeReqEvent"},
-            FunctionInfo{19, nullptr, "AcquireLlrStateEvent"},
-            FunctionInfo{20, nullptr, "IsLlrStarted"},
-            FunctionInfo{21, nullptr, "EnableSlotSaving"},
-            FunctionInfo{22, nullptr, "ProtectDeviceInfo"},
-            FunctionInfo{23, nullptr, "AcquireBleScanEvent"},
-            FunctionInfo{24, nullptr, "GetBleScanParameterGeneral"},
-            FunctionInfo{25, nullptr, "GetBleScanParameterSmartDevice"},
-            FunctionInfo{26, nullptr, "StartBleScanForGeneral"},
-            FunctionInfo{27, nullptr, "StopBleScanForGeneral"},
-            FunctionInfo{28, nullptr, "GetBleScanResultsForGeneral"},
-            FunctionInfo{29, nullptr, "StartBleScanForPairedDevice"},
-            FunctionInfo{30, nullptr, "StopBleScanForPairedDevice"},
-            FunctionInfo{31, nullptr, "StartBleScanForSmartDevice"},
-            FunctionInfo{32, nullptr, "StopBleScanForSmartDevice"},
-            FunctionInfo{33, nullptr, "GetBleScanResultsForSmartDevice"},
-            FunctionInfo{34, nullptr, "AcquireBleConnectionEvent"},
-            FunctionInfo{35, nullptr, "BleConnect"},
-            FunctionInfo{36, nullptr, "BleOverrideConnection"},
-            FunctionInfo{37, nullptr, "BleDisconnect"},
-            FunctionInfo{38, nullptr, "BleGetConnectionState"},
-            FunctionInfo{39, nullptr, "BleGetGattClientConditionList"},
-            FunctionInfo{40, nullptr, "AcquireBlePairingEvent"},
-            FunctionInfo{41, nullptr, "BlePairDevice"},
-            FunctionInfo{42, nullptr, "BleUnpairDeviceOnBoth"},
-            FunctionInfo{43, nullptr, "BleUnpairDevice"},
-            FunctionInfo{44, nullptr, "BleGetPairedAddresses"},
-            FunctionInfo{45, nullptr, "AcquireBleServiceDiscoveryEvent"},
-            FunctionInfo{46, nullptr, "GetGattServices"},
-            FunctionInfo{47, nullptr, "GetGattService"},
-            FunctionInfo{48, nullptr, "GetGattIncludedServices"},
-            FunctionInfo{49, nullptr, "GetBelongingService"},
-            FunctionInfo{50, nullptr, "GetGattCharacteristics"},
-            FunctionInfo{51, nullptr, "GetGattDescriptors"},
-            FunctionInfo{52, nullptr, "AcquireBleMtuConfigEvent"},
-            FunctionInfo{53, nullptr, "ConfigureBleMtu"},
-            FunctionInfo{54, nullptr, "GetBleMtu"},
-            FunctionInfo{55, nullptr, "RegisterBleGattDataPath"},
-            FunctionInfo{56, nullptr, "UnregisterBleGattDataPath"},
-            FunctionInfo{57, nullptr, "RegisterAppletResourceUserId"},
-            FunctionInfo{58, nullptr, "UnregisterAppletResourceUserId"},
-            FunctionInfo{59, nullptr, "SetAppletResourceUserId"},
-            FunctionInfo{60, nullptr, "AcquireBleConnectionParameterUpdateEvent"}, //8.0.0+
-            FunctionInfo{61, nullptr, "SetCeLength"}, //8.0.0+
-            FunctionInfo{62, nullptr, "EnsureSlotExpansion"}, //9.0.0+
-            FunctionInfo{63, nullptr, "IsSlotExpansionEnsured"}, //9.0.0+
-            FunctionInfo{64, nullptr, "CancelConnectionTrigger"}, //10.0.0+
-            FunctionInfo{65, nullptr, "GetConnectionCapacity"}, //13.0.0+
-            FunctionInfo{66, nullptr, "GetWlanMode"}, //13.0.0+
-            FunctionInfo{67, nullptr, "IsSlotSavingEnabled"}, //13.0.0+
-            FunctionInfo{68, nullptr, "IsSlotSavingForPairingEnabled"}, //13.0.0+
-            FunctionInfo{69, nullptr, "AcquireAudioDeviceConnectionEvent"}, //13.0.0+
-            FunctionInfo{70, nullptr, "GetConnectedAudioDevices"}, //13.0.0+
-            FunctionInfo{71, nullptr, "SetAudioSourceVolume"}, //13.0.0+
-            FunctionInfo{72, nullptr, "GetAudioSourceVolume"}, //13.0.0+
-            FunctionInfo{73, nullptr, "RequestAudioDeviceConnectionRejection"}, //13.0.0+
-            FunctionInfo{74, nullptr, "CancelAudioDeviceConnectionRejection"}, //13.0.0+
-            FunctionInfo{75, nullptr, "GetPairedAudioDevices"}, //13.0.0+
-            FunctionInfo{76, nullptr, "SetWlanModeWithOption"}, //13.1.0+
-            FunctionInfo{100, nullptr, "AcquireConnectionDisallowedEvent"}, //13.0.0+
-            FunctionInfo{101, nullptr, "GetUsecaseViolationFactor"}, //13.0.0+
-            FunctionInfo{110, nullptr, "GetShortenedDeviceInfo"}, //13.0.0+
-            FunctionInfo{111, nullptr, "AcquirePairingCountUpdateEvent"},//13.0.0+
-            FunctionInfo{112, nullptr, "Unknown112"}, //14.0.0-14.1.2
-            FunctionInfo{113, nullptr, "Unknown113"}, //14.0.0-14.1.2
-            FunctionInfo{114, nullptr, "IsFirstAudioControlConnection"}, //14.0.0+
-            FunctionInfo{115, nullptr, "GetShortenedDeviceCondition"}, //14.0.0+
-            FunctionInfo{116, nullptr, "SetAudioSinkVolume"}, //15.0.0+
-            FunctionInfo{117, nullptr, "GetAudioSinkVolume"} //15.0.0+
-        );
+        RegisterHandlers(functions);
     }
 };
 

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

@@ -20,14 +20,15 @@ namespace Service::Capture {
 
 class IDecoderControlService final : public ServiceFramework<IDecoderControlService> {
 public:
-    explicit IDecoderControlService(Core::System& system_) : ServiceFramework{system_, "grc:d"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{3001, nullptr, "DecodeJpeg"},
-            FunctionInfo{4001, nullptr, "ShrinkJpeg"},
-            FunctionInfo{4002, nullptr, "ShrinkJpegEx"}
-        );
+    explicit IDecoderControlService(Core::System& system_) : ServiceFramework{system_, "grc:d"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {3001, nullptr, "DecodeJpeg"},
+            {4001, nullptr, "ShrinkJpeg"},
+            {4002, nullptr, "ShrinkJpegEx"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 

src/core/hle/service/erpt/erpt.cpp

@@ -17,28 +17,30 @@ namespace Service::ERPT {
 
 class ErrorReportContext final : public ServiceFramework<ErrorReportContext> {
 public:
-    explicit ErrorReportContext(Core::System& system_) : ServiceFramework{system_, "erpt:c"} {}
+    explicit ErrorReportContext(Core::System& system_) : ServiceFramework{system_, "erpt:c"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, C<&ErrorReportContext::SubmitContext>, "SubmitContext"},
+            {1, C<&ErrorReportContext::CreateReportV0>, "CreateReportV0"},
+            {2, nullptr, "SetInitialLaunchSettingsCompletionTime"},
+            {3, nullptr, "ClearInitialLaunchSettingsCompletionTime"},
+            {4, nullptr, "UpdatePowerOnTime"},
+            {5, D<&ErrorReportContext::UpdateAwakeTime>, "UpdateAwakeTime"},
+            {6, nullptr, "SubmitMultipleCategoryContext"},
+            {7, nullptr, "UpdateApplicationLaunchTime"},
+            {8, nullptr, "ClearApplicationLaunchTime"},
+            {9, nullptr, "SubmitAttachment"},
+            {10, nullptr, "CreateReportWithAttachments"},
+            {11, C<&ErrorReportContext::CreateReportV1>, "CreateReportV1"},
+            {12, C<&ErrorReportContext::CreateReport>, "CreateReport"},
+            {20, nullptr, "RegisterRunningApplet"},
+            {21, nullptr, "UnregisterRunningApplet"},
+            {22, nullptr, "UpdateAppletSuspendedDuration"},
+            {30, nullptr, "InvalidateForcedShutdownDetection"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, C<&ErrorReportContext::SubmitContext>, "SubmitContext"},
-            FunctionInfo{1, C<&ErrorReportContext::CreateReportV0>, "CreateReportV0"},
-            FunctionInfo{2, nullptr, "SetInitialLaunchSettingsCompletionTime"},
-            FunctionInfo{3, nullptr, "ClearInitialLaunchSettingsCompletionTime"},
-            FunctionInfo{4, nullptr, "UpdatePowerOnTime"},
-            FunctionInfo{5, D<&ErrorReportContext::UpdateAwakeTime>, "UpdateAwakeTime"},
-            FunctionInfo{6, nullptr, "SubmitMultipleCategoryContext"},
-            FunctionInfo{7, nullptr, "UpdateApplicationLaunchTime"},
-            FunctionInfo{8, nullptr, "ClearApplicationLaunchTime"},
-            FunctionInfo{9, nullptr, "SubmitAttachment"},
-            FunctionInfo{10, nullptr, "CreateReportWithAttachments"},
-            FunctionInfo{11, C<&ErrorReportContext::CreateReportV1>, "CreateReportV1"},
-            FunctionInfo{12, C<&ErrorReportContext::CreateReport>, "CreateReport"},
-            FunctionInfo{20, nullptr, "RegisterRunningApplet"},
-            FunctionInfo{21, nullptr, "UnregisterRunningApplet"},
-            FunctionInfo{22, nullptr, "UpdateAppletSuspendedDuration"},
-            FunctionInfo{30, nullptr, "InvalidateForcedShutdownDetection"}
-        );
+        RegisterHandlers(functions);
     }
 
 private:
@@ -87,14 +89,16 @@ private:
 
 class ErrorReportSession final : public ServiceFramework<ErrorReportSession> {
 public:
-    explicit ErrorReportSession(Core::System& system_) : ServiceFramework{system_, "erpt:r"} {}
+    explicit ErrorReportSession(Core::System& system_) : ServiceFramework{system_, "erpt:r"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "OpenReport"},
+            {1, nullptr, "OpenManager"},
+            {2, nullptr, "OpenAttachment"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "OpenReport"},
-            FunctionInfo{1, nullptr, "OpenManager"},
-            FunctionInfo{2, nullptr, "OpenAttachment"}
-        );
+        RegisterHandlers(functions);
     }
 };
 

src/core/hle/service/es/es.cpp

@@ -19,109 +19,110 @@ constexpr Result ERROR_INVALID_RIGHTS_ID{ErrorModule::ETicket, 3};
 class ETicket final : public ServiceFramework<ETicket> {
 public:
     explicit ETicket(Core::System& system_) : ServiceFramework{system_, "es"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {1, &ETicket::ImportTicket, "ImportTicket"},
+            {2, nullptr, "ImportTicketCertificateSet"},
+            {3, nullptr, "DeleteTicket"},
+            {4, nullptr, "DeletePersonalizedTicket"},
+            {5, nullptr, "DeleteAllCommonTicket"},
+            {6, nullptr, "DeleteAllPersonalizedTicket"},
+            {7, nullptr, "DeleteAllPersonalizedTicketEx"},
+            {8, &ETicket::GetTitleKey, "GetTitleKey"},
+            {9, &ETicket::CountCommonTicket, "CountCommonTicket"},
+            {10, &ETicket::CountPersonalizedTicket, "CountPersonalizedTicket"},
+            {11, &ETicket::ListCommonTicketRightsIds, "ListCommonTicketRightsIds"},
+            {12, &ETicket::ListPersonalizedTicketRightsIds, "ListPersonalizedTicketRightsIds"},
+            {13, nullptr, "ListMissingPersonalizedTicket"},
+            {14, &ETicket::GetCommonTicketSize, "GetCommonTicketSize"},
+            {15, &ETicket::GetPersonalizedTicketSize, "GetPersonalizedTicketSize"},
+            {16, &ETicket::GetCommonTicketData, "GetCommonTicketData"},
+            {17, &ETicket::GetPersonalizedTicketData, "GetPersonalizedTicketData"},
+            {18, nullptr, "OwnTicket"},
+            {19, nullptr, "GetTicketInfo"},
+            {20, nullptr, "ListLightTicketInfo"},
+            {21, nullptr, "SignData"},
+            {22, nullptr, "GetCommonTicketAndCertificateSize"},
+            {23, nullptr, "GetCommonTicketAndCertificateData"},
+            {24, nullptr, "ImportPrepurchaseRecord"},
+            {25, nullptr, "DeletePrepurchaseRecord"},
+            {26, nullptr, "DeleteAllPrepurchaseRecord"},
+            {27, nullptr, "CountPrepurchaseRecord"},
+            {28, nullptr, "ListPrepurchaseRecordRightsIds"},
+            {29, nullptr, "ListPrepurchaseRecordInfo"},
+            {30, nullptr, "CountTicket"},
+            {31, nullptr, "ListTicketRightsIds"},
+            {32, nullptr, "CountPrepurchaseRecordEx"},
+            {33, nullptr, "ListPrepurchaseRecordRightsIdsEx"},
+            {34, nullptr, "GetEncryptedTicketSize"},
+            {35, nullptr, "GetEncryptedTicketData"},
+            {36, nullptr, "DeleteAllInactiveELicenseRequiredPersonalizedTicket"},
+            {37, nullptr, "OwnTicket2"},
+            {38, nullptr, "OwnTicket3"},
+            {39, nullptr, "DeleteAllInactivePersonalizedTicket"},
+            {40, nullptr, "DeletePrepurchaseRecordByNintendoAccountId"},
+            {101, nullptr, "Unknown101"}, //18.0.0+
+            {102, nullptr, "Unknown102"}, //18.0.0+
+            {103, nullptr, "Unknown103"}, //18.0.0+
+            {104, nullptr, "Unknown104"}, //18.0.0+
+            {105, nullptr, "Unknown105"}, //20.0.0+
+            {201, nullptr, "Unknown201"}, //18.0.0+
+            {202, nullptr, "Unknown202"}, //18.0.0+
+            {203, nullptr, "Unknown203"}, //18.0.0+
+            {204, nullptr, "Unknown204"}, //18.0.0+
+            {205, nullptr, "Unknown205"}, //18.0.0+
+            {501, nullptr, "Unknown501"},
+            {502, nullptr, "Unknown502"},
+            {503, nullptr, "GetTitleKey"},
+            {504, nullptr, "Unknown504"},
+            {508, nullptr, "Unknown508"},
+            {509, nullptr, "Unknown509"},
+            {510, nullptr, "Unknown510"},
+            {511, nullptr, "Unknown511"},
+            {1001, nullptr, "Unknown1001"},
+            {1002, nullptr, "Unknown1001"},
+            {1003, nullptr, "Unknown1003"},
+            {1004, nullptr, "Unknown1004"},
+            {1005, nullptr, "Unknown1005"},
+            {1006, nullptr, "Unknown1006"},
+            {1007, nullptr, "Unknown1007"},
+            {1009, nullptr, "Unknown1009"},
+            {1010, nullptr, "Unknown1010"},
+            {1011, nullptr, "Unknown1011"},
+            {1012, nullptr, "Unknown1012"},
+            {1013, nullptr, "Unknown1013"},
+            {1014, nullptr, "Unknown1014"},
+            {1015, nullptr, "Unknown1015"},
+            {1016, nullptr, "Unknown1016"},
+            {1017, nullptr, "Unknown1017"},
+            {1018, nullptr, "Unknown1018"},
+            {1019, nullptr, "Unknown1019"},
+            {1020, nullptr, "Unknown1020"},
+            {1021, nullptr, "Unknown1021"},
+            {1501, nullptr, "Unknown1501"},
+            {1502, nullptr, "Unknown1502"},
+            {1503, nullptr, "Unknown1503"},
+            {1504, nullptr, "Unknown1504"},
+            {1505, nullptr, "Unknown1505"},
+            {1506, nullptr, "Unknown1506"},
+            {2000, nullptr, "Unknown2000"},
+            {2001, nullptr, "Unknown2001"},
+            {2002, nullptr, "Unknown2002"},
+            {2003, nullptr, "Unknown2003"},
+            {2100, nullptr, "Unknown2100"},
+            {2501, nullptr, "Unknown2501"},
+            {2502, nullptr, "Unknown2502"},
+            {2601, nullptr, "Unknown2601"},
+            {3001, nullptr, "Unknown3001"},
+            {3002, nullptr, "Unknown3002"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
+
         keys.PopulateTickets();
         keys.SynthesizeTickets();
     }
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{1, &ETicket::ImportTicket, "ImportTicket"},
-            FunctionInfo{2, nullptr, "ImportTicketCertificateSet"},
-            FunctionInfo{3, nullptr, "DeleteTicket"},
-            FunctionInfo{4, nullptr, "DeletePersonalizedTicket"},
-            FunctionInfo{5, nullptr, "DeleteAllCommonTicket"},
-            FunctionInfo{6, nullptr, "DeleteAllPersonalizedTicket"},
-            FunctionInfo{7, nullptr, "DeleteAllPersonalizedTicketEx"},
-            FunctionInfo{8, &ETicket::GetTitleKey, "GetTitleKey"},
-            FunctionInfo{9, &ETicket::CountCommonTicket, "CountCommonTicket"},
-            FunctionInfo{10, &ETicket::CountPersonalizedTicket, "CountPersonalizedTicket"},
-            FunctionInfo{11, &ETicket::ListCommonTicketRightsIds, "ListCommonTicketRightsIds"},
-            FunctionInfo{12, &ETicket::ListPersonalizedTicketRightsIds, "ListPersonalizedTicketRightsIds"},
-            FunctionInfo{13, nullptr, "ListMissingPersonalizedTicket"},
-            FunctionInfo{14, &ETicket::GetCommonTicketSize, "GetCommonTicketSize"},
-            FunctionInfo{15, &ETicket::GetPersonalizedTicketSize, "GetPersonalizedTicketSize"},
-            FunctionInfo{16, &ETicket::GetCommonTicketData, "GetCommonTicketData"},
-            FunctionInfo{17, &ETicket::GetPersonalizedTicketData, "GetPersonalizedTicketData"},
-            FunctionInfo{18, nullptr, "OwnTicket"},
-            FunctionInfo{19, nullptr, "GetTicketInfo"},
-            FunctionInfo{20, nullptr, "ListLightTicketInfo"},
-            FunctionInfo{21, nullptr, "SignData"},
-            FunctionInfo{22, nullptr, "GetCommonTicketAndCertificateSize"},
-            FunctionInfo{23, nullptr, "GetCommonTicketAndCertificateData"},
-            FunctionInfo{24, nullptr, "ImportPrepurchaseRecord"},
-            FunctionInfo{25, nullptr, "DeletePrepurchaseRecord"},
-            FunctionInfo{26, nullptr, "DeleteAllPrepurchaseRecord"},
-            FunctionInfo{27, nullptr, "CountPrepurchaseRecord"},
-            FunctionInfo{28, nullptr, "ListPrepurchaseRecordRightsIds"},
-            FunctionInfo{29, nullptr, "ListPrepurchaseRecordInfo"},
-            FunctionInfo{30, nullptr, "CountTicket"},
-            FunctionInfo{31, nullptr, "ListTicketRightsIds"},
-            FunctionInfo{32, nullptr, "CountPrepurchaseRecordEx"},
-            FunctionInfo{33, nullptr, "ListPrepurchaseRecordRightsIdsEx"},
-            FunctionInfo{34, nullptr, "GetEncryptedTicketSize"},
-            FunctionInfo{35, nullptr, "GetEncryptedTicketData"},
-            FunctionInfo{36, nullptr, "DeleteAllInactiveELicenseRequiredPersonalizedTicket"},
-            FunctionInfo{37, nullptr, "OwnTicket2"},
-            FunctionInfo{38, nullptr, "OwnTicket3"},
-            FunctionInfo{39, nullptr, "DeleteAllInactivePersonalizedTicket"},
-            FunctionInfo{40, nullptr, "DeletePrepurchaseRecordByNintendoAccountId"},
-            FunctionInfo{101, nullptr, "Unknown101"}, //18.0.0+
-            FunctionInfo{102, nullptr, "Unknown102"}, //18.0.0+
-            FunctionInfo{103, nullptr, "Unknown103"}, //18.0.0+
-            FunctionInfo{104, nullptr, "Unknown104"}, //18.0.0+
-            FunctionInfo{105, nullptr, "Unknown105"}, //20.0.0+
-            FunctionInfo{201, nullptr, "Unknown201"}, //18.0.0+
-            FunctionInfo{202, nullptr, "Unknown202"}, //18.0.0+
-            FunctionInfo{203, nullptr, "Unknown203"}, //18.0.0+
-            FunctionInfo{204, nullptr, "Unknown204"}, //18.0.0+
-            FunctionInfo{205, nullptr, "Unknown205"}, //18.0.0+
-            FunctionInfo{501, nullptr, "Unknown501"},
-            FunctionInfo{502, nullptr, "Unknown502"},
-            FunctionInfo{503, nullptr, "GetTitleKey"},
-            FunctionInfo{504, nullptr, "Unknown504"},
-            FunctionInfo{508, nullptr, "Unknown508"},
-            FunctionInfo{509, nullptr, "Unknown509"},
-            FunctionInfo{510, nullptr, "Unknown510"},
-            FunctionInfo{511, nullptr, "Unknown511"},
-            FunctionInfo{1001, nullptr, "Unknown1001"},
-            FunctionInfo{1002, nullptr, "Unknown1001"},
-            FunctionInfo{1003, nullptr, "Unknown1003"},
-            FunctionInfo{1004, nullptr, "Unknown1004"},
-            FunctionInfo{1005, nullptr, "Unknown1005"},
-            FunctionInfo{1006, nullptr, "Unknown1006"},
-            FunctionInfo{1007, nullptr, "Unknown1007"},
-            FunctionInfo{1009, nullptr, "Unknown1009"},
-            FunctionInfo{1010, nullptr, "Unknown1010"},
-            FunctionInfo{1011, nullptr, "Unknown1011"},
-            FunctionInfo{1012, nullptr, "Unknown1012"},
-            FunctionInfo{1013, nullptr, "Unknown1013"},
-            FunctionInfo{1014, nullptr, "Unknown1014"},
-            FunctionInfo{1015, nullptr, "Unknown1015"},
-            FunctionInfo{1016, nullptr, "Unknown1016"},
-            FunctionInfo{1017, nullptr, "Unknown1017"},
-            FunctionInfo{1018, nullptr, "Unknown1018"},
-            FunctionInfo{1019, nullptr, "Unknown1019"},
-            FunctionInfo{1020, nullptr, "Unknown1020"},
-            FunctionInfo{1021, nullptr, "Unknown1021"},
-            FunctionInfo{1501, nullptr, "Unknown1501"},
-            FunctionInfo{1502, nullptr, "Unknown1502"},
-            FunctionInfo{1503, nullptr, "Unknown1503"},
-            FunctionInfo{1504, nullptr, "Unknown1504"},
-            FunctionInfo{1505, nullptr, "Unknown1505"},
-            FunctionInfo{1506, nullptr, "Unknown1506"},
-            FunctionInfo{2000, nullptr, "Unknown2000"},
-            FunctionInfo{2001, nullptr, "Unknown2001"},
-            FunctionInfo{2002, nullptr, "Unknown2002"},
-            FunctionInfo{2003, nullptr, "Unknown2003"},
-            FunctionInfo{2100, nullptr, "Unknown2100"},
-            FunctionInfo{2501, nullptr, "Unknown2501"},
-            FunctionInfo{2502, nullptr, "Unknown2502"},
-            FunctionInfo{2601, nullptr, "Unknown2601"},
-            FunctionInfo{3001, nullptr, "Unknown3001"},
-            FunctionInfo{3002, nullptr, "Unknown3002"}
-        );
-    }
-
 private:
     bool CheckRightsId(HLERequestContext& ctx, const u128& rights_id) {
         if (rights_id == u128{}) {
@@ -322,81 +323,83 @@ private:
 class NDRM_LU final : public ServiceFramework<NDRM_LU> {
 public:
     explicit NDRM_LU(Core::System& system_)
-        : ServiceFramework{system_, "ndrm:lu"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{1, nullptr, "Cmd1"},
-            FunctionInfo{2, nullptr, "Cmd2"},
-            FunctionInfo{3, nullptr, "Cmd3"},
-            FunctionInfo{1000, nullptr, "Cmd1000"},
-            FunctionInfo{8000, nullptr, "Cmd8000"}
-        );
+        : ServiceFramework{system_, "ndrm:lu"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {1, nullptr, "Cmd1"},
+            {2, nullptr, "Cmd2"},
+            {3, nullptr, "Cmd3"},
+            {1000, nullptr, "Cmd1000"},
+            {8000, nullptr, "Cmd8000"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 
 class NDRM_LA final : public ServiceFramework<NDRM_LA> {
 public:
     explicit NDRM_LA(Core::System& system_)
-        : ServiceFramework{system_, "ndrm:la"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{1, nullptr, "Cmd1"},
-            FunctionInfo{2, nullptr, "Cmd2"},
-            FunctionInfo{3, nullptr, "Cmd3"},
-            FunctionInfo{4, nullptr, "Cmd4"},
-            FunctionInfo{5, nullptr, "Cmd5"},
-            FunctionInfo{6, nullptr, "Cmd6"},
-            FunctionInfo{7, nullptr, "Cmd7"},
-            FunctionInfo{8, nullptr, "Cmd8"},
-            FunctionInfo{9, nullptr, "Cmd9"},
-            FunctionInfo{10, nullptr, "Cmd10"},
-            FunctionInfo{11, nullptr, "Cmd11"},
-            FunctionInfo{12, nullptr, "Cmd12"},
-            FunctionInfo{13, nullptr, "Cmd13"},
-            FunctionInfo{14, nullptr, "Cmd14"},
-            FunctionInfo{15, nullptr, "Cmd15"},
-            FunctionInfo{16, nullptr, "Cmd16"},
-            FunctionInfo{17, nullptr, "Cmd17"},
-            FunctionInfo{18, nullptr, "Cmd18"},
-            FunctionInfo{19, nullptr, "Cmd19"},
-            FunctionInfo{20, nullptr, "Cmd20"},
-            FunctionInfo{21, nullptr, "Cmd21"},
-            FunctionInfo{22, nullptr, "Cmd22"},
-            FunctionInfo{23, nullptr, "Cmd23"},
-            FunctionInfo{24, nullptr, "Cmd24"},
-            FunctionInfo{25, nullptr, "Cmd25"},
-            FunctionInfo{26, nullptr, "Cmd26"},
-            FunctionInfo{27, nullptr, "Cmd27"},
-            FunctionInfo{28, nullptr, "Cmd28"},
-            FunctionInfo{29, nullptr, "Cmd29"},
-            FunctionInfo{30, nullptr, "Cmd30"},
-            FunctionInfo{31, nullptr, "Cmd31"},
-            FunctionInfo{32, nullptr, "Cmd32"},
-            FunctionInfo{33, nullptr, "Cmd33"},
-            FunctionInfo{34, nullptr, "Cmd34"},
-            FunctionInfo{35, nullptr, "Cmd35"},
-            FunctionInfo{36, nullptr, "Cmd36"},
-            FunctionInfo{37, nullptr, "Cmd37"},
-            FunctionInfo{38, nullptr, "Cmd38"},
-            FunctionInfo{39, nullptr, "Cmd39"},
-            FunctionInfo{40, nullptr, "Cmd40"},
-            FunctionInfo{42, nullptr, "Cmd42"},
-            FunctionInfo{43, nullptr, "Cmd43"},
-            FunctionInfo{44, nullptr, "Cmd44"},
-            FunctionInfo{45, nullptr, "Cmd45"},
-            FunctionInfo{46, nullptr, "Cmd46"},
-            FunctionInfo{47, nullptr, "Cmd47"},
-            FunctionInfo{48, nullptr, "Cmd48"},
-            FunctionInfo{49, nullptr, "Cmd49"},
-            FunctionInfo{50, nullptr, "Cmd50"},
-            FunctionInfo{51, nullptr, "Cmd51"},
-            FunctionInfo{8000, nullptr, "Cmd8000"},
-            FunctionInfo{8001, nullptr, "Cmd8001"},
-            FunctionInfo{8002, nullptr, "Cmd8002"},
-            FunctionInfo{8003, nullptr, "Cmd8003"}
-        );
+        : ServiceFramework{system_, "ndrm:la"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {1, nullptr, "Cmd1"},
+            {2, nullptr, "Cmd2"},
+            {3, nullptr, "Cmd3"},
+            {4, nullptr, "Cmd4"},
+            {5, nullptr, "Cmd5"},
+            {6, nullptr, "Cmd6"},
+            {7, nullptr, "Cmd7"},
+            {8, nullptr, "Cmd8"},
+            {9, nullptr, "Cmd9"},
+            {10, nullptr, "Cmd10"},
+            {11, nullptr, "Cmd11"},
+            {12, nullptr, "Cmd12"},
+            {13, nullptr, "Cmd13"},
+            {14, nullptr, "Cmd14"},
+            {15, nullptr, "Cmd15"},
+            {16, nullptr, "Cmd16"},
+            {17, nullptr, "Cmd17"},
+            {18, nullptr, "Cmd18"},
+            {19, nullptr, "Cmd19"},
+            {20, nullptr, "Cmd20"},
+            {21, nullptr, "Cmd21"},
+            {22, nullptr, "Cmd22"},
+            {23, nullptr, "Cmd23"},
+            {24, nullptr, "Cmd24"},
+            {25, nullptr, "Cmd25"},
+            {26, nullptr, "Cmd26"},
+            {27, nullptr, "Cmd27"},
+            {28, nullptr, "Cmd28"},
+            {29, nullptr, "Cmd29"},
+            {30, nullptr, "Cmd30"},
+            {31, nullptr, "Cmd31"},
+            {32, nullptr, "Cmd32"},
+            {33, nullptr, "Cmd33"},
+            {34, nullptr, "Cmd34"},
+            {35, nullptr, "Cmd35"},
+            {36, nullptr, "Cmd36"},
+            {37, nullptr, "Cmd37"},
+            {38, nullptr, "Cmd38"},
+            {39, nullptr, "Cmd39"},
+            {40, nullptr, "Cmd40"},
+            {42, nullptr, "Cmd42"},
+            {43, nullptr, "Cmd43"},
+            {44, nullptr, "Cmd44"},
+            {45, nullptr, "Cmd45"},
+            {46, nullptr, "Cmd46"},
+            {47, nullptr, "Cmd47"},
+            {48, nullptr, "Cmd48"},
+            {49, nullptr, "Cmd49"},
+            {50, nullptr, "Cmd50"},
+            {51, nullptr, "Cmd51"},
+            {8000, nullptr, "Cmd8000"},
+            {8001, nullptr, "Cmd8001"},
+            {8002, nullptr, "Cmd8002"},
+            {8003, nullptr, "Cmd8003"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 

src/core/hle/service/eupld/eupld.cpp

@@ -1,6 +1,3 @@
-// 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
 
@@ -14,32 +11,36 @@ namespace Service::EUPLD {
 
 class ErrorUploadContext final : public ServiceFramework<ErrorUploadContext> {
 public:
-    explicit ErrorUploadContext(Core::System& system_) : ServiceFramework{system_, "eupld:c"} {}
+    explicit ErrorUploadContext(Core::System& system_) : ServiceFramework{system_, "eupld:c"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "SetUrl"},
+            {1, nullptr, "ImportCrt"},
+            {2, nullptr, "ImportPki"},
+            {3, nullptr, "SetAutoUpload"},
+            {4, nullptr, "GetAutoUpload"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "SetUrl"},
-            FunctionInfo{1, nullptr, "ImportCrt"},
-            FunctionInfo{2, nullptr, "ImportPki"},
-            FunctionInfo{3, nullptr, "SetAutoUpload"},
-            FunctionInfo{4, nullptr, "GetAutoUpload"}
-        );
+        RegisterHandlers(functions);
     }
 };
 
 class ErrorUploadRequest final : public ServiceFramework<ErrorUploadRequest> {
 public:
-    explicit ErrorUploadRequest(Core::System& system_) : ServiceFramework{system_, "eupld:r"} {}
+    explicit ErrorUploadRequest(Core::System& system_) : ServiceFramework{system_, "eupld:r"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "Initialize"},
+            {1, nullptr, "UploadAll"},
+            {2, nullptr, "UploadSelected"},
+            {3, nullptr, "GetUploadStatus"},
+            {4, nullptr, "CancelUpload"},
+            {5, nullptr, "GetResult"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "Initialize"},
-            FunctionInfo{1, nullptr, "UploadAll"},
-            FunctionInfo{2, nullptr, "UploadSelected"},
-            FunctionInfo{3, nullptr, "GetUploadStatus"},
-            FunctionInfo{4, nullptr, "CancelUpload"},
-            FunctionInfo{5, nullptr, "GetResult"}
-        );
+        RegisterHandlers(functions);
     }
 };
 

src/core/hle/service/fgm/fgm.cpp

@@ -16,26 +16,30 @@ namespace Service::FGM {
 
 class IRequest final : public ServiceFramework<IRequest> {
 public:
-    explicit IRequest(Core::System& system_) : ServiceFramework{system_, "IRequest"} {}
+    explicit IRequest(Core::System& system_) : ServiceFramework{system_, "IRequest"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "Initialize"},
+            {1, nullptr, "Set"},
+            {2, nullptr, "Get"},
+            {3, nullptr, "Cancel"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "Initialize"},
-            FunctionInfo{1, nullptr, "Set"},
-            FunctionInfo{2, nullptr, "Get"},
-            FunctionInfo{3, nullptr, "Cancel"}
-        );
+        RegisterHandlers(functions);
     }
 };
 
 class FGM final : public ServiceFramework<FGM> {
 public:
-    explicit FGM(Core::System& system_, const char* name) : ServiceFramework{system_, name} {}
+    explicit FGM(Core::System& system_, const char* name) : ServiceFramework{system_, name} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &FGM::Initialize, "Initialize"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, &FGM::Initialize, "Initialize"}
-        );
+        RegisterHandlers(functions);
     }
 
 private:
@@ -50,14 +54,16 @@ private:
 
 class FGM_DBG final : public ServiceFramework<FGM_DBG> {
 public:
-    explicit FGM_DBG(Core::System& system_) : ServiceFramework{system_, "fgm:dbg"} {}
+    explicit FGM_DBG(Core::System& system_) : ServiceFramework{system_, "fgm:dbg"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "Initialize"},
+            {1, nullptr, "Read"},
+            {2, nullptr, "Cancel"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "Initialize"},
-            FunctionInfo{1, nullptr, "Read"},
-            FunctionInfo{2, nullptr, "Cancel"}
-        );
+        RegisterHandlers(functions);
     }
 };
 

src/core/hle/service/friend/friend.cpp

@@ -22,124 +22,126 @@ class IFriendService final : public ServiceFramework<IFriendService> {
 public:
     explicit IFriendService(Core::System& system_)
         : ServiceFramework{system_, "IFriendService"}, service_context{system, "IFriendService"} {
-        completion_event = service_context.CreateEvent("IFriendService:CompletionEvent");
-    }
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &IFriendService::GetCompletionEvent, "GetCompletionEvent"},
+            {1, &IFriendService::Cancel, "Cancel"},
+            {10100, nullptr, "GetFriendListIds"},
+            {10101, &IFriendService::GetFriendList, "GetFriendList"},
+            {10102, nullptr, "UpdateFriendInfo"},
+            {10110, nullptr, "GetFriendProfileImage"},
+            {10111, nullptr, "GetFriendProfileImageWithImageSize"}, // 18.0.0+
+            {10120, &IFriendService::CheckFriendListAvailability, "CheckFriendListAvailability"},
+            {10121, nullptr, "EnsureFriendListAvailable"},
+            {10200, nullptr, "SendFriendRequestForApplication"},
+            {10211, nullptr, "AddFacedFriendRequestForApplication"},
+            {10400, &IFriendService::GetBlockedUserListIds, "GetBlockedUserListIds"},
+            {10420, &IFriendService::CheckBlockedUserListAvailability, "CheckBlockedUserListAvailability"},
+            {10421, nullptr, "EnsureBlockedUserListAvailable"},
+            {10500, nullptr, "GetProfileList"},
+            {10501, nullptr, "GetProfileListV2"}, // 18.0.0+
+            {10600, nullptr, "DeclareOpenOnlinePlaySession"},
+            {10601, &IFriendService::DeclareCloseOnlinePlaySession, "DeclareCloseOnlinePlaySession"},
+            {10610, &IFriendService::UpdateUserPresence, "UpdateUserPresence"},
+            {10700, &IFriendService::GetPlayHistoryRegistrationKey, "GetPlayHistoryRegistrationKey"},
+            {10701, nullptr, "GetPlayHistoryRegistrationKeyWithNetworkServiceAccountId"},
+            {10702, nullptr, "AddPlayHistory"},
+            {11000, nullptr, "GetProfileImageUrl"},
+            {11001, nullptr, "GetProfileImageUrlV2"}, // 18.0.0+
+            {20100, &IFriendService::GetFriendCount, "GetFriendCount"},
+            {20101, &IFriendService::GetNewlyFriendCount, "GetNewlyFriendCount"},
+            {20102, nullptr, "GetFriendDetailedInfo"},
+            {20103, nullptr, "SyncFriendList"},
+            {20104, &IFriendService::RequestSyncFriendList, "RequestSyncFriendList"},
+            {20105, &IFriendService::GetFriendListForViewer, "GetFriendListForViewerV1"},
+            {20106, nullptr, "UpdateFriendInfoForViewerV1"},
+            {20107, nullptr, "GetFriendDetailedInfoV2"}, // 20.0.0+
+            {20108, &IFriendService::GetFriendListForViewer, "GetFriendListForViewerV2"}, // 22.0.0+
+            {20109, nullptr, "UpdateFriendInfoForViewerV2"}, // 22.0.0+
+            {20110, nullptr, "LoadFriendSettingV1"},
+            {20111, nullptr, "LoadFriendSettingV2"}, // 22.0.0+
+            {20200, &IFriendService::GetReceivedFriendRequestCount, "GetReceivedFriendRequestCount"},
+            {20201, nullptr, "GetFriendRequestListV1"},
+            {20202, nullptr, "GetFriendRequestListV2"}, // 20.0.0+
+            {20203, nullptr, "GetFriendRequestReceivedNotificationCount"}, // 22.0.0+
+            {20300, nullptr, "GetFriendCandidateList"},
+            {20301, nullptr, "GetNintendoNetworkIdInfo"},
+            {20302, nullptr, "GetSnsAccountLinkage"}, // 5.0.0-19.0.1
+            {20303, nullptr, "GetSnsAccountProfile"}, // 5.0.0-19.0.1
+            {20304, nullptr, "GetSnsAccountFriendList"}, // 5.0.0-19.0.1
+            {20400, nullptr, "GetBlockedUserListV1"},
+            {20401, nullptr, "SyncBlockedUserList"},
+            {20402, nullptr, "GetBlockedUserListV2"}, // 20.0.0+
+            {20500, nullptr, "GetProfileExtraListV1"},
+            {20501, nullptr, "GetRelationship"},
+            {20502, nullptr, "GetProfileExtraListV2"}, // 19.0.0+
+            {20600, &IFriendService::GetUserPresenceView, "GetUserPresenceViewV1"},
+            {20601, &IFriendService::GetUserPresenceView, "GetUserPresenceViewV2"}, // 19.0.0+
+            {20700, nullptr, "GetPlayHistoryListV1"},
+            {20701, &IFriendService::GetPlayHistoryStatistics, "GetPlayHistoryStatistics"},
+            {20702, nullptr, "GetPlayHistoryListV2"}, // 19.0.0+
+            {20800, &IFriendService::LoadUserSetting, "LoadUserSettingV1"},
+            {20801, nullptr, "SyncUserSetting"},
+            {20802, &IFriendService::LoadUserSetting, "LoadUserSettingV2"}, // 19.0.0+
+            {20900, &IFriendService::RequestListSummaryOverlayNotification, "RequestListSummaryOverlayNotification"},
+            {21000, nullptr, "GetExternalApplicationCatalog"},
+            {22000, nullptr, "GetReceivedFriendInvitationListV1"},
+            {22001, nullptr, "GetReceivedFriendInvitationDetailedInfoV1"},
+            {22002, nullptr, "GetReceivedFriendInvitationListV2"}, // 19.0.0+
+            {22003, nullptr, "GetReceivedFriendInvitationDetailedInfoV2"}, // 19.0.0+
+            {22010, &IFriendService::GetReceivedFriendInvitationCountCache, "GetReceivedFriendInvitationCountCache"},
+            {30100, nullptr, "DropFriendNewlyFlags"},
+            {30101, nullptr, "DeleteFriend"},
+            {30110, nullptr, "DropFriendNewlyFlag"},
+            {30120, nullptr, "ChangeFriendFavoriteFlag"},
+            {30121, nullptr, "ChangeFriendOnlineNotificationFlag"},
+            {30130, nullptr, "SetFriendNote"}, // 22.0.0+
+            {30131, nullptr, "RequestUploadPendingNote"}, // 22.0.0+
+            {30190, nullptr, "RequestSyncLocalUpdates"}, // 22.0.0+
+            {30200, nullptr, "SendFriendRequest"},
+            {30201, nullptr, "SendFriendRequestWithApplicationInfoV1"},
+            {30202, nullptr, "CancelFriendRequest"},
+            {30203, nullptr, "AcceptFriendRequest"},
+            {30204, nullptr, "RejectFriendRequest"},
+            {30205, nullptr, "ReadFriendRequest"},
+            {30210, nullptr, "GetFacedFriendRequestRegistrationKey"},
+            {30211, nullptr, "AddFacedFriendRequest"},
+            {30212, nullptr, "CancelFacedFriendRequest"},
+            {30213, nullptr, "GetFacedFriendRequestProfileImage"},
+            {30214, nullptr, "GetFacedFriendRequestProfileImageFromPath"},
+            {30215, nullptr, "SendFriendRequestWithExternalApplicationCatalogId"},
+            {30216, nullptr, "ResendFacedFriendRequest"},
+            {30217, nullptr, "SendFriendRequestWithNintendoNetworkIdInfo"},
+            {30218, nullptr, "SendFriendRequestWithApplicationInfoV2"}, // 20.0.0+
+            {30300, nullptr, "GetSnsAccountLinkPageUrl"}, // 5.0.0-19.0.1
+            {30301, nullptr, "UnlinkSnsAccount"}, // 5.0.0-19.0.1
+            {30400, nullptr, "BlockUser"},
+            {30401, nullptr, "BlockUserWithApplicationInfoV1"},
+            {30402, nullptr, "UnblockUser"},
+            {30403, nullptr, "BlockUserWithApplicationInfoV2"}, // 20.0.0+
+            {30500, nullptr, "GetProfileExtraFromFriendCodeV1"},
+            {30501, nullptr, "GetProfileExtraFromFriendCodeV2"}, // 19.0.0+
+            {30700, nullptr, "DeletePlayHistory"},
+            {30701, nullptr, "AddPlayHistoryWithApplication"}, // 19.0.0+
+            {30810, nullptr, "ChangePresencePermission"},
+            {30811, nullptr, "ChangeFriendRequestReception"},
+            {30812, nullptr, "ChangePlayLogPermission"},
+            {30820, nullptr, "IssueFriendCode"},
+            {30830, nullptr, "ClearPlayLog"},
+            {30900, nullptr, "SendFriendInvitationV1"},
+            {30901, nullptr, "SendFriendInvitationV2"}, // 19.0.0+
+            {30910, nullptr, "ReadFriendInvitation"},
+            {30911, nullptr, "ReadAllFriendInvitations"},
+            {31000, nullptr, "OpenUser"}, // 19.0.0+
+            {40100, nullptr, "DeleteFriendListCache"},
+            {40400, nullptr, "DeleteBlockedUserListCache"},
+            {49900, nullptr, "DeleteNetworkServiceAccountCache"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, &IFriendService::GetCompletionEvent, "GetCompletionEvent"},
-            FunctionInfo{1, &IFriendService::Cancel, "Cancel"},
-            FunctionInfo{10100, nullptr, "GetFriendListIds"},
-            FunctionInfo{10101, &IFriendService::GetFriendList, "GetFriendList"},
-            FunctionInfo{10102, nullptr, "UpdateFriendInfo"},
-            FunctionInfo{10110, nullptr, "GetFriendProfileImage"},
-            FunctionInfo{10111, nullptr, "GetFriendProfileImageWithImageSize"}, // 18.0.0+
-            FunctionInfo{10120, &IFriendService::CheckFriendListAvailability, "CheckFriendListAvailability"},
-            FunctionInfo{10121, nullptr, "EnsureFriendListAvailable"},
-            FunctionInfo{10200, nullptr, "SendFriendRequestForApplication"},
-            FunctionInfo{10211, nullptr, "AddFacedFriendRequestForApplication"},
-            FunctionInfo{10400, &IFriendService::GetBlockedUserListIds, "GetBlockedUserListIds"},
-            FunctionInfo{10420, &IFriendService::CheckBlockedUserListAvailability, "CheckBlockedUserListAvailability"},
-            FunctionInfo{10421, nullptr, "EnsureBlockedUserListAvailable"},
-            FunctionInfo{10500, nullptr, "GetProfileList"},
-            FunctionInfo{10501, nullptr, "GetProfileListV2"}, // 18.0.0+
-            FunctionInfo{10600, nullptr, "DeclareOpenOnlinePlaySession"},
-            FunctionInfo{10601, &IFriendService::DeclareCloseOnlinePlaySession, "DeclareCloseOnlinePlaySession"},
-            FunctionInfo{10610, &IFriendService::UpdateUserPresence, "UpdateUserPresence"},
-            FunctionInfo{10700, &IFriendService::GetPlayHistoryRegistrationKey, "GetPlayHistoryRegistrationKey"},
-            FunctionInfo{10701, nullptr, "GetPlayHistoryRegistrationKeyWithNetworkServiceAccountId"},
-            FunctionInfo{10702, nullptr, "AddPlayHistory"},
-            FunctionInfo{11000, nullptr, "GetProfileImageUrl"},
-            FunctionInfo{11001, nullptr, "GetProfileImageUrlV2"}, // 18.0.0+
-            FunctionInfo{20100, &IFriendService::GetFriendCount, "GetFriendCount"},
-            FunctionInfo{20101, &IFriendService::GetNewlyFriendCount, "GetNewlyFriendCount"},
-            FunctionInfo{20102, nullptr, "GetFriendDetailedInfo"},
-            FunctionInfo{20103, nullptr, "SyncFriendList"},
-            FunctionInfo{20104, &IFriendService::RequestSyncFriendList, "RequestSyncFriendList"},
-            FunctionInfo{20105, &IFriendService::GetFriendListForViewer, "GetFriendListForViewerV1"},
-            FunctionInfo{20106, nullptr, "UpdateFriendInfoForViewerV1"},
-            FunctionInfo{20107, nullptr, "GetFriendDetailedInfoV2"}, // 20.0.0+
-            FunctionInfo{20108, &IFriendService::GetFriendListForViewer, "GetFriendListForViewerV2"}, // 22.0.0+
-            FunctionInfo{20109, nullptr, "UpdateFriendInfoForViewerV2"}, // 22.0.0+
-            FunctionInfo{20110, nullptr, "LoadFriendSettingV1"},
-            FunctionInfo{20111, nullptr, "LoadFriendSettingV2"}, // 22.0.0+
-            FunctionInfo{20200, &IFriendService::GetReceivedFriendRequestCount, "GetReceivedFriendRequestCount"},
-            FunctionInfo{20201, nullptr, "GetFriendRequestListV1"},
-            FunctionInfo{20202, nullptr, "GetFriendRequestListV2"}, // 20.0.0+
-            FunctionInfo{20203, nullptr, "GetFriendRequestReceivedNotificationCount"}, // 22.0.0+
-            FunctionInfo{20300, nullptr, "GetFriendCandidateList"},
-            FunctionInfo{20301, nullptr, "GetNintendoNetworkIdInfo"},
-            FunctionInfo{20302, nullptr, "GetSnsAccountLinkage"}, // 5.0.0-19.0.1
-            FunctionInfo{20303, nullptr, "GetSnsAccountProfile"}, // 5.0.0-19.0.1
-            FunctionInfo{20304, nullptr, "GetSnsAccountFriendList"}, // 5.0.0-19.0.1
-            FunctionInfo{20400, nullptr, "GetBlockedUserListV1"},
-            FunctionInfo{20401, nullptr, "SyncBlockedUserList"},
-            FunctionInfo{20402, nullptr, "GetBlockedUserListV2"}, // 20.0.0+
-            FunctionInfo{20500, nullptr, "GetProfileExtraListV1"},
-            FunctionInfo{20501, nullptr, "GetRelationship"},
-            FunctionInfo{20502, nullptr, "GetProfileExtraListV2"}, // 19.0.0+
-            FunctionInfo{20600, &IFriendService::GetUserPresenceView, "GetUserPresenceViewV1"},
-            FunctionInfo{20601, &IFriendService::GetUserPresenceView, "GetUserPresenceViewV2"}, // 19.0.0+
-            FunctionInfo{20700, nullptr, "GetPlayHistoryListV1"},
-            FunctionInfo{20701, &IFriendService::GetPlayHistoryStatistics, "GetPlayHistoryStatistics"},
-            FunctionInfo{20702, nullptr, "GetPlayHistoryListV2"}, // 19.0.0+
-            FunctionInfo{20800, &IFriendService::LoadUserSetting, "LoadUserSettingV1"},
-            FunctionInfo{20801, nullptr, "SyncUserSetting"},
-            FunctionInfo{20802, &IFriendService::LoadUserSetting, "LoadUserSettingV2"}, // 19.0.0+
-            FunctionInfo{20900, &IFriendService::RequestListSummaryOverlayNotification, "RequestListSummaryOverlayNotification"},
-            FunctionInfo{21000, nullptr, "GetExternalApplicationCatalog"},
-            FunctionInfo{22000, nullptr, "GetReceivedFriendInvitationListV1"},
-            FunctionInfo{22001, nullptr, "GetReceivedFriendInvitationDetailedInfoV1"},
-            FunctionInfo{22002, nullptr, "GetReceivedFriendInvitationListV2"}, // 19.0.0+
-            FunctionInfo{22003, nullptr, "GetReceivedFriendInvitationDetailedInfoV2"}, // 19.0.0+
-            FunctionInfo{22010, &IFriendService::GetReceivedFriendInvitationCountCache, "GetReceivedFriendInvitationCountCache"},
-            FunctionInfo{30100, nullptr, "DropFriendNewlyFlags"},
-            FunctionInfo{30101, nullptr, "DeleteFriend"},
-            FunctionInfo{30110, nullptr, "DropFriendNewlyFlag"},
-            FunctionInfo{30120, nullptr, "ChangeFriendFavoriteFlag"},
-            FunctionInfo{30121, nullptr, "ChangeFriendOnlineNotificationFlag"},
-            FunctionInfo{30130, nullptr, "SetFriendNote"}, // 22.0.0+
-            FunctionInfo{30131, nullptr, "RequestUploadPendingNote"}, // 22.0.0+
-            FunctionInfo{30190, nullptr, "RequestSyncLocalUpdates"}, // 22.0.0+
-            FunctionInfo{30200, nullptr, "SendFriendRequest"},
-            FunctionInfo{30201, nullptr, "SendFriendRequestWithApplicationInfoV1"},
-            FunctionInfo{30202, nullptr, "CancelFriendRequest"},
-            FunctionInfo{30203, nullptr, "AcceptFriendRequest"},
-            FunctionInfo{30204, nullptr, "RejectFriendRequest"},
-            FunctionInfo{30205, nullptr, "ReadFriendRequest"},
-            FunctionInfo{30210, nullptr, "GetFacedFriendRequestRegistrationKey"},
-            FunctionInfo{30211, nullptr, "AddFacedFriendRequest"},
-            FunctionInfo{30212, nullptr, "CancelFacedFriendRequest"},
-            FunctionInfo{30213, nullptr, "GetFacedFriendRequestProfileImage"},
-            FunctionInfo{30214, nullptr, "GetFacedFriendRequestProfileImageFromPath"},
-            FunctionInfo{30215, nullptr, "SendFriendRequestWithExternalApplicationCatalogId"},
-            FunctionInfo{30216, nullptr, "ResendFacedFriendRequest"},
-            FunctionInfo{30217, nullptr, "SendFriendRequestWithNintendoNetworkIdInfo"},
-            FunctionInfo{30218, nullptr, "SendFriendRequestWithApplicationInfoV2"}, // 20.0.0+
-            FunctionInfo{30300, nullptr, "GetSnsAccountLinkPageUrl"}, // 5.0.0-19.0.1
-            FunctionInfo{30301, nullptr, "UnlinkSnsAccount"}, // 5.0.0-19.0.1
-            FunctionInfo{30400, nullptr, "BlockUser"},
-            FunctionInfo{30401, nullptr, "BlockUserWithApplicationInfoV1"},
-            FunctionInfo{30402, nullptr, "UnblockUser"},
-            FunctionInfo{30403, nullptr, "BlockUserWithApplicationInfoV2"}, // 20.0.0+
-            FunctionInfo{30500, nullptr, "GetProfileExtraFromFriendCodeV1"},
-            FunctionInfo{30501, nullptr, "GetProfileExtraFromFriendCodeV2"}, // 19.0.0+
-            FunctionInfo{30700, nullptr, "DeletePlayHistory"},
-            FunctionInfo{30701, nullptr, "AddPlayHistoryWithApplication"}, // 19.0.0+
-            FunctionInfo{30810, nullptr, "ChangePresencePermission"},
-            FunctionInfo{30811, nullptr, "ChangeFriendRequestReception"},
-            FunctionInfo{30812, nullptr, "ChangePlayLogPermission"},
-            FunctionInfo{30820, nullptr, "IssueFriendCode"},
-            FunctionInfo{30830, nullptr, "ClearPlayLog"},
-            FunctionInfo{30900, nullptr, "SendFriendInvitationV1"},
-            FunctionInfo{30901, nullptr, "SendFriendInvitationV2"}, // 19.0.0+
-            FunctionInfo{30910, nullptr, "ReadFriendInvitation"},
-            FunctionInfo{30911, nullptr, "ReadAllFriendInvitations"},
-            FunctionInfo{31000, nullptr, "OpenUser"}, // 19.0.0+
-            FunctionInfo{40100, nullptr, "DeleteFriendListCache"},
-            FunctionInfo{40400, nullptr, "DeleteBlockedUserListCache"},
-            FunctionInfo{49900, nullptr, "DeleteNetworkServiceAccountCache"}
-        );
+        RegisterHandlers(functions);
+
+        completion_event = service_context.CreateEvent("IFriendService:CompletionEvent");
     }
 
     ~IFriendService() override {
@@ -373,17 +375,19 @@ private:
 class INotificationService final : public ServiceFramework<INotificationService> {
 public:
     explicit INotificationService(Core::System& system_, Common::UUID uuid_)
-        : ServiceFramework{system_, "INotificationService"}, uuid{uuid_}
-        , service_context{system_, "INotificationService"} {
-        notification_event = service_context.CreateEvent("INotificationService:NotifyEvent");
-    }
+        : ServiceFramework{system_, "INotificationService"}, uuid{uuid_},
+          service_context{system_, "INotificationService"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &INotificationService::GetEvent, "GetEvent"},
+            {1, &INotificationService::Clear, "Clear"},
+            {2, &INotificationService::Pop, "Pop"}
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, &INotificationService::GetEvent, "GetEvent"},
-            FunctionInfo{1, &INotificationService::Clear, "Clear"},
-            FunctionInfo{2, &INotificationService::Pop, "Pop"}
-        );
+        RegisterHandlers(functions);
+
+        notification_event = service_context.CreateEvent("INotificationService:NotifyEvent");
     }
 
     ~INotificationService() override {
@@ -497,13 +501,12 @@ class IServiceForApplication final : public ServiceFramework<IServiceForApplicat
 public:
     explicit IServiceForApplication(Core::System& system_)
         : ServiceFramework{system_, "nd:app"}
-    {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "GetReceivableNeighborInfoCountMax"},
-            FunctionInfo{10, nullptr, "IsNeighborDetectionEnabled"}
-        );
+    {
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "GetReceivableNeighborInfoCountMax"},
+            {10, nullptr, "IsNeighborDetectionEnabled"},
+        };
+        RegisterHandlers(functions);
     }
 };
 
@@ -511,48 +514,47 @@ class IServiceForSystem final : public ServiceFramework<IServiceForSystem> {
 public:
     explicit IServiceForSystem(Core::System& system_)
         : ServiceFramework{system_, "nd:sys"}
-    {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "GetReceivableNeighborInfoCountMax"},
-            FunctionInfo{10, nullptr, "IsNeighborDetectionEnabled"},
-            FunctionInfo{200, nullptr, "SetSystemData"},
-            FunctionInfo{201, nullptr, "ClearSystemData"},
-            FunctionInfo{203, nullptr, "GetReceivableNeighborInfoCountForSystem"},
-            FunctionInfo{204, nullptr, "ReceiveNeighborInfoForSystem"},
-            FunctionInfo{205, nullptr, "SetSender"},
-            FunctionInfo{206, nullptr, "GetSender"},
-            FunctionInfo{207, nullptr, "CreateScannerForSystem"},
-            FunctionInfo{208, nullptr, "CreateReceiveEventHolderForSystem"},
-            FunctionInfo{223, nullptr, "EnableNeighborDetection"},
-            FunctionInfo{224, nullptr, "DisableNeighborDetection"},
-            FunctionInfo{226, nullptr, "EnablePowerSave"},
-            FunctionInfo{227, nullptr, "DisablePowerSave"},
-            FunctionInfo{228, nullptr, "IsPowerSaveEnabled"},
-            FunctionInfo{232, nullptr, "ClearBlockedUsers"},
-            FunctionInfo{233, nullptr, "GetBlockedUserCount"},
-            FunctionInfo{234, nullptr, "BlockUserByLocalUserId"},
-            FunctionInfo{235, nullptr, "BlockUserByNetworkUserId"},
-            FunctionInfo{236, nullptr, "UnblockUserByLocalUserId"},
-            FunctionInfo{237, nullptr, "UnblockUserByNetworkUserId"},
-            FunctionInfo{240, nullptr, "DeleteApplication"},
-            FunctionInfo{250, nullptr, "InitializeApplicationInfo"},
-            FunctionInfo{260, nullptr, "CreateAccountSystemSaveDataAccessSuppressor"},
-            FunctionInfo{300, nullptr, "AddReceivedNeighborInfoForSystemForDebug"},
-            FunctionInfo{301, nullptr, "GetSendDataForDebug"},
-            FunctionInfo{302, nullptr, "ClearReceiveCounterForDebug"},
-            FunctionInfo{303, nullptr, "GetNextReceiveCounterForDebug"},
-            FunctionInfo{304, nullptr, "ListBlockedUsersForDebug"},
-            FunctionInfo{305, nullptr, "RefreshSendDataIdForDebug"},
-            FunctionInfo{306, nullptr, "ReloadFwdbgSettingsForDebug"},
-            FunctionInfo{307, nullptr, "EnableApplicationForDebug"},
-            FunctionInfo{308, nullptr, "GetNextReceiveCountersForDebug"},
-            FunctionInfo{309, nullptr, "ListApplicationInfoForDebug"},
-            FunctionInfo{310, nullptr, "SetApplicationDataForDebug"},
-            FunctionInfo{400, nullptr, "GetNetworkUserId"},
-            FunctionInfo{401, nullptr, "DeleteNetworkUserId"}
-        );
+    {
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "GetReceivableNeighborInfoCountMax"},
+            {10, nullptr, "IsNeighborDetectionEnabled"},
+            {200, nullptr, "SetSystemData"},
+            {201, nullptr, "ClearSystemData"},
+            {203, nullptr, "GetReceivableNeighborInfoCountForSystem"},
+            {204, nullptr, "ReceiveNeighborInfoForSystem"},
+            {205, nullptr, "SetSender"},
+            {206, nullptr, "GetSender"},
+            {207, nullptr, "CreateScannerForSystem"},
+            {208, nullptr, "CreateReceiveEventHolderForSystem"},
+            {223, nullptr, "EnableNeighborDetection"},
+            {224, nullptr, "DisableNeighborDetection"},
+            {226, nullptr, "EnablePowerSave"},
+            {227, nullptr, "DisablePowerSave"},
+            {228, nullptr, "IsPowerSaveEnabled"},
+            {232, nullptr, "ClearBlockedUsers"},
+            {233, nullptr, "GetBlockedUserCount"},
+            {234, nullptr, "BlockUserByLocalUserId"},
+            {235, nullptr, "BlockUserByNetworkUserId"},
+            {236, nullptr, "UnblockUserByLocalUserId"},
+            {237, nullptr, "UnblockUserByNetworkUserId"},
+            {240, nullptr, "DeleteApplication"},
+            {250, nullptr, "InitializeApplicationInfo"},
+            {260, nullptr, "CreateAccountSystemSaveDataAccessSuppressor"},
+            {300, nullptr, "AddReceivedNeighborInfoForSystemForDebug"},
+            {301, nullptr, "GetSendDataForDebug"},
+            {302, nullptr, "ClearReceiveCounterForDebug"},
+            {303, nullptr, "GetNextReceiveCounterForDebug"},
+            {304, nullptr, "ListBlockedUsersForDebug"},
+            {305, nullptr, "RefreshSendDataIdForDebug"},
+            {306, nullptr, "ReloadFwdbgSettingsForDebug"},
+            {307, nullptr, "EnableApplicationForDebug"},
+            {308, nullptr, "GetNextReceiveCountersForDebug"},
+            {309, nullptr, "ListApplicationInfoForDebug"},
+            {310, nullptr, "SetApplicationDataForDebug"},
+            {400, nullptr, "GetNetworkUserId"},
+            {401, nullptr, "DeleteNetworkUserId"},
+        };
+        RegisterHandlers(functions);
     }
 };
 

src/core/hle/service/glue/arp.cpp

@@ -164,14 +164,16 @@ public:
     using IssuerFn = std::function<Result(u64, ApplicationLaunchProperty, std::vector<u8>)>;
 
     explicit IRegistrar(Core::System& system_, IssuerFn&& issuer)
-        : ServiceFramework{system_, "IRegistrar"}, issue_process_id{std::move(issuer)} {}
+        : ServiceFramework{system_, "IRegistrar"}, issue_process_id{std::move(issuer)} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &IRegistrar::Issue, "Issue"},
+            {1, &IRegistrar::SetApplicationLaunchProperty, "SetApplicationLaunchProperty"},
+            {2, &IRegistrar::SetApplicationControlProperty, "SetApplicationControlProperty"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, &IRegistrar::Issue, "Issue"},
-            FunctionInfo{1, &IRegistrar::SetApplicationLaunchProperty, "SetApplicationLaunchProperty"},
-            FunctionInfo{2, &IRegistrar::SetApplicationControlProperty, "SetApplicationControlProperty"}
-        );
+        RegisterHandlers(functions);
     }
 
 private:
@@ -246,9 +248,9 @@ ARP_W::ARP_W(Core::System& system_, ARPManager& manager_)
     : ServiceFramework{system_, "arp:w"}, manager{manager_} {
     // clang-format off
         static const FunctionInfo functions[] = {
-            FunctionInfo{0, &ARP_W::AcquireRegistrar, "AcquireRegistrar"},
-            FunctionInfo{1, &ARP_W::UnregisterApplicationInstance , "UnregisterApplicationInstance "},
-            FunctionInfo{2, nullptr, "AcquireUpdater"}
+            {0, &ARP_W::AcquireRegistrar, "AcquireRegistrar"},
+            {1, &ARP_W::UnregisterApplicationInstance , "UnregisterApplicationInstance "},
+            {2, nullptr, "AcquireUpdater"},
         };
     // clang-format on
 

src/core/hle/service/glue/ectx.cpp

@@ -12,12 +12,14 @@ namespace Service::Glue {
 // This is nn::err::context::IContextRegistrar
 class IContextRegistrar : public ServiceFramework<IContextRegistrar> {
 public:
-    IContextRegistrar(Core::System& system_) : ServiceFramework{system_, "IContextRegistrar"} {}
+    IContextRegistrar(Core::System& system_) : ServiceFramework{system_, "IContextRegistrar"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &IContextRegistrar::Complete, "Complete"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, &IContextRegistrar::Complete, "Complete"}
-        );
+        RegisterHandlers(functions);
     }
 
     ~IContextRegistrar() override = default;

src/core/hle/service/glue/notif.cpp

@@ -178,15 +178,18 @@ class INotificationSystemEventAccessor final
     : public ServiceFramework<INotificationSystemEventAccessor> {
 public:
     explicit INotificationSystemEventAccessor(Core::System& system_)
-        : ServiceFramework{system_, "INotificationSystemEventAccessor"}
-        , service_context{system_, "INotificationSystemEventAccessor"} {
-        notification_event = service_context.CreateEvent("INotificationSystemEventAccessor:NotificationEvent");
-    }
+        : ServiceFramework{system_, "INotificationSystemEventAccessor"},
+          service_context{system_, "INotificationSystemEventAccessor"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, D<&INotificationSystemEventAccessor::GetSystemEvent>, "GetSystemEvent"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, D<&INotificationSystemEventAccessor::GetSystemEvent>, "GetSystemEvent"}
-        );
+        RegisterHandlers(functions);
+
+        notification_event =
+            service_context.CreateEvent("INotificationSystemEventAccessor:NotificationEvent");
     }
 
     ~INotificationSystemEventAccessor() {

src/core/hle/service/glue/time/static.cpp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -34,25 +31,25 @@ StaticService::StaticService(Core::System& system_,
       m_time_zone_binary{time->m_time_zone_binary} {
     // clang-format off
         static const FunctionInfo functions[] = {
-            FunctionInfo{0,   D<&StaticService::GetStandardUserSystemClock>, "GetStandardUserSystemClock"},
-            FunctionInfo{1,   D<&StaticService::GetStandardNetworkSystemClock>, "GetStandardNetworkSystemClock"},
-            FunctionInfo{2,   D<&StaticService::GetStandardSteadyClock>, "GetStandardSteadyClock"},
-            FunctionInfo{3,   D<&StaticService::GetTimeZoneService>, "GetTimeZoneService"},
-            FunctionInfo{4,   D<&StaticService::GetStandardLocalSystemClock>, "GetStandardLocalSystemClock"},
-            FunctionInfo{5,   D<&StaticService::GetEphemeralNetworkSystemClock>, "GetEphemeralNetworkSystemClock"},
-            FunctionInfo{20,  D<&StaticService::GetSharedMemoryNativeHandle>, "GetSharedMemoryNativeHandle"},
-            FunctionInfo{50,  D<&StaticService::SetStandardSteadyClockInternalOffset>, "SetStandardSteadyClockInternalOffset"},
-            FunctionInfo{51,  D<&StaticService::GetStandardSteadyClockRtcValue>, "GetStandardSteadyClockRtcValue"},
-            FunctionInfo{100, D<&StaticService::IsStandardUserSystemClockAutomaticCorrectionEnabled>, "IsStandardUserSystemClockAutomaticCorrectionEnabled"},
-            FunctionInfo{101, D<&StaticService::SetStandardUserSystemClockAutomaticCorrectionEnabled>, "SetStandardUserSystemClockAutomaticCorrectionEnabled"},
-            FunctionInfo{102, D<&StaticService::GetStandardUserSystemClockInitialYear>, "GetStandardUserSystemClockInitialYear"},
-            FunctionInfo{200, D<&StaticService::IsStandardNetworkSystemClockAccuracySufficient>, "IsStandardNetworkSystemClockAccuracySufficient"},
-            FunctionInfo{201, D<&StaticService::GetStandardUserSystemClockAutomaticCorrectionUpdatedTime>, "GetStandardUserSystemClockAutomaticCorrectionUpdatedTime"},
-            FunctionInfo{300, D<&StaticService::CalculateMonotonicSystemClockBaseTimePoint>, "CalculateMonotonicSystemClockBaseTimePoint"},
-            FunctionInfo{400, D<&StaticService::GetClockSnapshot>, "GetClockSnapshot"},
-            FunctionInfo{401, D<&StaticService::GetClockSnapshotFromSystemClockContext>, "GetClockSnapshotFromSystemClockContext"},
-            FunctionInfo{500, D<&StaticService::CalculateStandardUserSystemClockDifferenceByUser>, "CalculateStandardUserSystemClockDifferenceByUser"},
-            FunctionInfo{501, D<&StaticService::CalculateSpanBetween>, "CalculateSpanBetween"}
+            {0,   D<&StaticService::GetStandardUserSystemClock>, "GetStandardUserSystemClock"},
+            {1,   D<&StaticService::GetStandardNetworkSystemClock>, "GetStandardNetworkSystemClock"},
+            {2,   D<&StaticService::GetStandardSteadyClock>, "GetStandardSteadyClock"},
+            {3,   D<&StaticService::GetTimeZoneService>, "GetTimeZoneService"},
+            {4,   D<&StaticService::GetStandardLocalSystemClock>, "GetStandardLocalSystemClock"},
+            {5,   D<&StaticService::GetEphemeralNetworkSystemClock>, "GetEphemeralNetworkSystemClock"},
+            {20,  D<&StaticService::GetSharedMemoryNativeHandle>, "GetSharedMemoryNativeHandle"},
+            {50,  D<&StaticService::SetStandardSteadyClockInternalOffset>, "SetStandardSteadyClockInternalOffset"},
+            {51,  D<&StaticService::GetStandardSteadyClockRtcValue>, "GetStandardSteadyClockRtcValue"},
+            {100, D<&StaticService::IsStandardUserSystemClockAutomaticCorrectionEnabled>, "IsStandardUserSystemClockAutomaticCorrectionEnabled"},
+            {101, D<&StaticService::SetStandardUserSystemClockAutomaticCorrectionEnabled>, "SetStandardUserSystemClockAutomaticCorrectionEnabled"},
+            {102, D<&StaticService::GetStandardUserSystemClockInitialYear>, "GetStandardUserSystemClockInitialYear"},
+            {200, D<&StaticService::IsStandardNetworkSystemClockAccuracySufficient>, "IsStandardNetworkSystemClockAccuracySufficient"},
+            {201, D<&StaticService::GetStandardUserSystemClockAutomaticCorrectionUpdatedTime>, "GetStandardUserSystemClockAutomaticCorrectionUpdatedTime"},
+            {300, D<&StaticService::CalculateMonotonicSystemClockBaseTimePoint>, "CalculateMonotonicSystemClockBaseTimePoint"},
+            {400, D<&StaticService::GetClockSnapshot>, "GetClockSnapshot"},
+            {401, D<&StaticService::GetClockSnapshotFromSystemClockContext>, "GetClockSnapshotFromSystemClockContext"},
+            {500, D<&StaticService::CalculateStandardUserSystemClockDifferenceByUser>, "CalculateStandardUserSystemClockDifferenceByUser"},
+            {501, D<&StaticService::CalculateSpanBetween>, "CalculateSpanBetween"},
         };
     // clang-format on
 

src/core/hle/service/gpio/gpio.cpp

@@ -17,7 +17,7 @@ public:
         : ServiceFramework{system_, "gpio"}
     {
         static const FunctionInfo functions[] = {
-            FunctionInfo{0, nullptr, "Cmd0"}
+            {0, nullptr, "Cmd0"},
         };
         RegisterHandlers(functions);
     }

src/core/hle/service/grc/grc.cpp

@@ -14,29 +14,32 @@ namespace Service::GRC {
 
 class GRC final : public ServiceFramework<GRC> {
 public:
-    explicit GRC(Core::System& system_) : ServiceFramework{system_, "grc:c"} {}
+    explicit GRC(Core::System& system_) : ServiceFramework{system_, "grc:c"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {1, nullptr, "OpenContinuousRecorder"},
+            {2, nullptr, "OpenGameMovieTrimmer"},
+            {3, nullptr, "OpenOffscreenRecorder"},
+            {101, nullptr, "CreateMovieMaker"},
+            {9903, nullptr, "SetOffscreenRecordingMarker"}
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{1, nullptr, "OpenContinuousRecorder"},
-            FunctionInfo{2, nullptr, "OpenGameMovieTrimmer"},
-            FunctionInfo{3, nullptr, "OpenOffscreenRecorder"},
-            FunctionInfo{101, nullptr, "CreateMovieMaker"},
-            FunctionInfo{9903, nullptr, "SetOffscreenRecordingMarker"}
-        );
+        RegisterHandlers(functions);
     }
 };
 
 class GRC_D final : public ServiceFramework<GRC_D> {
 public:
-    explicit GRC_D(Core::System& system_) : ServiceFramework{system_, "grc:d"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{1, nullptr, "Initialize"},
-            FunctionInfo{2, nullptr, "Transfer"},
-            FunctionInfo{3, nullptr, "Cmd3"}
-        );
+    explicit GRC_D(Core::System& system_) : ServiceFramework{system_, "grc:d"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {1, nullptr, "Initialize"},
+            {2, nullptr, "Transfer"},
+            {3, nullptr, "Cmd3"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 

src/core/hle/service/hid/active_vibration_device_list.cpp

@@ -19,7 +19,7 @@ IActiveVibrationDeviceList::IActiveVibrationDeviceList(Core::System& system_,
     : ServiceFramework{system_, "IActiveVibrationDeviceList"}, resource_manager(resource) {
     // clang-format off
         static const FunctionInfo functions[] = {
-            FunctionInfo{0, C<&IActiveVibrationDeviceList::ActivateVibrationDevice>, "ActivateVibrationDevice"}
+            {0, C<&IActiveVibrationDeviceList::ActivateVibrationDevice>, "ActivateVibrationDevice"},
         };
     // clang-format on
 

src/core/hle/service/hid/hid.cpp

@@ -22,12 +22,13 @@ namespace Service::HID {
 class IHidTemporaryServer final : public ServiceFramework<IHidTemporaryServer> {
 public:
     explicit IHidTemporaryServer(Core::System& system_)
-    : ServiceFramework{system_, "hid:tmp"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "GetConsoleSixAxisSensorCalibrationValues"}
-        );
+    : ServiceFramework{system_, "hid:tmp"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "GetConsoleSixAxisSensorCalibrationValues"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
     ~IHidTemporaryServer() override = default;
 };
@@ -35,16 +36,17 @@ public:
 class AHID_CD final : public ServiceFramework<AHID_CD> {
 public:
     explicit AHID_CD(Core::System& system_)
-    : ServiceFramework{system_, "ahid:cd"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "AcquireDevice"},
-            FunctionInfo{1, nullptr, "ReleaseDevice"},
-            FunctionInfo{2, nullptr, "GetCtrlSession"},
-            FunctionInfo{3, nullptr, "GetReadSession"},
-            FunctionInfo{4, nullptr, "GetWriteSession"}
-        );
+    : ServiceFramework{system_, "ahid:cd"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "AcquireDevice"},
+            {1, nullptr, "ReleaseDevice"},
+            {2, nullptr, "GetCtrlSession"},
+            {3, nullptr, "GetReadSession"},
+            {4, nullptr, "GetWriteSession"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
     ~AHID_CD() override = default;
 };
@@ -52,17 +54,18 @@ public:
 class AHID_HDR final : public ServiceFramework<AHID_HDR> {
 public:
     explicit AHID_HDR(Core::System& system_)
-    : ServiceFramework{system_, "ahid:hdr"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "GetDeviceEntries"},
-            FunctionInfo{1, nullptr, "GetDeviceList"},
-            FunctionInfo{2, nullptr, "GetDeviceParameters"},
-            FunctionInfo{3, nullptr, "AttachDevice"},
-            FunctionInfo{4, nullptr, "DetachDevice"},
-            FunctionInfo{5, nullptr, "SetDeviceFilter"}
-        );
+    : ServiceFramework{system_, "ahid:hdr"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "GetDeviceEntries"},
+            {1, nullptr, "GetDeviceList"},
+            {2, nullptr, "GetDeviceParameters"},
+            {3, nullptr, "AttachDevice"},
+            {4, nullptr, "DetachDevice"},
+            {5, nullptr, "SetDeviceFilter"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
     ~AHID_HDR() override = default;
 };

src/core/hle/service/hid/hidbus.cpp

@@ -31,20 +31,20 @@ Hidbus::Hidbus(Core::System& system_)
 
     // clang-format off
     static const FunctionInfo functions[] = {
-            FunctionInfo{1, C<&Hidbus::GetBusHandle>, "GetBusHandle"},
-            FunctionInfo{2, C<&Hidbus::IsExternalDeviceConnected>, "IsExternalDeviceConnected"},
-            FunctionInfo{3, C<&Hidbus::Initialize>, "Initialize"},
-            FunctionInfo{4, C<&Hidbus::Finalize>, "Finalize"},
-            FunctionInfo{5, C<&Hidbus::EnableExternalDevice>, "EnableExternalDevice"},
-            FunctionInfo{6, C<&Hidbus::GetExternalDeviceId>, "GetExternalDeviceId"},
-            FunctionInfo{7, C<&Hidbus::SendCommandAsync>, "SendCommandAsync"},
-            FunctionInfo{8, C<&Hidbus::GetSendCommandAsynceResult>, "GetSendCommandAsynceResult"},
-            FunctionInfo{9, C<&Hidbus::SetEventForSendCommandAsycResult>, "SetEventForSendCommandAsycResult"},
-            FunctionInfo{10, C<&Hidbus::GetSharedMemoryHandle>, "GetSharedMemoryHandle"},
-            FunctionInfo{11, C<&Hidbus::EnableJoyPollingReceiveMode>, "EnableJoyPollingReceiveMode"},
-            FunctionInfo{12, C<&Hidbus::DisableJoyPollingReceiveMode>, "DisableJoyPollingReceiveMode"},
-            FunctionInfo{13, nullptr, "GetPollingData"},
-            FunctionInfo{14, C<&Hidbus::SetStatusManagerType>, "SetStatusManagerType"},
+            {1, C<&Hidbus::GetBusHandle>, "GetBusHandle"},
+            {2, C<&Hidbus::IsExternalDeviceConnected>, "IsExternalDeviceConnected"},
+            {3, C<&Hidbus::Initialize>, "Initialize"},
+            {4, C<&Hidbus::Finalize>, "Finalize"},
+            {5, C<&Hidbus::EnableExternalDevice>, "EnableExternalDevice"},
+            {6, C<&Hidbus::GetExternalDeviceId>, "GetExternalDeviceId"},
+            {7, C<&Hidbus::SendCommandAsync>, "SendCommandAsync"},
+            {8, C<&Hidbus::GetSendCommandAsynceResult>, "GetSendCommandAsynceResult"},
+            {9, C<&Hidbus::SetEventForSendCommandAsycResult>, "SetEventForSendCommandAsycResult"},
+            {10, C<&Hidbus::GetSharedMemoryHandle>, "GetSharedMemoryHandle"},
+            {11, C<&Hidbus::EnableJoyPollingReceiveMode>, "EnableJoyPollingReceiveMode"},
+            {12, C<&Hidbus::DisableJoyPollingReceiveMode>, "DisableJoyPollingReceiveMode"},
+            {13, nullptr, "GetPollingData"},
+            {14, C<&Hidbus::SetStatusManagerType>, "SetStatusManagerType"},
     };
     // clang-format on
 

src/core/hle/service/i2c/i2c.cpp

@@ -21,13 +21,13 @@ public:
         : ServiceFramework{system_, "I2CSession"}
     {
         static const FunctionInfo functions[] = {
-            FunctionInfo{0, nullptr, "SendOld"},
-            FunctionInfo{1, nullptr, "ReceiveOld"},
-            FunctionInfo{2, nullptr, "ExecuteCommandListOld"},
-            FunctionInfo{10, C<&I2CSession::Send>, "Send"},
-            FunctionInfo{11, nullptr, "Receive"},
-            FunctionInfo{12, nullptr, "ExecuteCommandList"},
-            FunctionInfo{13, nullptr, "SetRetryPolicy"}
+            {0, nullptr, "SendOld"},
+            {1, nullptr, "ReceiveOld"},
+            {2, nullptr, "ExecuteCommandListOld"},
+            {10, C<&I2CSession::Send>, "Send"},
+            {11, nullptr, "Receive"},
+            {12, nullptr, "ExecuteCommandList"},
+            {13, nullptr, "SetRetryPolicy"},
         };
         RegisterHandlers(functions);
     }
@@ -49,11 +49,11 @@ public:
         : ServiceFramework{system_, "i2c"}
     {
         static const FunctionInfo functions[] = {
-            FunctionInfo{0, C<&I2C::OpenSessionForDev>, "OpenSessionForDev"},
-            FunctionInfo{1, C<&I2C::OpenSession>, "OpenSession"},
-            FunctionInfo{2, C<&I2C::HasDevice>, "HasDevice"},
-            FunctionInfo{3, C<&I2C::HasDeviceForDev>, "HasDeviceForDev"},
-            FunctionInfo{4, C<&I2C::OpenSession2>, "OpenSession2"}
+            {0, C<&I2C::OpenSessionForDev>, "OpenSessionForDev"},
+            {1, C<&I2C::OpenSession>, "OpenSession"},
+            {2, C<&I2C::HasDevice>, "HasDevice"},
+            {3, C<&I2C::HasDeviceForDev>, "HasDeviceForDev"},
+            {4, C<&I2C::OpenSession2>, "OpenSession2"},
         };
         RegisterHandlers(functions);
     }

src/core/hle/service/jit/jit.cpp

@@ -37,6 +37,18 @@ public:
         , user_ro{std::move(user_ro_)}
         , context{process_->GetMemory()}
     {
+
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, C<&IJitEnvironment::GenerateCode>, "GenerateCode"},
+            {1, C<&IJitEnvironment::Control>, "Control"},
+            {1000, C<&IJitEnvironment::LoadPlugin>, "LoadPlugin"},
+            {1001, C<&IJitEnvironment::GetCodeAddress>, "GetCodeAddress"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+
         // Identity map user code range into sysmodule context
         configuration.user_rx_memory.size = user_rx.GetSize();
         configuration.user_rx_memory.offset = user_rx.GetAddress();
@@ -47,15 +59,6 @@ public:
         configuration.sys_ro_memory = configuration.user_ro_memory;
     }
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, C<&IJitEnvironment::GenerateCode>, "GenerateCode"},
-            FunctionInfo{1, C<&IJitEnvironment::Control>, "Control"},
-            FunctionInfo{1000, C<&IJitEnvironment::LoadPlugin>, "LoadPlugin"},
-            FunctionInfo{1001, C<&IJitEnvironment::GetCodeAddress>, "GetCodeAddress"}
-        );
-    }
-
     ~IJitEnvironment() {
         user_rx.Finalize(system.Kernel());
         user_ro.Finalize(system.Kernel());
@@ -255,12 +258,14 @@ private:
 
 class JITU final : public ServiceFramework<JITU> {
 public:
-    explicit JITU(Core::System& system_) : ServiceFramework{system_, "jit:u"} {}
+    explicit JITU(Core::System& system_) : ServiceFramework{system_, "jit:u"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, C<&JITU::CreateJitEnvironment>, "CreateJitEnvironment"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, C<&JITU::CreateJitEnvironment>, "CreateJitEnvironment"}
-        );
+        RegisterHandlers(functions);
     }
 
 private:

src/core/hle/service/lbl/lbl.cpp

@@ -18,41 +18,43 @@ namespace Service::LBL {
 
 class LBL final : public ServiceFramework<LBL> {
 public:
-    explicit LBL(Core::System& system_) : ServiceFramework{system_, "lbl"} {}
+    explicit LBL(Core::System& system_) : ServiceFramework{system_, "lbl"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &LBL::SaveCurrentSetting, "SaveCurrentSetting"},
+            {1, &LBL::LoadCurrentSetting, "LoadCurrentSetting"},
+            {2, &LBL::SetCurrentBrightnessSetting, "SetCurrentBrightnessSetting"},
+            {3, &LBL::GetCurrentBrightnessSetting, "GetCurrentBrightnessSetting"},
+            {4, nullptr, "ApplyCurrentBrightnessSettingToBacklight"},
+            {5, nullptr, "GetBrightnessSettingAppliedToBacklight"},
+            {6, &LBL::SwitchBacklightOn, "SwitchBacklightOn"},
+            {7, &LBL::SwitchBacklightOff, "SwitchBacklightOff"},
+            {8, &LBL::GetBacklightSwitchStatus, "GetBacklightSwitchStatus"},
+            {9, &LBL::EnableDimming, "EnableDimming"},
+            {10, &LBL::DisableDimming, "DisableDimming"},
+            {11, &LBL::IsDimmingEnabled, "IsDimmingEnabled"},
+            {12, &LBL::EnableAutoBrightnessControl, "EnableAutoBrightnessControl"},
+            {13, &LBL::DisableAutoBrightnessControl, "DisableAutoBrightnessControl"},
+            {14, &LBL::IsAutoBrightnessControlEnabled, "IsAutoBrightnessControlEnabled"},
+            {15, &LBL::SetAmbientLightSensorValue, "SetAmbientLightSensorValue"},
+            {16, &LBL::GetAmbientLightSensorValue, "GetAmbientLightSensorValue"},
+            {17, &LBL::SetBrightnessReflectionDelayLevel, "SetBrightnessReflectionDelayLevel"},
+            {18, &LBL::GetBrightnessReflectionDelayLevel, "GetBrightnessReflectionDelayLevel"},
+            {19, &LBL::SetCurrentBrightnessMapping, "SetCurrentBrightnessMapping"},
+            {20, &LBL::GetCurrentBrightnessMapping, "GetCurrentBrightnessMapping"},
+            {21, &LBL::SetCurrentAmbientLightSensorMapping, "SetCurrentAmbientLightSensorMapping"},
+            {22, &LBL::GetCurrentAmbientLightSensorMapping, "GetCurrentAmbientLightSensorMapping"},
+            {23, &LBL::IsAmbientLightSensorAvailable, "IsAmbientLightSensorAvailable"},
+            {24, &LBL::SetCurrentBrightnessSettingForVrMode, "SetCurrentBrightnessSettingForVrMode"},
+            {25, &LBL::GetCurrentBrightnessSettingForVrMode, "GetCurrentBrightnessSettingForVrMode"},
+            {26, &LBL::EnableVrMode, "EnableVrMode"},
+            {27, &LBL::DisableVrMode, "DisableVrMode"},
+            {28, &LBL::IsVrModeEnabled, "IsVrModeEnabled"},
+            {29, &LBL::IsAutoBrightnessControlSupported, "IsAutoBrightnessControlSupported"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, &LBL::SaveCurrentSetting, "SaveCurrentSetting"},
-            FunctionInfo{1, &LBL::LoadCurrentSetting, "LoadCurrentSetting"},
-            FunctionInfo{2, &LBL::SetCurrentBrightnessSetting, "SetCurrentBrightnessSetting"},
-            FunctionInfo{3, &LBL::GetCurrentBrightnessSetting, "GetCurrentBrightnessSetting"},
-            FunctionInfo{4, nullptr, "ApplyCurrentBrightnessSettingToBacklight"},
-            FunctionInfo{5, nullptr, "GetBrightnessSettingAppliedToBacklight"},
-            FunctionInfo{6, &LBL::SwitchBacklightOn, "SwitchBacklightOn"},
-            FunctionInfo{7, &LBL::SwitchBacklightOff, "SwitchBacklightOff"},
-            FunctionInfo{8, &LBL::GetBacklightSwitchStatus, "GetBacklightSwitchStatus"},
-            FunctionInfo{9, &LBL::EnableDimming, "EnableDimming"},
-            FunctionInfo{10, &LBL::DisableDimming, "DisableDimming"},
-            FunctionInfo{11, &LBL::IsDimmingEnabled, "IsDimmingEnabled"},
-            FunctionInfo{12, &LBL::EnableAutoBrightnessControl, "EnableAutoBrightnessControl"},
-            FunctionInfo{13, &LBL::DisableAutoBrightnessControl, "DisableAutoBrightnessControl"},
-            FunctionInfo{14, &LBL::IsAutoBrightnessControlEnabled, "IsAutoBrightnessControlEnabled"},
-            FunctionInfo{15, &LBL::SetAmbientLightSensorValue, "SetAmbientLightSensorValue"},
-            FunctionInfo{16, &LBL::GetAmbientLightSensorValue, "GetAmbientLightSensorValue"},
-            FunctionInfo{17, &LBL::SetBrightnessReflectionDelayLevel, "SetBrightnessReflectionDelayLevel"},
-            FunctionInfo{18, &LBL::GetBrightnessReflectionDelayLevel, "GetBrightnessReflectionDelayLevel"},
-            FunctionInfo{19, &LBL::SetCurrentBrightnessMapping, "SetCurrentBrightnessMapping"},
-            FunctionInfo{20, &LBL::GetCurrentBrightnessMapping, "GetCurrentBrightnessMapping"},
-            FunctionInfo{21, &LBL::SetCurrentAmbientLightSensorMapping, "SetCurrentAmbientLightSensorMapping"},
-            FunctionInfo{22, &LBL::GetCurrentAmbientLightSensorMapping, "GetCurrentAmbientLightSensorMapping"},
-            FunctionInfo{23, &LBL::IsAmbientLightSensorAvailable, "IsAmbientLightSensorAvailable"},
-            FunctionInfo{24, &LBL::SetCurrentBrightnessSettingForVrMode, "SetCurrentBrightnessSettingForVrMode"},
-            FunctionInfo{25, &LBL::GetCurrentBrightnessSettingForVrMode, "GetCurrentBrightnessSettingForVrMode"},
-            FunctionInfo{26, &LBL::EnableVrMode, "EnableVrMode"},
-            FunctionInfo{27, &LBL::DisableVrMode, "DisableVrMode"},
-            FunctionInfo{28, &LBL::IsVrModeEnabled, "IsVrModeEnabled"},
-            FunctionInfo{29, &LBL::IsAutoBrightnessControlSupported, "IsAutoBrightnessControlSupported"}
-        );
+        RegisterHandlers(functions);
     }
 
 private:

src/core/hle/service/ldn/ldn.cpp

@@ -20,12 +20,13 @@ class IClientProcessMonitor final
     : public ServiceFramework<IClientProcessMonitor> {
 public:
     explicit IClientProcessMonitor(Core::System& system_)
-        : ServiceFramework{system_, "IClientProcessMonitor"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, D<&IClientProcessMonitor::RegisterClient>, "RegisterClient"}
-        );
+        : ServiceFramework{system_, "IClientProcessMonitor"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, D<&IClientProcessMonitor::RegisterClient>, "RegisterClient"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
     ~IClientProcessMonitor() override = default;
 private:
@@ -37,12 +38,13 @@ private:
 
 class IMonitorServiceCreator final : public ServiceFramework<IMonitorServiceCreator> {
 public:
-    explicit IMonitorServiceCreator(Core::System& system_) : ServiceFramework{system_, "ldn:m"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, C<&IMonitorServiceCreator::CreateMonitorService>, "CreateMonitorService"}
-        );
+    explicit IMonitorServiceCreator(Core::System& system_) : ServiceFramework{system_, "ldn:m"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, C<&IMonitorServiceCreator::CreateMonitorService>, "CreateMonitorService"}
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 
 private:
@@ -56,13 +58,15 @@ private:
 
 class ISystemServiceCreator final : public ServiceFramework<ISystemServiceCreator> {
 public:
-    explicit ISystemServiceCreator(Core::System& system_) : ServiceFramework{system_, "ldn:s"} {}
+    explicit ISystemServiceCreator(Core::System& system_) : ServiceFramework{system_, "ldn:s"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, C<&ISystemServiceCreator::CreateSystemLocalCommunicationService>, "CreateSystemLocalCommunicationService"},
+            {1, C<&ISystemServiceCreator::CreateClientProcessMonitor>, "CreateClientProcessMonitor"} // 18.0.0+
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, C<&ISystemServiceCreator::CreateSystemLocalCommunicationService>, "CreateSystemLocalCommunicationService"},
-            FunctionInfo{1, C<&ISystemServiceCreator::CreateClientProcessMonitor>, "CreateClientProcessMonitor"} // 18.0.0+
-        );
+        RegisterHandlers(functions);
     }
 
 private:
@@ -85,13 +89,15 @@ private:
 
 class IUserServiceCreator final : public ServiceFramework<IUserServiceCreator> {
 public:
-    explicit IUserServiceCreator(Core::System& system_) : ServiceFramework{system_, "ldn:u"} {}
+    explicit IUserServiceCreator(Core::System& system_) : ServiceFramework{system_, "ldn:u"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, D<&IUserServiceCreator::CreateUserLocalCommunicationService>, "CreateUserLocalCommunicationService"},
+            {1, D<&IUserServiceCreator::CreateClientProcessMonitor>, "CreateClientProcessMonitor"} // 18.0.0+
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, D<&IUserServiceCreator::CreateUserLocalCommunicationService>, "CreateUserLocalCommunicationService"},
-            FunctionInfo{1, D<&IUserServiceCreator::CreateClientProcessMonitor>, "CreateClientProcessMonitor"} // 18.0.0+
-        );
+        RegisterHandlers(functions);
     }
 
 private:
@@ -115,13 +121,15 @@ private:
 class ISfServiceCreator final : public ServiceFramework<ISfServiceCreator> {
 public:
     explicit ISfServiceCreator(Core::System& system_, bool is_system_, const char* name_)
-        : ServiceFramework{system_, name_}, is_system{is_system_} {}
+        : ServiceFramework{system_, name_}, is_system{is_system_} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, C<&ISfServiceCreator::CreateNetworkService>, "CreateNetworkService"},
+            {8, C<&ISfServiceCreator::CreateNetworkServiceMonitor>, "CreateNetworkServiceMonitor"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, C<&ISfServiceCreator::CreateNetworkService>, "CreateNetworkService"},
-            FunctionInfo{8, C<&ISfServiceCreator::CreateNetworkServiceMonitor>, "CreateNetworkServiceMonitor"}
-        );
+        RegisterHandlers(functions);
     }
 
 private:
@@ -147,12 +155,14 @@ private:
 
 class ISfMonitorServiceCreator final : public ServiceFramework<ISfMonitorServiceCreator> {
 public:
-    explicit ISfMonitorServiceCreator(Core::System& system_) : ServiceFramework{system_, "lp2p:m"} {}
+    explicit ISfMonitorServiceCreator(Core::System& system_) : ServiceFramework{system_, "lp2p:m"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, C<&ISfMonitorServiceCreator::CreateMonitorService>, "CreateMonitorService"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, C<&ISfMonitorServiceCreator::CreateMonitorService>, "CreateMonitorService"}
-        );
+        RegisterHandlers(functions);
     }
 
 private:

src/core/hle/service/ldn/sf_monitor_service.cpp

@@ -1,6 +1,3 @@
-// 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
 
@@ -14,9 +11,9 @@ ISfMonitorService::ISfMonitorService(Core::System& system_)
     : ServiceFramework{system_, "ISfMonitorService"} {
     // clang-format off
         static const FunctionInfo functions[] = {
-            FunctionInfo{0, C<&ISfMonitorService::Initialize>, "Initialize"},
-            FunctionInfo{288, C<&ISfMonitorService::GetGroupInfo>, "GetGroupInfo"},
-            FunctionInfo{320, nullptr, "GetLinkLevel"}
+            {0, C<&ISfMonitorService::Initialize>, "Initialize"},
+            {288, C<&ISfMonitorService::GetGroupInfo>, "GetGroupInfo"},
+            {320, nullptr, "GetLinkLevel"},
         };
     // clang-format on
 

src/core/hle/service/ldn/sf_service.cpp

@@ -1,6 +1,3 @@
-// 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
 
@@ -11,24 +8,24 @@ namespace Service::LDN {
 ISfService::ISfService(Core::System& system_) : ServiceFramework{system_, "ISfService"} {
     // clang-format off
     static const FunctionInfo functions[] = {
-            FunctionInfo{0, nullptr, "Initialize"},
-            FunctionInfo{256, nullptr, "AttachNetworkInterfaceStateChangeEvent"},
-            FunctionInfo{264, nullptr, "GetNetworkInterfaceLastError"},
-            FunctionInfo{272, nullptr, "GetRole"},
-            FunctionInfo{280, nullptr, "GetAdvertiseData"},
-            FunctionInfo{288, nullptr, "GetGroupInfo"},
-            FunctionInfo{296, nullptr, "GetGroupInfo2"},
-            FunctionInfo{304, nullptr, "GetGroupOwner"},
-            FunctionInfo{312, nullptr, "GetIpConfig"},
-            FunctionInfo{320, nullptr, "GetLinkLevel"},
-            FunctionInfo{512, nullptr, "Scan"},
-            FunctionInfo{768, nullptr, "CreateGroup"},
-            FunctionInfo{776, nullptr, "DestroyGroup"},
-            FunctionInfo{784, nullptr, "SetAdvertiseData"},
-            FunctionInfo{1536, nullptr, "SendToOtherGroup"},
-            FunctionInfo{1544, nullptr, "RecvFromOtherGroup"},
-            FunctionInfo{1552, nullptr, "AddAcceptableGroupId"},
-            FunctionInfo{1560, nullptr, "ClearAcceptableGroupId"},
+            {0, nullptr, "Initialize"},
+            {256, nullptr, "AttachNetworkInterfaceStateChangeEvent"},
+            {264, nullptr, "GetNetworkInterfaceLastError"},
+            {272, nullptr, "GetRole"},
+            {280, nullptr, "GetAdvertiseData"},
+            {288, nullptr, "GetGroupInfo"},
+            {296, nullptr, "GetGroupInfo2"},
+            {304, nullptr, "GetGroupOwner"},
+            {312, nullptr, "GetIpConfig"},
+            {320, nullptr, "GetLinkLevel"},
+            {512, nullptr, "Scan"},
+            {768, nullptr, "CreateGroup"},
+            {776, nullptr, "DestroyGroup"},
+            {784, nullptr, "SetAdvertiseData"},
+            {1536, nullptr, "SendToOtherGroup"},
+            {1544, nullptr, "RecvFromOtherGroup"},
+            {1552, nullptr, "AddAcceptableGroupId"},
+            {1560, nullptr, "ClearAcceptableGroupId"},
     };
     // clang-format on
 

src/core/hle/service/ldn/sf_service_monitor.cpp

@@ -1,6 +1,3 @@
-// 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
 
@@ -14,19 +11,19 @@ ISfServiceMonitor::ISfServiceMonitor(Core::System& system_)
     : ServiceFramework{system_, "ISfServiceMonitor"} {
     // clang-format off
         static const FunctionInfo functions[] = {
-            FunctionInfo{0, C<&ISfServiceMonitor::Initialize>, "Initialize"},
-            FunctionInfo{256, nullptr, "AttachNetworkInterfaceStateChangeEvent"},
-            FunctionInfo{264, nullptr, "GetNetworkInterfaceLastError"},
-            FunctionInfo{272, nullptr, "GetRole"},
-            FunctionInfo{280, nullptr, "GetAdvertiseData"},
-            FunctionInfo{281, nullptr, "GetAdvertiseData2"},
-            FunctionInfo{288, C<&ISfServiceMonitor::GetGroupInfo>, "GetGroupInfo"},
-            FunctionInfo{296, nullptr, "GetGroupInfo2"},
-            FunctionInfo{304, nullptr, "GetGroupOwner"},
-            FunctionInfo{312, nullptr, "GetIpConfig"},
-            FunctionInfo{320, nullptr, "GetLinkLevel"},
-            FunctionInfo{328, nullptr, "AttachJoinEvent"},
-            FunctionInfo{336, nullptr, "GetMembers"}
+            {0, C<&ISfServiceMonitor::Initialize>, "Initialize"},
+            {256, nullptr, "AttachNetworkInterfaceStateChangeEvent"},
+            {264, nullptr, "GetNetworkInterfaceLastError"},
+            {272, nullptr, "GetRole"},
+            {280, nullptr, "GetAdvertiseData"},
+            {281, nullptr, "GetAdvertiseData2"},
+            {288, C<&ISfServiceMonitor::GetGroupInfo>, "GetGroupInfo"},
+            {296, nullptr, "GetGroupInfo2"},
+            {304, nullptr, "GetGroupOwner"},
+            {312, nullptr, "GetIpConfig"},
+            {320, nullptr, "GetLinkLevel"},
+            {328, nullptr, "AttachJoinEvent"},
+            {336, nullptr, "GetMembers"},
         };
     // clang-format on
 

src/core/hle/service/ldn/system_local_communication_service.cpp

@@ -1,6 +1,3 @@
-// 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
 
@@ -13,36 +10,36 @@ ISystemLocalCommunicationService::ISystemLocalCommunicationService(Core::System&
     : ServiceFramework{system_, "ISystemLocalCommunicationService"} {
     // clang-format off
         static const FunctionInfo functions[] = {
-            FunctionInfo{0, nullptr, "GetState"},
-            FunctionInfo{1, nullptr, "GetNetworkInfo"},
-            FunctionInfo{2, nullptr, "GetIpv4Address"},
-            FunctionInfo{3, nullptr, "GetDisconnectReason"},
-            FunctionInfo{4, nullptr, "GetSecurityParameter"},
-            FunctionInfo{5, nullptr, "GetNetworkConfig"},
-            FunctionInfo{100, nullptr, "AttachStateChangeEvent"},
-            FunctionInfo{101, nullptr, "GetNetworkInfoLatestUpdate"},
-            FunctionInfo{102, nullptr, "Scan"},
-            FunctionInfo{103, nullptr, "ScanPrivate"},
-            FunctionInfo{104, nullptr, "SetWirelessControllerRestriction"},
-            FunctionInfo{200, nullptr, "OpenAccessPoint"},
-            FunctionInfo{201, nullptr, "CloseAccessPoint"},
-            FunctionInfo{202, nullptr, "CreateNetwork"},
-            FunctionInfo{203, nullptr, "CreateNetworkPrivate"},
-            FunctionInfo{204, nullptr, "DestroyNetwork"},
-            FunctionInfo{205, nullptr, "Reject"},
-            FunctionInfo{206, nullptr, "SetAdvertiseData"},
-            FunctionInfo{207, nullptr, "SetStationAcceptPolicy"},
-            FunctionInfo{208, nullptr, "AddAcceptFilterEntry"},
-            FunctionInfo{209, nullptr, "ClearAcceptFilter"},
-            FunctionInfo{300, nullptr, "OpenStation"},
-            FunctionInfo{301, nullptr, "CloseStation"},
-            FunctionInfo{302, nullptr, "Connect"},
-            FunctionInfo{303, nullptr, "ConnectPrivate"},
-            FunctionInfo{304, nullptr, "Disconnect"},
-            FunctionInfo{400, nullptr, "InitializeSystem"},
-            FunctionInfo{401, nullptr, "FinalizeSystem"},
-            FunctionInfo{402, nullptr, "SetOperationMode"},
-            FunctionInfo{403, C<&ISystemLocalCommunicationService::InitializeSystem2>, "InitializeSystem2"}
+            {0, nullptr, "GetState"},
+            {1, nullptr, "GetNetworkInfo"},
+            {2, nullptr, "GetIpv4Address"},
+            {3, nullptr, "GetDisconnectReason"},
+            {4, nullptr, "GetSecurityParameter"},
+            {5, nullptr, "GetNetworkConfig"},
+            {100, nullptr, "AttachStateChangeEvent"},
+            {101, nullptr, "GetNetworkInfoLatestUpdate"},
+            {102, nullptr, "Scan"},
+            {103, nullptr, "ScanPrivate"},
+            {104, nullptr, "SetWirelessControllerRestriction"},
+            {200, nullptr, "OpenAccessPoint"},
+            {201, nullptr, "CloseAccessPoint"},
+            {202, nullptr, "CreateNetwork"},
+            {203, nullptr, "CreateNetworkPrivate"},
+            {204, nullptr, "DestroyNetwork"},
+            {205, nullptr, "Reject"},
+            {206, nullptr, "SetAdvertiseData"},
+            {207, nullptr, "SetStationAcceptPolicy"},
+            {208, nullptr, "AddAcceptFilterEntry"},
+            {209, nullptr, "ClearAcceptFilter"},
+            {300, nullptr, "OpenStation"},
+            {301, nullptr, "CloseStation"},
+            {302, nullptr, "Connect"},
+            {303, nullptr, "ConnectPrivate"},
+            {304, nullptr, "Disconnect"},
+            {400, nullptr, "InitializeSystem"},
+            {401, nullptr, "FinalizeSystem"},
+            {402, nullptr, "SetOperationMode"},
+            {403, C<&ISystemLocalCommunicationService::InitializeSystem2>, "InitializeSystem2"},
         };
     // clang-format on
 

src/core/hle/service/ldn/user_local_communication_service.cpp

@@ -27,36 +27,36 @@ IUserLocalCommunicationService::IUserLocalCommunicationService(Core::System& sys
       lan_discovery{} {
     // clang-format off
         static const FunctionInfo functions[] = {
-            FunctionInfo{0, D<&IUserLocalCommunicationService::GetState>, "GetState"},
-            FunctionInfo{1, D<&IUserLocalCommunicationService::GetNetworkInfo>, "GetNetworkInfo"},
-            FunctionInfo{2, D<&IUserLocalCommunicationService::GetIpv4Address>, "GetIpv4Address"},
-            FunctionInfo{3, D<&IUserLocalCommunicationService::GetDisconnectReason>, "GetDisconnectReason"},
-            FunctionInfo{4, D<&IUserLocalCommunicationService::GetSecurityParameter>, "GetSecurityParameter"},
-            FunctionInfo{5, D<&IUserLocalCommunicationService::GetNetworkConfig>, "GetNetworkConfig"},
-            FunctionInfo{100, D<&IUserLocalCommunicationService::AttachStateChangeEvent>, "AttachStateChangeEvent"},
-            FunctionInfo{101, D<&IUserLocalCommunicationService::GetNetworkInfoLatestUpdate>, "GetNetworkInfoLatestUpdate"},
-            FunctionInfo{102, D<&IUserLocalCommunicationService::Scan>, "Scan"},
-            FunctionInfo{103, D<&IUserLocalCommunicationService::ScanPrivate>, "ScanPrivate"},
-            FunctionInfo{104, D<&IUserLocalCommunicationService::SetWirelessControllerRestriction>, "SetWirelessControllerRestriction"},
-            FunctionInfo{106, D<&IUserLocalCommunicationService::SetProtocol>, "SetProtocol" },
-            FunctionInfo{200, D<&IUserLocalCommunicationService::OpenAccessPoint>, "OpenAccessPoint"},
-            FunctionInfo{201, D<&IUserLocalCommunicationService::CloseAccessPoint>, "CloseAccessPoint"},
-            FunctionInfo{202, D<&IUserLocalCommunicationService::CreateNetwork>, "CreateNetwork"},
-            FunctionInfo{203, D<&IUserLocalCommunicationService::CreateNetworkPrivate>, "CreateNetworkPrivate"},
-            FunctionInfo{204, D<&IUserLocalCommunicationService::DestroyNetwork>, "DestroyNetwork"},
-            FunctionInfo{205, nullptr, "Reject"},
-            FunctionInfo{206, D<&IUserLocalCommunicationService::SetAdvertiseData>, "SetAdvertiseData"},
-            FunctionInfo{207, D<&IUserLocalCommunicationService::SetStationAcceptPolicy>, "SetStationAcceptPolicy"},
-            FunctionInfo{208, D<&IUserLocalCommunicationService::AddAcceptFilterEntry>, "AddAcceptFilterEntry"},
-            FunctionInfo{209, nullptr, "ClearAcceptFilter"},
-            FunctionInfo{300, D<&IUserLocalCommunicationService::OpenStation>, "OpenStation"},
-            FunctionInfo{301, D<&IUserLocalCommunicationService::CloseStation>, "CloseStation"},
-            FunctionInfo{302, D<&IUserLocalCommunicationService::Connect>, "Connect"},
-            FunctionInfo{303, nullptr, "ConnectPrivate"},
-            FunctionInfo{304, D<&IUserLocalCommunicationService::Disconnect>, "Disconnect"},
-            FunctionInfo{400, D<&IUserLocalCommunicationService::Initialize>, "Initialize"},
-            FunctionInfo{401, D<&IUserLocalCommunicationService::Finalize>, "Finalize"},
-            FunctionInfo{402, D<&IUserLocalCommunicationService::Initialize2>, "Initialize2"}
+            {0, D<&IUserLocalCommunicationService::GetState>, "GetState"},
+            {1, D<&IUserLocalCommunicationService::GetNetworkInfo>, "GetNetworkInfo"},
+            {2, D<&IUserLocalCommunicationService::GetIpv4Address>, "GetIpv4Address"},
+            {3, D<&IUserLocalCommunicationService::GetDisconnectReason>, "GetDisconnectReason"},
+            {4, D<&IUserLocalCommunicationService::GetSecurityParameter>, "GetSecurityParameter"},
+            {5, D<&IUserLocalCommunicationService::GetNetworkConfig>, "GetNetworkConfig"},
+            {100, D<&IUserLocalCommunicationService::AttachStateChangeEvent>, "AttachStateChangeEvent"},
+            {101, D<&IUserLocalCommunicationService::GetNetworkInfoLatestUpdate>, "GetNetworkInfoLatestUpdate"},
+            {102, D<&IUserLocalCommunicationService::Scan>, "Scan"},
+            {103, D<&IUserLocalCommunicationService::ScanPrivate>, "ScanPrivate"},
+            {104, D<&IUserLocalCommunicationService::SetWirelessControllerRestriction>, "SetWirelessControllerRestriction"},
+            { 106, D<&IUserLocalCommunicationService::SetProtocol>, "SetProtocol" },
+            {200, D<&IUserLocalCommunicationService::OpenAccessPoint>, "OpenAccessPoint"},
+            {201, D<&IUserLocalCommunicationService::CloseAccessPoint>, "CloseAccessPoint"},
+            {202, D<&IUserLocalCommunicationService::CreateNetwork>, "CreateNetwork"},
+            {203, D<&IUserLocalCommunicationService::CreateNetworkPrivate>, "CreateNetworkPrivate"},
+            {204, D<&IUserLocalCommunicationService::DestroyNetwork>, "DestroyNetwork"},
+            {205, nullptr, "Reject"},
+            {206, D<&IUserLocalCommunicationService::SetAdvertiseData>, "SetAdvertiseData"},
+            {207, D<&IUserLocalCommunicationService::SetStationAcceptPolicy>, "SetStationAcceptPolicy"},
+            {208, D<&IUserLocalCommunicationService::AddAcceptFilterEntry>, "AddAcceptFilterEntry"},
+            {209, nullptr, "ClearAcceptFilter"},
+            {300, D<&IUserLocalCommunicationService::OpenStation>, "OpenStation"},
+            {301, D<&IUserLocalCommunicationService::CloseStation>, "CloseStation"},
+            {302, D<&IUserLocalCommunicationService::Connect>, "Connect"},
+            {303, nullptr, "ConnectPrivate"},
+            {304, D<&IUserLocalCommunicationService::Disconnect>, "Disconnect"},
+            {400, D<&IUserLocalCommunicationService::Initialize>, "Initialize"},
+            {401, D<&IUserLocalCommunicationService::Finalize>, "Finalize"},
+            {402, D<&IUserLocalCommunicationService::Initialize2>, "Initialize2"},
         };
     // clang-format on
 

src/core/hle/service/ldr/ldr.cpp

@@ -12,41 +12,47 @@ namespace Service::LDR {
 
 class DebugMonitor final : public ServiceFramework<DebugMonitor> {
 public:
-    explicit DebugMonitor(Core::System& system_) : ServiceFramework{system_, "ldr:dmnt"} {}
+    explicit DebugMonitor(Core::System& system_) : ServiceFramework{system_, "ldr:dmnt"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "SetProgramArgument"},
+            {1, nullptr, "FlushArguments"},
+            {2, nullptr, "GetProcessModuleInfo"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "SetProgramArgument"},
-            FunctionInfo{1, nullptr, "FlushArguments"},
-            FunctionInfo{2, nullptr, "GetProcessModuleInfo"}
-        );
+        RegisterHandlers(functions);
     }
 };
 
 class ProcessManager final : public ServiceFramework<ProcessManager> {
 public:
-    explicit ProcessManager(Core::System& system_) : ServiceFramework{system_, "ldr:pm"} {}
+    explicit ProcessManager(Core::System& system_) : ServiceFramework{system_, "ldr:pm"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "CreateProcess"},
+            {1, nullptr, "GetProgramInfo"},
+            {2, nullptr, "PinProgram"},
+            {3, nullptr, "UnpinProgram"},
+            {4, nullptr, "SetEnabledProgramVerification"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "CreateProcess"},
-            FunctionInfo{1, nullptr, "GetProgramInfo"},
-            FunctionInfo{2, nullptr, "PinProgram"},
-            FunctionInfo{3, nullptr, "UnpinProgram"},
-            FunctionInfo{4, nullptr, "SetEnabledProgramVerification"}
-        );
+        RegisterHandlers(functions);
     }
 };
 
 class Shell final : public ServiceFramework<Shell> {
 public:
-    explicit Shell(Core::System& system_) : ServiceFramework{system_, "ldr:shel"} {}
+    explicit Shell(Core::System& system_) : ServiceFramework{system_, "ldr:shel"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "SetProgramArgument"},
+            {1, nullptr, "FlushArguments"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "SetProgramArgument"},
-            FunctionInfo{1, nullptr, "FlushArguments"}
-        );
+        RegisterHandlers(functions);
     }
 };
 

src/core/hle/service/lm/lm.cpp

@@ -89,10 +89,10 @@ class ILogger final : public ServiceFramework<ILogger> {
 public:
     explicit ILogger(Core::System& system_) : ServiceFramework{system_, "ILogger"} {
         static const FunctionInfo functions[] = {
-            FunctionInfo{0, &ILogger::Log, "Log"},
-            FunctionInfo{1, &ILogger::SetDestination, "SetDestination"},
-            FunctionInfo{2, nullptr, "TransmitHashedLog"}, //20.0.0+
-            FunctionInfo{3, nullptr, "DevNotify"}, //20.0.0+
+            {0, &ILogger::Log, "Log"},
+            {1, &ILogger::SetDestination, "SetDestination"},
+            {2, nullptr, "TransmitHashedLog"}, //20.0.0+
+            {3, nullptr, "DevNotify"}, //20.0.0+
         };
         RegisterHandlers(functions);
     }
@@ -337,12 +337,14 @@ private:
 
 class LM final : public ServiceFramework<LM> {
 public:
-    explicit LM(Core::System& system_) : ServiceFramework{system_, "lm"} {}
+    explicit LM(Core::System& system_) : ServiceFramework{system_, "lm"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &LM::OpenLogger, "OpenLogger"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, &LM::OpenLogger, "OpenLogger"}
-        );
+        RegisterHandlers(functions);
     }
 
 private:
@@ -361,10 +363,10 @@ public:
         : ServiceFramework{system_, "lm:get"}
     {
         static const FunctionInfo functions[] = {
-            FunctionInfo{0, nullptr, "StartLogging"},
-            FunctionInfo{1, nullptr, "StopLogging"},
-            FunctionInfo{2, nullptr, "GetLog"},
-            FunctionInfo{100, nullptr, "CreateDevNotificationReceiver"}
+            {0, nullptr, "StartLogging"},
+            {1, nullptr, "StopLogging"},
+            {2, nullptr, "GetLog"},
+            {100, nullptr, "CreateDevNotificationReceiver"},
         };
         RegisterHandlers(functions);
     }

src/core/hle/service/mig/mig.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
@@ -14,47 +14,49 @@ namespace Service::Migration {
 
 class MIG_USR final : public ServiceFramework<MIG_USR> {
 public:
-    explicit MIG_USR(Core::System& system_) : ServiceFramework{system_, "mig:usr"} {}
+    explicit MIG_USR(Core::System& system_) : ServiceFramework{system_, "mig:usr"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "Unknown0"}, //19.0.0+
+            {1, nullptr, "Unknown1"}, //20.0.0+
+            {2, nullptr, "Unknown2"}, //20.0.0+
+            {10, nullptr, "TryGetLastMigrationInfo"},
+            {11, nullptr, "Unknown11"}, //20.0.0+
+            {100, nullptr, "CreateUserMigrationServer"}, //7.0.0+
+            {101, nullptr, "ResumeUserMigrationServer"}, //7.0.0+
+            {200, nullptr, "CreateUserMigrationClient"}, //7.0.0+
+            {201, nullptr, "ResumeUserMigrationClient"}, //7.0.0+
+            {1001, nullptr, "GetSaveDataMigrationPolicyInfoAsync"}, //8.0.0-20.5.0
+            {1010, nullptr, "TryGetLastSaveDataMigrationInfo"}, //7.0.0+
+            {1100, nullptr, "CreateSaveDataMigrationServer"}, //7.0.0-19.0.1
+            {1101, nullptr, "ResumeSaveDataMigrationServer"}, //7.0.0+
+            {1110, nullptr, "Unknown1101"}, //17.0.0+
+            {1200, nullptr, "CreateSaveDataMigrationClient"}, //7.0.0+
+            {1201, nullptr, "ResumeSaveDataMigrationClient"}, //7.0.0+
+            {2001, nullptr, "Unknown2001"}, //20.0.0+
+            {2010, nullptr, "Unknown2010"}, //20.0.0+
+            {2100, nullptr, "Unknown2100"}, //20.0.0+
+            {2110, nullptr, "Unknown2110"}, //20.0.0+
+            {2200, nullptr, "Unknown2200"}, //20.0.0+
+            {2210, nullptr, "Unknown2210"}, //20.0.0+
+            {2220, nullptr, "Unknown2220"}, //20.0.0+
+            {2230, nullptr, "Unknown2230"}, //20.0.0+
+            {2231, nullptr, "Unknown2231"}, //20.0.0+
+            {2232, nullptr, "Unknown2232"}, //20.0.0+
+            {2233, nullptr, "Unknown2233"}, //20.0.0+
+            {2234, nullptr, "Unknown2234"}, //20.0.0+
+            {2250, nullptr, "Unknown2250"}, //20.0.0+
+            {2260, nullptr, "Unknown2260"}, //20.0.0+
+            {2270, nullptr, "Unknown2270"}, //20.0.0+
+            {2280, nullptr, "Unknown2280"}, //20.0.0+
+            {2300, nullptr, "Unknown2300"}, //20.0.0+
+            {2310, nullptr, "Unknown2310"}, //20.0.0+
+            {2400, nullptr, "Unknown2400"}, //20.0.0+
+            {2420, nullptr, "Unknown2420"}, //20.0.0+
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "Unknown0"}, //19.0.0+
-            FunctionInfo{1, nullptr, "Unknown1"}, //20.0.0+
-            FunctionInfo{2, nullptr, "Unknown2"}, //20.0.0+
-            FunctionInfo{10, nullptr, "TryGetLastMigrationInfo"},
-            FunctionInfo{11, nullptr, "Unknown11"}, //20.0.0+
-            FunctionInfo{100, nullptr, "CreateUserMigrationServer"}, //7.0.0+
-            FunctionInfo{101, nullptr, "ResumeUserMigrationServer"}, //7.0.0+
-            FunctionInfo{200, nullptr, "CreateUserMigrationClient"}, //7.0.0+
-            FunctionInfo{201, nullptr, "ResumeUserMigrationClient"}, //7.0.0+
-            FunctionInfo{1001, nullptr, "GetSaveDataMigrationPolicyInfoAsync"}, //8.0.0-20.5.0
-            FunctionInfo{1010, nullptr, "TryGetLastSaveDataMigrationInfo"}, //7.0.0+
-            FunctionInfo{1100, nullptr, "CreateSaveDataMigrationServer"}, //7.0.0-19.0.1
-            FunctionInfo{1101, nullptr, "ResumeSaveDataMigrationServer"}, //7.0.0+
-            FunctionInfo{1110, nullptr, "Unknown1101"}, //17.0.0+
-            FunctionInfo{1200, nullptr, "CreateSaveDataMigrationClient"}, //7.0.0+
-            FunctionInfo{1201, nullptr, "ResumeSaveDataMigrationClient"}, //7.0.0+
-            FunctionInfo{2001, nullptr, "Unknown2001"}, //20.0.0+
-            FunctionInfo{2010, nullptr, "Unknown2010"}, //20.0.0+
-            FunctionInfo{2100, nullptr, "Unknown2100"}, //20.0.0+
-            FunctionInfo{2110, nullptr, "Unknown2110"}, //20.0.0+
-            FunctionInfo{2200, nullptr, "Unknown2200"}, //20.0.0+
-            FunctionInfo{2210, nullptr, "Unknown2210"}, //20.0.0+
-            FunctionInfo{2220, nullptr, "Unknown2220"}, //20.0.0+
-            FunctionInfo{2230, nullptr, "Unknown2230"}, //20.0.0+
-            FunctionInfo{2231, nullptr, "Unknown2231"}, //20.0.0+
-            FunctionInfo{2232, nullptr, "Unknown2232"}, //20.0.0+
-            FunctionInfo{2233, nullptr, "Unknown2233"}, //20.0.0+
-            FunctionInfo{2234, nullptr, "Unknown2234"}, //20.0.0+
-            FunctionInfo{2250, nullptr, "Unknown2250"}, //20.0.0+
-            FunctionInfo{2260, nullptr, "Unknown2260"}, //20.0.0+
-            FunctionInfo{2270, nullptr, "Unknown2270"}, //20.0.0+
-            FunctionInfo{2280, nullptr, "Unknown2280"}, //20.0.0+
-            FunctionInfo{2300, nullptr, "Unknown2300"}, //20.0.0+
-            FunctionInfo{2310, nullptr, "Unknown2310"}, //20.0.0+
-            FunctionInfo{2400, nullptr, "Unknown2400"}, //20.0.0+
-            FunctionInfo{2420, nullptr, "Unknown2420"} //20.0.0+
-        );
+        RegisterHandlers(functions);
     }
 };
 

src/core/hle/service/mii/mii.cpp

@@ -24,44 +24,47 @@ namespace Service::Mii {
 
 class IDatabaseService final : public ServiceFramework<IDatabaseService> {
 public:
-    explicit IDatabaseService(Core::System& system_, std::shared_ptr<MiiManager> mii_manager, bool is_system_)
-        : ServiceFramework{system_, "IDatabaseService"}
-        , manager{mii_manager}
-        , is_system{is_system_} {
-        m_set_sys = system.ServiceManager().GetService<Service::Set::ISystemSettingsServer>("set:sys", true);
-        manager->Initialize(metadata);
-    }
+    explicit IDatabaseService(Core::System& system_, std::shared_ptr<MiiManager> mii_manager,
+                              bool is_system_)
+        : ServiceFramework{system_, "IDatabaseService"}, manager{mii_manager}, is_system{
+                                                                                   is_system_} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, D<&IDatabaseService::IsUpdated>, "IsUpdated"},
+            {1, D<&IDatabaseService::IsFullDatabase>, "IsFullDatabase"},
+            {2, D<&IDatabaseService::GetCount>, "GetCount"},
+            {3, D<&IDatabaseService::Get>, "Get"},
+            {4, D<&IDatabaseService::Get1>, "Get1"},
+            {5, D<&IDatabaseService::UpdateLatest>, "UpdateLatest"},
+            {6, D<&IDatabaseService::BuildRandom>, "BuildRandom"},
+            {7, D<&IDatabaseService::BuildDefault>, "BuildDefault"},
+            {8, D<&IDatabaseService::Get2>, "Get2"},
+            {9, D<&IDatabaseService::Get3>, "Get3"},
+            {10, D<&IDatabaseService::UpdateLatest1>, "UpdateLatest1"},
+            {11, D<&IDatabaseService::FindIndex>, "FindIndex"},
+            {12, D<&IDatabaseService::Move>, "Move"},
+            {13, D<&IDatabaseService::AddOrReplace>, "AddOrReplace"},
+            {14, D<&IDatabaseService::Delete>, "Delete"},
+            {15, D<&IDatabaseService::DestroyFile>, "DestroyFile"},
+            {16, D<&IDatabaseService::DeleteFile>, "DeleteFile"},
+            {17, D<&IDatabaseService::Format>, "Format"},
+            {18, nullptr, "Import"},
+            {19, nullptr, "Export"},
+            {20, D<&IDatabaseService::IsBrokenDatabaseWithClearFlag>, "IsBrokenDatabaseWithClearFlag"},
+            {21, D<&IDatabaseService::GetIndex>, "GetIndex"},
+            {22, D<&IDatabaseService::SetInterfaceVersion>, "SetInterfaceVersion"},
+            {23, D<&IDatabaseService::Convert>, "Convert"},
+            {24, D<&IDatabaseService::ConvertCoreDataToCharInfo>, "ConvertCoreDataToCharInfo"},
+            {25, D<&IDatabaseService::ConvertCharInfoToCoreData>, "ConvertCharInfoToCoreData"},
+            {26,  D<&IDatabaseService::Append>, "Append"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, D<&IDatabaseService::IsUpdated>, "IsUpdated"},
-            FunctionInfo{1, D<&IDatabaseService::IsFullDatabase>, "IsFullDatabase"},
-            FunctionInfo{2, D<&IDatabaseService::GetCount>, "GetCount"},
-            FunctionInfo{3, D<&IDatabaseService::Get>, "Get"},
-            FunctionInfo{4, D<&IDatabaseService::Get1>, "Get1"},
-            FunctionInfo{5, D<&IDatabaseService::UpdateLatest>, "UpdateLatest"},
-            FunctionInfo{6, D<&IDatabaseService::BuildRandom>, "BuildRandom"},
-            FunctionInfo{7, D<&IDatabaseService::BuildDefault>, "BuildDefault"},
-            FunctionInfo{8, D<&IDatabaseService::Get2>, "Get2"},
-            FunctionInfo{9, D<&IDatabaseService::Get3>, "Get3"},
-            FunctionInfo{10, D<&IDatabaseService::UpdateLatest1>, "UpdateLatest1"},
-            FunctionInfo{11, D<&IDatabaseService::FindIndex>, "FindIndex"},
-            FunctionInfo{12, D<&IDatabaseService::Move>, "Move"},
-            FunctionInfo{13, D<&IDatabaseService::AddOrReplace>, "AddOrReplace"},
-            FunctionInfo{14, D<&IDatabaseService::Delete>, "Delete"},
-            FunctionInfo{15, D<&IDatabaseService::DestroyFile>, "DestroyFile"},
-            FunctionInfo{16, D<&IDatabaseService::DeleteFile>, "DeleteFile"},
-            FunctionInfo{17, D<&IDatabaseService::Format>, "Format"},
-            FunctionInfo{18, nullptr, "Import"},
-            FunctionInfo{19, nullptr, "Export"},
-            FunctionInfo{20, D<&IDatabaseService::IsBrokenDatabaseWithClearFlag>, "IsBrokenDatabaseWithClearFlag"},
-            FunctionInfo{21, D<&IDatabaseService::GetIndex>, "GetIndex"},
-            FunctionInfo{22, D<&IDatabaseService::SetInterfaceVersion>, "SetInterfaceVersion"},
-            FunctionInfo{23, D<&IDatabaseService::Convert>, "Convert"},
-            FunctionInfo{24, D<&IDatabaseService::ConvertCoreDataToCharInfo>, "ConvertCoreDataToCharInfo"},
-            FunctionInfo{25, D<&IDatabaseService::ConvertCharInfoToCoreData>, "ConvertCharInfoToCoreData"},
-            FunctionInfo{26,  D<&IDatabaseService::Append>, "Append"}
-        );
+        RegisterHandlers(functions);
+
+        m_set_sys = system.ServiceManager().GetService<Service::Set::ISystemSettingsServer>(
+            "set:sys", true);
+        manager->Initialize(metadata);
     }
 
 private:
@@ -321,25 +324,27 @@ std::shared_ptr<MiiManager> IStaticService::GetMiiManager() {
 
 class IImageDatabaseService final : public ServiceFramework<IImageDatabaseService> {
 public:
-    explicit IImageDatabaseService(Core::System& system_) : ServiceFramework{system_, "miiimg"} {}
+    explicit IImageDatabaseService(Core::System& system_) : ServiceFramework{system_, "miiimg"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, D<&IImageDatabaseService::Initialize>, "Initialize"},
+            {10, nullptr, "Reload"},
+            {11, D<&IImageDatabaseService::GetCount>, "GetCount"},
+            {12, nullptr, "IsEmpty"},
+            {13, nullptr, "IsFull"},
+            {14, nullptr, "GetAttribute"},
+            {15, nullptr, "LoadImage"},
+            {16, nullptr, "AddOrUpdateImage"},
+            {17, nullptr, "DeleteImages"},
+            {100, nullptr, "DeleteFile"},
+            {101, nullptr, "DestroyFile"},
+            {102, nullptr, "ImportFile"},
+            {103, nullptr, "ExportFile"},
+            {104, nullptr, "ForceInitialize"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, D<&IImageDatabaseService::Initialize>, "Initialize"},
-            FunctionInfo{10, nullptr, "Reload"},
-            FunctionInfo{11, D<&IImageDatabaseService::GetCount>, "GetCount"},
-            FunctionInfo{12, nullptr, "IsEmpty"},
-            FunctionInfo{13, nullptr, "IsFull"},
-            FunctionInfo{14, nullptr, "GetAttribute"},
-            FunctionInfo{15, nullptr, "LoadImage"},
-            FunctionInfo{16, nullptr, "AddOrUpdateImage"},
-            FunctionInfo{17, nullptr, "DeleteImages"},
-            FunctionInfo{100, nullptr, "DeleteFile"},
-            FunctionInfo{101, nullptr, "DestroyFile"},
-            FunctionInfo{102, nullptr, "ImportFile"},
-            FunctionInfo{103, nullptr, "ExportFile"},
-            FunctionInfo{104, nullptr, "ForceInitialize"}
-        );
+        RegisterHandlers(functions);
     }
 
 private:

src/core/hle/service/mm/mm_u.cpp

@@ -49,19 +49,21 @@ public:
 
 class MM_U final : public ServiceFramework<MM_U> {
 public:
-    explicit MM_U(Core::System& system_) : ServiceFramework{system_, "mm:u"} {}
+    explicit MM_U(Core::System& system_) : ServiceFramework{system_, "mm:u"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &MM_U::InitializeOld, "InitializeOld"},
+            {1, &MM_U::FinalizeOld, "FinalizeOld"},
+            {2, &MM_U::SetAndWaitOld, "SetAndWaitOld"},
+            {3, &MM_U::GetOld, "GetOld"},
+            {4, &MM_U::Initialize, "Initialize"},
+            {5, &MM_U::Finalize, "Finalize"},
+            {6, &MM_U::SetAndWait, "SetAndWait"},
+            {7, &MM_U::Get, "Get"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, &MM_U::InitializeOld, "InitializeOld"},
-            FunctionInfo{1, &MM_U::FinalizeOld, "FinalizeOld"},
-            FunctionInfo{2, &MM_U::SetAndWaitOld, "SetAndWaitOld"},
-            FunctionInfo{3, &MM_U::GetOld, "GetOld"},
-            FunctionInfo{4, &MM_U::Initialize, "Initialize"},
-            FunctionInfo{5, &MM_U::Finalize, "Finalize"},
-            FunctionInfo{6, &MM_U::SetAndWait, "SetAndWait"},
-            FunctionInfo{7, &MM_U::Get, "Get"}
-        );
+        RegisterHandlers(functions);
     }
 
 private:

src/core/hle/service/mnpp/mnpp.cpp

@@ -14,13 +14,15 @@ namespace Service::MNPP {
 
 class MNPP_APP final : public ServiceFramework<MNPP_APP> {
 public:
-    explicit MNPP_APP(Core::System& system_) : ServiceFramework{system_, "mnpp:app"} {}
+    explicit MNPP_APP(Core::System& system_) : ServiceFramework{system_, "mnpp:app"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &MNPP_APP::Cmd0, "Cmd0"},
+            {1, &MNPP_APP::Cmd1, "Cmd1"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, &MNPP_APP::Cmd0, "Cmd0"},
-            FunctionInfo{1, &MNPP_APP::Cmd1, "Cmd1"}
-        );
+        RegisterHandlers(functions);
     }
 
 private:
@@ -41,32 +43,34 @@ private:
 
 class MNPP_SYS final : public ServiceFramework<MNPP_SYS> {
 public:
-    explicit MNPP_SYS(Core::System& system_) : ServiceFramework{system_, "mnpp:sys"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "Cmd0"},
-            FunctionInfo{10, nullptr, "Cmd10"},
-            FunctionInfo{100, nullptr, "Cmd100"},
-            FunctionInfo{200, nullptr, "Cmd200"},
-            FunctionInfo{300, nullptr, "Cmd300"},
-            FunctionInfo{400, nullptr, "Cmd400"}
-        );
+    explicit MNPP_SYS(Core::System& system_) : ServiceFramework{system_, "mnpp:sys"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "Cmd0"},
+            {10, nullptr, "Cmd10"},
+            {100, nullptr, "Cmd100"},
+            {200, nullptr, "Cmd200"},
+            {300, nullptr, "Cmd300"},
+            {400, nullptr, "Cmd400"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 
 class MNPP_WEB final : public ServiceFramework<MNPP_WEB> {
 public:
-    explicit MNPP_WEB(Core::System& system_) : ServiceFramework{system_, "mnpp:web"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "Cmd0"},
-            FunctionInfo{1, nullptr, "Cmd1"},
-            FunctionInfo{10, nullptr, "Cmd10"},
-            FunctionInfo{20, nullptr, "Cmd20"},
-            FunctionInfo{100, nullptr, "Cmd100"}
-        );
+    explicit MNPP_WEB(Core::System& system_) : ServiceFramework{system_, "mnpp:web"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "Cmd0"},
+            {1, nullptr, "Cmd1"},
+            {10, nullptr, "Cmd10"},
+            {20, nullptr, "Cmd20"},
+            {100, nullptr, "Cmd100"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 

src/core/hle/service/ncm/ncm.cpp

@@ -24,31 +24,33 @@ namespace Service::NCM {
 class ILocationResolver final : public ServiceFramework<ILocationResolver> {
 public:
     explicit ILocationResolver(Core::System& system_, FileSys::StorageId id)
-        : ServiceFramework{system_, "ILocationResolver"}, storage{id} {}
+        : ServiceFramework{system_, "ILocationResolver"}, storage{id} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "ResolveProgramPath"},
+            {1, nullptr, "RedirectProgramPath"},
+            {2, nullptr, "ResolveApplicationControlPath"},
+            {3, nullptr, "ResolveApplicationHtmlDocumentPath"},
+            {4, nullptr, "ResolveDataPath"},
+            {5, nullptr, "RedirectApplicationControlPath"},
+            {6, nullptr, "RedirectApplicationHtmlDocumentPath"},
+            {7, nullptr, "ResolveApplicationLegalInformationPath"},
+            {8, nullptr, "RedirectApplicationLegalInformationPath"},
+            {9, nullptr, "Refresh"},
+            {10, nullptr, "RedirectApplicationProgramPath"},
+            {11, nullptr, "ClearApplicationRedirection"},
+            {12, nullptr, "EraseProgramRedirection"},
+            {13, nullptr, "EraseApplicationControlRedirection"},
+            {14, nullptr, "EraseApplicationHtmlDocumentRedirection"},
+            {15, nullptr, "EraseApplicationLegalInformationRedirection"},
+            {16, nullptr, "ResolveProgramPathForDebug"},
+            {17, nullptr, "RedirectProgramPathForDebug"},
+            {18, nullptr, "RedirectApplicationProgramPathForDebug"},
+            {19, nullptr, "EraseProgramRedirectionForDebug"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "ResolveProgramPath"},
-            FunctionInfo{1, nullptr, "RedirectProgramPath"},
-            FunctionInfo{2, nullptr, "ResolveApplicationControlPath"},
-            FunctionInfo{3, nullptr, "ResolveApplicationHtmlDocumentPath"},
-            FunctionInfo{4, nullptr, "ResolveDataPath"},
-            FunctionInfo{5, nullptr, "RedirectApplicationControlPath"},
-            FunctionInfo{6, nullptr, "RedirectApplicationHtmlDocumentPath"},
-            FunctionInfo{7, nullptr, "ResolveApplicationLegalInformationPath"},
-            FunctionInfo{8, nullptr, "RedirectApplicationLegalInformationPath"},
-            FunctionInfo{9, nullptr, "Refresh"},
-            FunctionInfo{10, nullptr, "RedirectApplicationProgramPath"},
-            FunctionInfo{11, nullptr, "ClearApplicationRedirection"},
-            FunctionInfo{12, nullptr, "EraseProgramRedirection"},
-            FunctionInfo{13, nullptr, "EraseApplicationControlRedirection"},
-            FunctionInfo{14, nullptr, "EraseApplicationHtmlDocumentRedirection"},
-            FunctionInfo{15, nullptr, "EraseApplicationLegalInformationRedirection"},
-            FunctionInfo{16, nullptr, "ResolveProgramPathForDebug"},
-            FunctionInfo{17, nullptr, "RedirectProgramPathForDebug"},
-            FunctionInfo{18, nullptr, "RedirectApplicationProgramPathForDebug"},
-            FunctionInfo{19, nullptr, "EraseProgramRedirectionForDebug"}
-        );
+        RegisterHandlers(functions);
     }
 
 private:
@@ -58,54 +60,60 @@ private:
 class IRegisteredLocationResolver final : public ServiceFramework<IRegisteredLocationResolver> {
 public:
     explicit IRegisteredLocationResolver(Core::System& system_)
-        : ServiceFramework{system_, "IRegisteredLocationResolver"} {}
+        : ServiceFramework{system_, "IRegisteredLocationResolver"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "ResolveProgramPath"},
+            {1, nullptr, "RegisterProgramPath"},
+            {2, nullptr, "UnregisterProgramPath"},
+            {3, nullptr, "RedirectProgramPath"},
+            {4, nullptr, "ResolveHtmlDocumentPath"},
+            {5, nullptr, "RegisterHtmlDocumentPath"},
+            {6, nullptr, "UnregisterHtmlDocumentPath"},
+            {7, nullptr, "RedirectHtmlDocumentPath"},
+            {8, nullptr, "Refresh"},
+            {9, nullptr, "RefreshExcluding"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "ResolveProgramPath"},
-            FunctionInfo{1, nullptr, "RegisterProgramPath"},
-            FunctionInfo{2, nullptr, "UnregisterProgramPath"},
-            FunctionInfo{3, nullptr, "RedirectProgramPath"},
-            FunctionInfo{4, nullptr, "ResolveHtmlDocumentPath"},
-            FunctionInfo{5, nullptr, "RegisterHtmlDocumentPath"},
-            FunctionInfo{6, nullptr, "UnregisterHtmlDocumentPath"},
-            FunctionInfo{7, nullptr, "RedirectHtmlDocumentPath"},
-            FunctionInfo{8, nullptr, "Refresh"},
-            FunctionInfo{9, nullptr, "RefreshExcluding"}
-        );
+        RegisterHandlers(functions);
     }
 };
 
 class IAddOnContentLocationResolver final : public ServiceFramework<IAddOnContentLocationResolver> {
 public:
     explicit IAddOnContentLocationResolver(Core::System& system_)
-        : ServiceFramework{system_, "IAddOnContentLocationResolver"} {}
+        : ServiceFramework{system_, "IAddOnContentLocationResolver"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "ResolveAddOnContentPath"},
+            {1, nullptr, "RegisterAddOnContentStorage"},
+            {2, nullptr, "UnregisterAllAddOnContentPath"},
+            {3, nullptr, "RefreshApplicationAddOnContent"},
+            {4, nullptr, "UnregisterApplicationAddOnContent"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "ResolveAddOnContentPath"},
-            FunctionInfo{1, nullptr, "RegisterAddOnContentStorage"},
-            FunctionInfo{2, nullptr, "UnregisterAllAddOnContentPath"},
-            FunctionInfo{3, nullptr, "RefreshApplicationAddOnContent"},
-            FunctionInfo{4, nullptr, "UnregisterApplicationAddOnContent"}
-        );
+        RegisterHandlers(functions);
     }
 };
 
 class IContentStorage final : public ServiceFramework<IContentStorage> {
 public:
     explicit IContentStorage(Core::System& system_, FileSys::StorageId id)
-        : ServiceFramework{system_, "IContentStorage"}, storage{id} {}
+        : ServiceFramework{system_, "IContentStorage"}, storage{id} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &IContentStorage::GeneratePlaceHolderId, "GeneratePlaceHolderId"},
+            {1, &IContentStorage::CreatePlaceHolder, "CreatePlaceHolder"},
+            {2, &IContentStorage::DeletePlaceHolder, "DeletePlaceHolder"},
+            {4, &IContentStorage::WritePlaceHolder, "WritePlaceHolder"},
+            {5, &IContentStorage::Register, "Register"},
+            {6, &IContentStorage::Delete, "Delete"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, &IContentStorage::GeneratePlaceHolderId, "GeneratePlaceHolderId"},
-            FunctionInfo{1, &IContentStorage::CreatePlaceHolder, "CreatePlaceHolder"},
-            FunctionInfo{2, &IContentStorage::DeletePlaceHolder, "DeletePlaceHolder"},
-            FunctionInfo{4, &IContentStorage::WritePlaceHolder, "WritePlaceHolder"},
-            FunctionInfo{5, &IContentStorage::Register, "Register"},
-            FunctionInfo{6, &IContentStorage::Delete, "Delete"}
-        );
+        RegisterHandlers(functions);
     }
 
 private:
@@ -250,15 +258,17 @@ private:
 class IContentMetaDatabase final : public ServiceFramework<IContentMetaDatabase> {
 public:
     explicit IContentMetaDatabase(Core::System& system_, FileSys::StorageId id)
-        : ServiceFramework{system_, "IContentMetaDatabase"}, storage{id} {}
+        : ServiceFramework{system_, "IContentMetaDatabase"}, storage{id} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &IContentMetaDatabase::Set, "Set"},
+            {2, &IContentMetaDatabase::Remove, "Remove"},
+            {8, &IContentMetaDatabase::Has, "Has"},
+            {15, &IContentMetaDatabase::Commit, "Commit"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, &IContentMetaDatabase::Set, "Set"},
-            FunctionInfo{2, &IContentMetaDatabase::Remove, "Remove"},
-            FunctionInfo{8, &IContentMetaDatabase::Has, "Has"},
-            FunctionInfo{15, &IContentMetaDatabase::Commit, "Commit"}
-        );
+        RegisterHandlers(functions);
     }
 
 private:
@@ -352,41 +362,45 @@ private:
 
 class LR final : public ServiceFramework<LR> {
 public:
-    explicit LR(Core::System& system_) : ServiceFramework{system_, "lr"} {}
+    explicit LR(Core::System& system_) : ServiceFramework{system_, "lr"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "OpenLocationResolver"},
+            {1, nullptr, "OpenRegisteredLocationResolver"},
+            {2, nullptr, "RefreshLocationResolver"},
+            {3, nullptr, "OpenAddOnContentLocationResolver"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "OpenLocationResolver"},
-            FunctionInfo{1, nullptr, "OpenRegisteredLocationResolver"},
-            FunctionInfo{2, nullptr, "RefreshLocationResolver"},
-            FunctionInfo{3, nullptr, "OpenAddOnContentLocationResolver"}
-        );
+        RegisterHandlers(functions);
     }
 };
 
 class NCM final : public ServiceFramework<NCM> {
 public:
-    explicit NCM(Core::System& system_) : ServiceFramework{system_, "ncm"} {}
+    explicit NCM(Core::System& system_) : ServiceFramework{system_, "ncm"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "CreateContentStorage"},
+            {1, nullptr, "CreateContentMetaDatabase"},
+            {2, nullptr, "VerifyContentStorage"},
+            {3, nullptr, "VerifyContentMetaDatabase"},
+            {4, &NCM::OpenContentStorage, "OpenContentStorage"},
+            {5, &NCM::OpenContentMetaDatabase, "OpenContentMetaDatabase"},
+            {6, nullptr, "CloseContentStorageForcibly"},
+            {7, nullptr, "CloseContentMetaDatabaseForcibly"},
+            {8, nullptr, "CleanupContentMetaDatabase"},
+            {9, nullptr, "ActivateContentStorage"},
+            {10, nullptr, "InactivateContentStorage"},
+            {11, nullptr, "ActivateContentMetaDatabase"},
+            {12, nullptr, "InactivateContentMetaDatabase"},
+            {13, nullptr, "InvalidateRightsIdCache"},
+            {14, nullptr, "GetMemoryReport"},
+            {15, nullptr, "ActivateFsContentStorage"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "CreateContentStorage"},
-            FunctionInfo{1, nullptr, "CreateContentMetaDatabase"},
-            FunctionInfo{2, nullptr, "VerifyContentStorage"},
-            FunctionInfo{3, nullptr, "VerifyContentMetaDatabase"},
-            FunctionInfo{4, &NCM::OpenContentStorage, "OpenContentStorage"},
-            FunctionInfo{5, &NCM::OpenContentMetaDatabase, "OpenContentMetaDatabase"},
-            FunctionInfo{6, nullptr, "CloseContentStorageForcibly"},
-            FunctionInfo{7, nullptr, "CloseContentMetaDatabaseForcibly"},
-            FunctionInfo{8, nullptr, "CleanupContentMetaDatabase"},
-            FunctionInfo{9, nullptr, "ActivateContentStorage"},
-            FunctionInfo{10, nullptr, "InactivateContentStorage"},
-            FunctionInfo{11, nullptr, "ActivateContentMetaDatabase"},
-            FunctionInfo{12, nullptr, "InactivateContentMetaDatabase"},
-            FunctionInfo{13, nullptr, "InvalidateRightsIdCache"},
-            FunctionInfo{14, nullptr, "GetMemoryReport"},
-            FunctionInfo{15, nullptr, "ActivateFsContentStorage"}
-        );
+        RegisterHandlers(functions);
     }
 
 private:
@@ -419,7 +433,7 @@ public:
         : ServiceFramework{system_, "ncm:v"}
     {
         static const FunctionInfo functions[] = {
-            FunctionInfo{0, nullptr, "GetSystemVersion"}
+            {0, nullptr, "GetSystemVersion"},
         };
         RegisterHandlers(functions);
     }

src/core/hle/service/nfc/nfc.cpp

@@ -19,7 +19,8 @@ namespace Service::NFC {
 class IUser final : public NfcInterface {
 public:
     explicit IUser(Core::System& system_) : NfcInterface(system_, "NFC::IUser", BackendType::Nfc) {
-        static const FunctionInfoTyped<IUser> functions[] = {
+        // clang-format off
+        static const FunctionInfo functions[] = {
             {0, &NfcInterface::Initialize, "InitializeOld"},
             {1, &NfcInterface::Finalize, "FinalizeOld"},
             {2, &NfcInterface::GetState, "GetStateOld"},
@@ -41,8 +42,10 @@ public:
             {1001, &NfcInterface::WriteMifare ,"WriteMifare"},
             {1300, &NfcInterface::SendCommandByPassThrough, "SendCommandByPassThrough"},
             {1301, nullptr, "KeepPassThroughSession"},
-            {1302, nullptr, "ReleasePassThroughSession"}
+            {1302, nullptr, "ReleasePassThroughSession"},
         };
+        // clang-format on
+
         RegisterHandlers(functions);
     }
 };
@@ -51,7 +54,8 @@ class ISystem final : public NfcInterface {
 public:
     explicit ISystem(Core::System& system_)
         : NfcInterface{system_, "NFC::ISystem", BackendType::Nfc} {
-        static const FunctionInfoTyped<ISystem> functions[] = {
+        // clang-format off
+        static const FunctionInfo functions[] = {
             {0, &NfcInterface::Initialize, "InitializeOld"},
             {1, &NfcInterface::Finalize, "FinalizeOld"},
             {2, &NfcInterface::GetState, "GetStateOld"},
@@ -76,8 +80,10 @@ public:
             {1001, &NfcInterface::WriteMifare, "WriteMifare"},
             {1300, &NfcInterface::SendCommandByPassThrough, "SendCommandByPassThrough"},
             {1301, nullptr, "KeepPassThroughSession"},
-            {1302, nullptr, "ReleasePassThroughSession"}
+            {1302, nullptr, "ReleasePassThroughSession"},
         };
+        // clang-format on
+
         RegisterHandlers(functions);
     }
 };
@@ -87,7 +93,9 @@ public:
 using MFInterface = NfcInterface;
 class MFIUser final : public MFInterface {
 public:
-    explicit MFIUser(Core::System& system_) : MFInterface{system_, "NFC::MFInterface", BackendType::Mifare} {
+    explicit MFIUser(Core::System& system_)
+        : MFInterface{system_, "NFC::MFInterface", BackendType::Mifare} {
+        // clang-format off
         static const FunctionInfoTyped<MFIUser> functions[] = {
             {0, &MFIUser::Initialize, "Initialize"},
             {1, &MFIUser::Finalize, "Finalize"},
@@ -102,33 +110,39 @@ public:
             {10, &MFIUser::GetState, "GetState"},
             {11, &MFIUser::GetDeviceState, "GetDeviceState"},
             {12, &MFIUser::GetNpadId, "GetNpadId"},
-            {13, &MFIUser::AttachAvailabilityChangeEvent, "GetAvailabilityChangeEventHandle"}
+            {13, &MFIUser::AttachAvailabilityChangeEvent, "GetAvailabilityChangeEventHandle"},
         };
+        // clang-format on
+
         RegisterHandlers(functions);
     }
 };
 
 class IAm final : public ServiceFramework<IAm> {
 public:
-    explicit IAm(Core::System& system_) : ServiceFramework{system_, "NFC::IAm"} {}
+    explicit IAm(Core::System& system_) : ServiceFramework{system_, "NFC::IAm"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "Initialize"},
+            {1, nullptr, "Finalize"},
+            {2, nullptr, "NotifyForegroundApplet"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "Initialize"},
-            FunctionInfo{1, nullptr, "Finalize"},
-            FunctionInfo{2, nullptr, "NotifyForegroundApplet"}
-        );
+        RegisterHandlers(functions);
     }
 };
 
 class NFC_AM final : public ServiceFramework<NFC_AM> {
 public:
-    explicit NFC_AM(Core::System& system_) : ServiceFramework{system_, "nfc:am"} {}
+    explicit NFC_AM(Core::System& system_) : ServiceFramework{system_, "nfc:am"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &NFC_AM::CreateAmNfcInterface, "CreateAmNfcInterface"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, &NFC_AM::CreateAmNfcInterface, "CreateAmNfcInterface"}
-        );
+        RegisterHandlers(functions);
     }
 
 private:
@@ -143,12 +157,14 @@ private:
 
 class NFC_MF_U final : public ServiceFramework<NFC_MF_U> {
 public:
-    explicit NFC_MF_U(Core::System& system_) : ServiceFramework{system_, "nfc:mf:u"} {}
+    explicit NFC_MF_U(Core::System& system_) : ServiceFramework{system_, "nfc:mf:u"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &NFC_MF_U::CreateUserNfcInterface, "CreateUserNfcInterface"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, &NFC_MF_U::CreateUserNfcInterface, "CreateUserNfcInterface"}
-        );
+        RegisterHandlers(functions);
     }
 
 private:
@@ -163,12 +179,14 @@ private:
 
 class NFC_U final : public ServiceFramework<NFC_U> {
 public:
-    explicit NFC_U(Core::System& system_) : ServiceFramework{system_, "nfc:user"} {}
+    explicit NFC_U(Core::System& system_) : ServiceFramework{system_, "nfc:user"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &NFC_U::CreateUserNfcInterface, "CreateUserNfcInterface"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, &NFC_U::CreateUserNfcInterface, "CreateUserNfcInterface"}
-        );
+        RegisterHandlers(functions);
     }
 
 private:
@@ -183,12 +201,14 @@ private:
 
 class NFC_SYS final : public ServiceFramework<NFC_SYS> {
 public:
-    explicit NFC_SYS(Core::System& system_) : ServiceFramework{system_, "nfc:sys"} {}
+    explicit NFC_SYS(Core::System& system_) : ServiceFramework{system_, "nfc:sys"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &NFC_SYS::CreateSystemNfcInterface, "CreateSystemNfcInterface"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, &NFC_SYS::CreateSystemNfcInterface, "CreateSystemNfcInterface"}
-        );
+        RegisterHandlers(functions);
     }
 
 private:

src/core/hle/service/nfp/nfp.cpp

@@ -15,6 +15,7 @@ namespace Service::NFP {
 class IUser final : public Interface {
 public:
     explicit IUser(Core::System& system_) : Interface(system_, "NFP:IUser") {
+        // clang-format off
         static const FunctionInfoTyped<IUser> functions[] = {
             {0, &IUser::Initialize, "Initialize"},
             {1, &IUser::Finalize, "Finalize"},
@@ -41,8 +42,10 @@ public:
             {22, &IUser::GetApplicationAreaSize, "GetApplicationAreaSize"},
             {23, &IUser::AttachAvailabilityChangeEvent, "AttachAvailabilityChangeEvent"},
             {24, &IUser::RecreateApplicationArea, "RecreateApplicationArea"},
-            {25, &IUser::StartDetection, "StartDetectionWithFilter"}
+            {25, &IUser::StartDetection, "StartDetectionWithFilter"},
         };
+        // clang-format on
+
         RegisterHandlers(functions);
     }
 };
@@ -50,6 +53,7 @@ public:
 class ISystem final : public Interface {
 public:
     explicit ISystem(Core::System& system_) : Interface(system_, "NFP:ISystem") {
+        // clang-format off
         static const FunctionInfoTyped<ISystem> functions[] = {
             {0, &ISystem::InitializeSystem, "InitializeSystem"},
             {1, &ISystem::FinalizeSystem, "FinalizeSystem"},
@@ -78,8 +82,10 @@ public:
             {103, &ISystem::SetRegisterInfoPrivate, "SetRegisterInfoPrivate"},
             {104, &ISystem::DeleteRegisterInfo, "DeleteRegisterInfo"},
             {105, &ISystem::DeleteApplicationArea, "DeleteApplicationArea"},
-            {106, &ISystem::ExistsApplicationArea, "ExistsApplicationArea"}
+            {106, &ISystem::ExistsApplicationArea, "ExistsApplicationArea"},
         };
+        // clang-format on
+
         RegisterHandlers(functions);
     }
 };
@@ -87,6 +93,7 @@ public:
 class IDebug final : public Interface {
 public:
     explicit IDebug(Core::System& system_) : Interface(system_, "NFP:IDebug") {
+        // clang-format off
         static const FunctionInfoTyped<IDebug> functions[] = {
             {0, &IDebug::InitializeDebug, "InitializeDebug"},
             {1, &IDebug::FinalizeDebug, "FinalizeDebug"},
@@ -127,20 +134,24 @@ public:
             {203, &IDebug::BreakTag, "BreakTag"},
             {204, &IDebug::ReadBackupData, "ReadBackupData"},
             {205, &IDebug::WriteBackupData, "WriteBackupData"},
-            {206, &IDebug::WriteNtf, "WriteNtf"}
+            {206, &IDebug::WriteNtf, "WriteNtf"},
         };
+        // clang-format on
+
         RegisterHandlers(functions);
     }
 };
 
 class IUserManager final : public ServiceFramework<IUserManager> {
 public:
-    explicit IUserManager(Core::System& system_) : ServiceFramework{system_, "nfp:user"} {}
+    explicit IUserManager(Core::System& system_) : ServiceFramework{system_, "nfp:user"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &IUserManager::CreateUserInterface, "CreateUserInterface"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, &IUserManager::CreateUserInterface, "CreateUserInterface"}
-        );
+        RegisterHandlers(functions);
     }
 
 private:
@@ -155,12 +166,14 @@ private:
 
 class ISystemManager final : public ServiceFramework<ISystemManager> {
 public:
-    explicit ISystemManager(Core::System& system_) : ServiceFramework{system_, "nfp:sys"} {}
+    explicit ISystemManager(Core::System& system_) : ServiceFramework{system_, "nfp:sys"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &ISystemManager::CreateSystemInterface, "CreateSystemInterface"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, &ISystemManager::CreateSystemInterface, "CreateSystemInterface"}
-        );
+        RegisterHandlers(functions);
     }
 
 private:
@@ -175,12 +188,14 @@ private:
 
 class IDebugManager final : public ServiceFramework<IDebugManager> {
 public:
-    explicit IDebugManager(Core::System& system_) : ServiceFramework{system_, "nfp:dbg"} {}
+    explicit IDebugManager(Core::System& system_) : ServiceFramework{system_, "nfp:dbg"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &IDebugManager::CreateDebugInterface, "CreateDebugInterface"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, &IDebugManager::CreateDebugInterface, "CreateDebugInterface"}
-        );
+        RegisterHandlers(functions);
     }
 
 private:

src/core/hle/service/ngc/ngc.cpp

@@ -21,13 +21,15 @@ namespace Service::NGC {
 
 class IService final : public ServiceFramework<IService> {
 public:
-    explicit IService(Core::System& system_) : ServiceFramework{system_, "ngct:u"} {}
+    explicit IService(Core::System& system_) : ServiceFramework{system_, "ngct:u"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &IService::Match, "Match"},
+            {1, &IService::Filter, "Filter"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, &IService::Match, "Match"},
-            FunctionInfo{1, &IService::Filter, "Filter"}
-        );
+        RegisterHandlers(functions);
     }
 
 private:
@@ -63,17 +65,19 @@ private:
 
 class NgcServiceImpl final : public ServiceFramework<NgcServiceImpl> {
 public:
-    explicit NgcServiceImpl(Core::System& system_) : ServiceFramework(system_, "ngc:u") {}
+    explicit NgcServiceImpl(Core::System& system_) : ServiceFramework(system_, "ngc:u") {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &NgcServiceImpl::GetContentVersion, "GetContentVersion"},
+            {1, &NgcServiceImpl::Check, "Check"},
+            {2, &NgcServiceImpl::Mask, "Mask"},
+            {3, &NgcServiceImpl::Reload, "Reload"},
+            {4, &NgcServiceImpl::Check, "Check2"},
+            {5, &NgcServiceImpl::Mask, "Mask2"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, &NgcServiceImpl::GetContentVersion, "GetContentVersion"},
-            FunctionInfo{1, &NgcServiceImpl::Check, "Check"},
-            FunctionInfo{2, &NgcServiceImpl::Mask, "Mask"},
-            FunctionInfo{3, &NgcServiceImpl::Reload, "Reload"},
-            FunctionInfo{4, &NgcServiceImpl::Check, "Check2"},
-            FunctionInfo{5, &NgcServiceImpl::Mask, "Mask2"}
-        );
+        RegisterHandlers(functions);
     }
 
 private:
@@ -150,20 +154,21 @@ private:
 
 class IServiceWithManagementApi final : public ServiceFramework<IServiceWithManagementApi> {
 public:
-    explicit IServiceWithManagementApi(Core::System& system_) : ServiceFramework(system_, "ngct:s") {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "Match"},
-            FunctionInfo{1, nullptr, "Filter"},
-            FunctionInfo{100, nullptr, "ConfigureAutoUpdateSetting"},
-            FunctionInfo{101, nullptr, "RequestResourceUpdateCheck"},
-            FunctionInfo{110, nullptr, "Reload"},
-            FunctionInfo{111, nullptr, "IsReloadRequired"},
-            FunctionInfo{112, nullptr, "TryAcquireReloadRequestNotifier"},
-            FunctionInfo{120, nullptr, "CalculateContentFingerprint"},
-            FunctionInfo{130, nullptr, "TryEnableTemporalPassThrough"}
-        );
+    explicit IServiceWithManagementApi(Core::System& system_) : ServiceFramework(system_, "ngct:s") {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0 , nullptr, "Match"},
+            {1 , nullptr, "Filter"},
+            {100, nullptr, "ConfigureAutoUpdateSetting"},
+            {101, nullptr, "RequestResourceUpdateCheck"},
+            {110, nullptr, "Reload"},
+            {111, nullptr, "IsReloadRequired"},
+            {112, nullptr, "TryAcquireReloadRequestNotifier"},
+            {120, nullptr, "CalculateContentFingerprint"},
+            {130, nullptr, "TryEnableTemporalPassThrough"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 
@@ -174,19 +179,20 @@ static_assert(sizeof(SaveDataHandle) == 0x08);
 
 class IUserShimScopedObject final : public ServiceFramework<IUserShimScopedObject> {
 public:
-    explicit IUserShimScopedObject(Core::System& system_) : ServiceFramework(system_, "IUserShimScopedObject") {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{450, nullptr, "InitializeForSaveData"},
-            FunctionInfo{451, nullptr, "FinalizeForSaveData"},
-            FunctionInfo{452, D<&IUserShimScopedObject::OpenSaveData>, "OpenSaveData"},
-            FunctionInfo{453, nullptr, "CloseSaveData"},
-            FunctionInfo{454, D<&IUserShimScopedObject::ReadSaveSlot>, "ReadSaveSlot"},
-            FunctionInfo{455, D<&IUserShimScopedObject::WriteSaveSlot>, "WriteSaveSlot"},
-            FunctionInfo{456, nullptr, "FlushSaveSlot"},
-            FunctionInfo{457, nullptr, "CommitSaveData"}
-        );
+    explicit IUserShimScopedObject(Core::System& system_) : ServiceFramework(system_, "IUserShimScopedObject") {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {450, nullptr, "InitializeForSaveData"},
+            {451, nullptr, "FinalizeForSaveData"},
+            {452, D<&IUserShimScopedObject::OpenSaveData>, "OpenSaveData"},
+            {453, nullptr, "CloseSaveData"},
+            {454, D<&IUserShimScopedObject::ReadSaveSlot>, "ReadSaveSlot"},
+            {455, D<&IUserShimScopedObject::WriteSaveSlot>, "WriteSaveSlot"},
+            {456, nullptr, "FlushSaveSlot"},
+            {457, nullptr, "CommitSaveData"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 
     Result OpenSaveData(Account::Uid unk0, Out<SaveDataHandle> unk1) {
@@ -208,12 +214,13 @@ public:
 
 class IUserService final : public ServiceFramework<IUserService> {
 public:
-    explicit IUserService(Core::System& system_) : ServiceFramework(system_, "stpl:u") {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, D<&IUserService::Cmd0>, "Cmd0"}
-        );
+    explicit IUserService(Core::System& system_) : ServiceFramework(system_, "stpl:u") {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0 , D<&IUserService::Cmd0>, "Cmd0"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
     Result Cmd0(u32 unk0, OutInterface<IUserShimScopedObject> out_interface) {
         LOG_WARNING(Service_NGC, "stubbed");
@@ -224,20 +231,21 @@ public:
 
 class ISystemShimScopedObject final : public ServiceFramework<ISystemShimScopedObject> {
 public:
-    explicit ISystemShimScopedObject(Core::System& system_) : ServiceFramework(system_, "ISystemShimScopedObject") {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{106, nullptr, "Cmd106"},
-            FunctionInfo{107, nullptr, "Cmd107"},
-            FunctionInfo{108, D<&ISystemShimScopedObject::Cmd108>, "Cmd108"},
-            FunctionInfo{207, nullptr, "Cmd207"},
-            FunctionInfo{208, D<&ISystemShimScopedObject::Cmd208>, "Cmd208"},
-            FunctionInfo{209, nullptr, "Cmd209"},
-            FunctionInfo{210, nullptr, "Cmd210"},
-            FunctionInfo{211, nullptr, "Cmd211"},
-            FunctionInfo{212, nullptr, "Cmd212"}
-        );
+    explicit ISystemShimScopedObject(Core::System& system_) : ServiceFramework(system_, "ISystemShimScopedObject") {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {106, nullptr, "Cmd106"},
+            {107, nullptr, "Cmd107"},
+            {108, D<&ISystemShimScopedObject::Cmd108>, "Cmd108"},
+            {207, nullptr, "Cmd207"},
+            {208, D<&ISystemShimScopedObject::Cmd208>, "Cmd208"},
+            {209, nullptr, "Cmd209"},
+            {210, nullptr, "Cmd210"},
+            {211, nullptr, "Cmd211"},
+            {212, nullptr, "Cmd212"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 
     Result Cmd108() {
@@ -253,12 +261,13 @@ public:
 
 class ISystemService final : public ServiceFramework<ISystemService> {
 public:
-    explicit ISystemService(Core::System& system_) : ServiceFramework(system_, "stpl:sys") {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, D<&ISystemService::Cmd0>, "Cmd0"}
-        );
+    explicit ISystemService(Core::System& system_) : ServiceFramework(system_, "stpl:sys") {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0 , D<&ISystemService::Cmd0>, "Cmd0"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
     Result Cmd0(OutInterface<ISystemShimScopedObject> out_interface) {
         LOG_WARNING(Service_NGC, "stubbed");

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

@@ -236,11 +236,11 @@ public:
         : ServiceFramework{system_, "IScanRequest"}, svc_ctx{system_, "IScanRequest"} {
 
         static const FunctionInfo functions[] = {
-            FunctionInfo{0, &IScanRequest::Submit, "Submit"},
-            FunctionInfo{1, &IScanRequest::IsProcessing, "IsProcessing"},
-            FunctionInfo{2, &IScanRequest::GetResult, "GetResult"},
-            FunctionInfo{3, &IScanRequest::GetSystemEventReadableHandle, "GetSystemEventReadableHandle"},
-            FunctionInfo{4, &IScanRequest::SetChannels, "SetChannels"}
+            {0, &IScanRequest::Submit, "Submit"},
+            {1, &IScanRequest::IsProcessing, "IsProcessing"},
+            {2, &IScanRequest::GetResult, "GetResult"},
+            {3, &IScanRequest::GetSystemEventReadableHandle, "GetSystemEventReadableHandle"},
+            {4, &IScanRequest::SetChannels, "SetChannels"},
         };
         RegisterHandlers(functions);
 
@@ -343,32 +343,32 @@ public:
     explicit IRequest(Core::System& system_)
         : ServiceFramework{system_, "IRequest"}, service_context{system_, "IRequest"} {
         static const FunctionInfo functions[] = {
-            FunctionInfo{0, &IRequest::GetRequestState, "GetRequestState"},
-            FunctionInfo{1, &IRequest::GetResult, "GetResult"},
-            FunctionInfo{2, &IRequest::GetSystemEventReadableHandles, "GetSystemEventReadableHandles"},
-            FunctionInfo{3, &IRequest::Cancel, "Cancel"},
-            FunctionInfo{4, &IRequest::Submit, "Submit"},
-            FunctionInfo{5, nullptr, "SetRequirement"},
-            FunctionInfo{6, &IRequest::SetRequirementPreset, "SetRequirementPreset"},
-            FunctionInfo{8, nullptr, "SetPriority"},
-            FunctionInfo{9, &IRequest::SetNetworkProfileId, "SetNetworkProfileId"},
-            FunctionInfo{10, nullptr, "SetRejectable"},
-            FunctionInfo{11, &IRequest::SetConnectionConfirmationOption, "SetConnectionConfirmationOption"},
-            FunctionInfo{12, nullptr, "SetPersistent"},
-            FunctionInfo{13, nullptr, "SetInstant"},
-            FunctionInfo{14, nullptr, "SetSustainable"},
-            FunctionInfo{15, nullptr, "SetRawPriority"},
-            FunctionInfo{16, nullptr, "SetGreedy"},
-            FunctionInfo{17, nullptr, "SetSharable"},
-            FunctionInfo{18, nullptr, "SetRequirementByRevision"},
-            FunctionInfo{19, nullptr, "GetRequirement"},
-            FunctionInfo{20, nullptr, "GetRevision"},
-            FunctionInfo{21, &IRequest::GetAppletInfo, "GetAppletInfo"},
-            FunctionInfo{22, nullptr, "GetAdditionalInfo"},
-            FunctionInfo{23, nullptr, "SetKeptInSleep"},
-            FunctionInfo{24, nullptr, "RegisterSocketDescriptor"},
-            FunctionInfo{25, nullptr, "UnregisterSocketDescriptor"},
-            FunctionInfo{26, nullptr, "GetNetworkAccessStatus"}, //21.0.0+
+            {0, &IRequest::GetRequestState, "GetRequestState"},
+            {1, &IRequest::GetResult, "GetResult"},
+            {2, &IRequest::GetSystemEventReadableHandles, "GetSystemEventReadableHandles"},
+            {3, &IRequest::Cancel, "Cancel"},
+            {4, &IRequest::Submit, "Submit"},
+            {5, nullptr, "SetRequirement"},
+            {6, &IRequest::SetRequirementPreset, "SetRequirementPreset"},
+            {8, nullptr, "SetPriority"},
+            {9, &IRequest::SetNetworkProfileId, "SetNetworkProfileId"},
+            {10, nullptr, "SetRejectable"},
+            {11, &IRequest::SetConnectionConfirmationOption, "SetConnectionConfirmationOption"},
+            {12, nullptr, "SetPersistent"},
+            {13, nullptr, "SetInstant"},
+            {14, nullptr, "SetSustainable"},
+            {15, nullptr, "SetRawPriority"},
+            {16, nullptr, "SetGreedy"},
+            {17, nullptr, "SetSharable"},
+            {18, nullptr, "SetRequirementByRevision"},
+            {19, nullptr, "GetRequirement"},
+            {20, nullptr, "GetRevision"},
+            {21, &IRequest::GetAppletInfo, "GetAppletInfo"},
+            {22, nullptr, "GetAdditionalInfo"},
+            {23, nullptr, "SetKeptInSleep"},
+            {24, nullptr, "RegisterSocketDescriptor"},
+            {25, nullptr, "UnregisterSocketDescriptor"},
+            {26, nullptr, "GetNetworkAccessStatus"}, //21.0.0+
         };
         RegisterHandlers(functions);
 
@@ -510,9 +510,9 @@ class INetworkProfile final : public ServiceFramework<INetworkProfile> {
 public:
     explicit INetworkProfile(Core::System& system_) : ServiceFramework{system_, "INetworkProfile"} {
         static const FunctionInfo functions[] = {
-            FunctionInfo{0, nullptr, "Update"},
-            FunctionInfo{1, nullptr, "PersistOld"},
-            FunctionInfo{2, nullptr, "Persist"}
+            {0, nullptr, "Update"},
+            {1, nullptr, "PersistOld"},
+            {2, nullptr, "Persist"},
         };
         RegisterHandlers(functions);
     }
@@ -1117,8 +1117,8 @@ public:
     explicit NetworkInterface(const char* name, Core::System& system_)
         : ServiceFramework{system_, name} {
         static const FunctionInfo functions[] = {
-            FunctionInfo{4, &NetworkInterface::CreateGeneralServiceOld, "CreateGeneralServiceOld"},
-            FunctionInfo{5, &NetworkInterface::CreateGeneralService, "CreateGeneralService"}
+            {4, &NetworkInterface::CreateGeneralServiceOld, "CreateGeneralServiceOld"},
+            {5, &NetworkInterface::CreateGeneralService, "CreateGeneralService"},
         };
         RegisterHandlers(functions);
     }

src/core/hle/service/nim/nim.cpp

@@ -24,20 +24,22 @@ namespace Service::NIM {
 class IShopServiceAsync final : public ServiceFramework<IShopServiceAsync> {
 public:
     explicit IShopServiceAsync(Core::System& system_)
-        : ServiceFramework{system_, "IShopServiceAsync"}
-        , service_context{system_, "IShopServiceAsync"} {
-        completion_event = service_context.CreateEvent("IShopServiceAsync:Completion");
-    }
+        : ServiceFramework{system_, "IShopServiceAsync"},
+          service_context{system_, "IShopServiceAsync"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, D<&IShopServiceAsync::Cancel>, "Cancel"},
+            {1, D<&IShopServiceAsync::GetSize>, "GetSize"},
+            {2, D<&IShopServiceAsync::Read>, "Read"},
+            {3, D<&IShopServiceAsync::GetErrorCode>, "GetErrorCode"},
+            {4, D<&IShopServiceAsync::Request>, "Request"},
+            {5, D<&IShopServiceAsync::Prepare>, "Prepare"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, D<&IShopServiceAsync::Cancel>, "Cancel"},
-            FunctionInfo{1, D<&IShopServiceAsync::GetSize>, "GetSize"},
-            FunctionInfo{2, D<&IShopServiceAsync::Read>, "Read"},
-            FunctionInfo{3, D<&IShopServiceAsync::GetErrorCode>, "GetErrorCode"},
-            FunctionInfo{4, D<&IShopServiceAsync::Request>, "Request"},
-            FunctionInfo{5, D<&IShopServiceAsync::Prepare>, "Prepare"}
-        );
+        RegisterHandlers(functions);
+
+        completion_event = service_context.CreateEvent("IShopServiceAsync:Completion");
     }
 
     ~IShopServiceAsync() override {
@@ -139,12 +141,14 @@ private:
 class IShopServiceAccessor final : public ServiceFramework<IShopServiceAccessor> {
 public:
     explicit IShopServiceAccessor(Core::System& system_)
-        : ServiceFramework{system_, "IShopServiceAccessor"} {}
+        : ServiceFramework{system_, "IShopServiceAccessor"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &IShopServiceAccessor::CreateAsyncInterface, "CreateAsyncInterface"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, &IShopServiceAccessor::CreateAsyncInterface, "CreateAsyncInterface"}
-        );
+        RegisterHandlers(functions);
     }
 
 private:
@@ -161,12 +165,14 @@ private:
 class IShopServiceAccessServer final : public ServiceFramework<IShopServiceAccessServer> {
 public:
     explicit IShopServiceAccessServer(Core::System& system_)
-        : ServiceFramework{system_, "IShopServiceAccessServer"} {}
+        : ServiceFramework{system_, "IShopServiceAccessServer"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &IShopServiceAccessServer::CreateAccessorInterface, "CreateAccessorInterface"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, &IShopServiceAccessServer::CreateAccessorInterface, "CreateAccessorInterface"}
-        );
+        RegisterHandlers(functions);
     }
 
 private:
@@ -180,250 +186,254 @@ private:
 
 class NIM final : public ServiceFramework<NIM> {
 public:
-    explicit NIM(Core::System& system_) : ServiceFramework{system_, "nim"} {}
+    explicit NIM(Core::System& system_) : ServiceFramework{system_, "nim"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "CreateSystemUpdateTask"},
+            {1, nullptr, "DestroySystemUpdateTask"},
+            {2, nullptr, "ListSystemUpdateTask"},
+            {3, nullptr, "RequestSystemUpdateTaskRun"},
+            {4, nullptr, "GetSystemUpdateTaskInfo"},
+            {5, nullptr, "CommitSystemUpdateTask"},
+            {6, nullptr, "CreateNetworkInstallTask"},
+            {7, nullptr, "DestroyNetworkInstallTask"},
+            {8, nullptr, "ListNetworkInstallTask"},
+            {9, nullptr, "RequestNetworkInstallTaskRun"},
+            {10, nullptr, "GetNetworkInstallTaskInfo"},
+            {11, nullptr, "CommitNetworkInstallTask"},
+            {12, nullptr, "RequestLatestSystemUpdateMeta"},
+            {14, nullptr, "ListApplicationNetworkInstallTask"},
+            {15, nullptr, "ListNetworkInstallTaskContentMeta"},
+            {16, nullptr, "RequestLatestVersion"},
+            {17, nullptr, "SetNetworkInstallTaskAttribute"},
+            {18, nullptr, "AddNetworkInstallTaskContentMeta"},
+            {19, nullptr, "GetDownloadedSystemDataPath"},
+            {20, nullptr, "CalculateNetworkInstallTaskRequiredSize"},
+            {21, nullptr, "IsExFatDriverIncluded"},
+            {22, nullptr, "GetBackgroundDownloadStressTaskInfo"},
+            {23, nullptr, "RequestDeviceAuthenticationToken"},
+            {24, nullptr, "RequestGameCardRegistrationStatus"},
+            {25, nullptr, "RequestRegisterGameCard"},
+            {26, nullptr, "RequestRegisterNotificationToken"},
+            {27, nullptr, "RequestDownloadTaskList"},
+            {28, nullptr, "RequestApplicationControl"},
+            {29, nullptr, "RequestLatestApplicationControl"},
+            {30, nullptr, "RequestVersionList"},
+            {31, nullptr, "CreateApplyDeltaTask"},
+            {32, nullptr, "DestroyApplyDeltaTask"},
+            {33, nullptr, "ListApplicationApplyDeltaTask"},
+            {34, nullptr, "RequestApplyDeltaTaskRun"},
+            {35, nullptr, "GetApplyDeltaTaskInfo"},
+            {36, nullptr, "ListApplyDeltaTask"},
+            {37, nullptr, "CommitApplyDeltaTask"},
+            {38, nullptr, "CalculateApplyDeltaTaskRequiredSize"},
+            {39, nullptr, "PrepareShutdown"},
+            {40, nullptr, "ListApplyDeltaTask"},
+            {41, nullptr, "ClearNotEnoughSpaceStateOfApplyDeltaTask"},
+            {42, nullptr, "CreateApplyDeltaTaskFromDownloadTask"},
+            {43, nullptr, "GetBackgroundApplyDeltaStressTaskInfo"},
+            {44, nullptr, "GetApplyDeltaTaskRequiredStorage"},
+            {45, nullptr, "CalculateNetworkInstallTaskContentsSize"},
+            {46, nullptr, "PrepareShutdownForSystemUpdate"},
+            {47, nullptr, "FindMaxRequiredApplicationVersionOfTask"},
+            {48, nullptr, "CommitNetworkInstallTaskPartially"},
+            {49, nullptr, "ListNetworkInstallTaskCommittedContentMeta"},
+            {50, nullptr, "ListNetworkInstallTaskNotCommittedContentMeta"},
+            {51, nullptr, "FindMaxRequiredSystemVersionOfTask"},
+            {52, nullptr, "GetNetworkInstallTaskErrorContext"},
+            {53, nullptr, "CreateLocalCommunicationReceiveApplicationTask"},
+            {54, nullptr, "DestroyLocalCommunicationReceiveApplicationTask"},
+            {55, nullptr, "ListLocalCommunicationReceiveApplicationTask"},
+            {56, nullptr, "RequestLocalCommunicationReceiveApplicationTaskRun"},
+            {57, nullptr, "GetLocalCommunicationReceiveApplicationTaskInfo"},
+            {58, nullptr, "CommitLocalCommunicationReceiveApplicationTask"},
+            {59, nullptr, "ListLocalCommunicationReceiveApplicationTaskContentMeta"},
+            {60, nullptr, "CreateLocalCommunicationSendApplicationTask"},
+            {61, nullptr, "RequestLocalCommunicationSendApplicationTaskRun"},
+            {62, nullptr, "GetLocalCommunicationReceiveApplicationTaskErrorContext"},
+            {63, nullptr, "GetLocalCommunicationSendApplicationTaskInfo"},
+            {64, nullptr, "DestroyLocalCommunicationSendApplicationTask"},
+            {65, nullptr, "GetLocalCommunicationSendApplicationTaskErrorContext"},
+            {66, nullptr, "CalculateLocalCommunicationReceiveApplicationTaskRequiredSize"},
+            {67, nullptr, "ListApplicationLocalCommunicationReceiveApplicationTask"},
+            {68, nullptr, "ListApplicationLocalCommunicationSendApplicationTask"},
+            {69, nullptr, "CreateLocalCommunicationReceiveSystemUpdateTask"},
+            {70, nullptr, "DestroyLocalCommunicationReceiveSystemUpdateTask"},
+            {71, nullptr, "ListLocalCommunicationReceiveSystemUpdateTask"},
+            {72, nullptr, "RequestLocalCommunicationReceiveSystemUpdateTaskRun"},
+            {73, nullptr, "GetLocalCommunicationReceiveSystemUpdateTaskInfo"},
+            {74, nullptr, "CommitLocalCommunicationReceiveSystemUpdateTask"},
+            {75, nullptr, "GetLocalCommunicationReceiveSystemUpdateTaskErrorContext"},
+            {76, nullptr, "CreateLocalCommunicationSendSystemUpdateTask"},
+            {77, nullptr, "RequestLocalCommunicationSendSystemUpdateTaskRun"},
+            {78, nullptr, "GetLocalCommunicationSendSystemUpdateTaskInfo"},
+            {79, nullptr, "DestroyLocalCommunicationSendSystemUpdateTask"},
+            {80, nullptr, "GetLocalCommunicationSendSystemUpdateTaskErrorContext"},
+            {81, nullptr, "ListLocalCommunicationSendSystemUpdateTask"},
+            {82, nullptr, "GetReceivedSystemDataPath"},
+            {83, nullptr, "CalculateApplyDeltaTaskOccupiedSize"},
+            {84, nullptr, "ReloadErrorSimulation"},
+            {85, nullptr, "ListNetworkInstallTaskContentMetaFromInstallMeta"},
+            {86, nullptr, "ListNetworkInstallTaskOccupiedSize"},
+            {87, nullptr, "RequestQueryAvailableELicenses"},
+            {88, nullptr, "RequestAssignELicenses"},
+            {89, nullptr, "RequestExtendELicenses"},
+            {90, nullptr, "RequestSyncELicenses"},
+            {91, nullptr, "Unknown91"}, //6.0.0-14.1.2
+            {92, nullptr, "Unknown92"}, //21.0.0+
+            {93, nullptr, "RequestReportActiveELicenses"},
+            {94, nullptr, "RequestReportActiveELicensesPassively"},
+            {95, nullptr, "RequestRegisterDynamicRightsNotificationToken"},
+            {96, nullptr, "RequestAssignAllDeviceLinkedELicenses"},
+            {97, nullptr, "RequestRevokeAllELicenses"},
+            {98, nullptr, "RequestPrefetchForDynamicRights"},
+            {99, nullptr, "CreateNetworkInstallTask"},
+            {100, nullptr, "ListNetworkInstallTaskRightsIds"},
+            {101, nullptr, "RequestDownloadETickets"},
+            {102, nullptr, "RequestQueryDownloadableContents"},
+            {103, nullptr, "DeleteNetworkInstallTaskContentMeta"},
+            {104, nullptr, "RequestIssueEdgeTokenForDebug"},
+            {105, nullptr, "RequestQueryAvailableELicenses2"},
+            {106, nullptr, "RequestAssignELicenses2"},
+            {107, nullptr, "GetNetworkInstallTaskStateCounter"},
+            {108, nullptr, "InvalidateDynamicRightsNaIdTokenCacheForDebug"},
+            {109, nullptr, "ListNetworkInstallTaskPartialInstallContentMeta"},
+            {110, nullptr, "ListNetworkInstallTaskRightsIdsFromIndex"},
+            {111, nullptr, "AddNetworkInstallTaskContentMetaForUser"},
+            {112, nullptr, "RequestAssignELicensesAndDownloadETickets"},
+            {113, nullptr, "RequestQueryAvailableCommonELicenses"},
+            {114, nullptr, "SetNetworkInstallTaskExtendedAttribute"},
+            {115, nullptr, "GetNetworkInstallTaskExtendedAttribute"},
+            {116, nullptr, "GetAllocatorInfo"},
+            {117, nullptr, "RequestQueryDownloadableContentsByApplicationId"},
+            {118, nullptr, "MarkNoDownloadRightsErrorResolved"},
+            {119, nullptr, "GetApplyDeltaTaskAllAppliedContentMeta"},
+            {120, nullptr, "PrioritizeNetworkInstallTask"},
+            {121, nullptr, "RequestQueryAvailableCommonELicenses2"},
+            {122, nullptr, "RequestAssignCommonELicenses"},
+            {123, nullptr, "RequestAssignCommonELicenses2"},
+            {124, nullptr, "IsNetworkInstallTaskFrontOfQueue"},
+            {125, nullptr, "PrioritizeApplyDeltaTask"},
+            {126, nullptr, "RerouteDownloadingPatch"},
+            {127, nullptr, "UnmarkNoDownloadRightsErrorResolved"},
+            {128, nullptr, "RequestContentsSize"},
+            {129, nullptr, "RequestContentsAuthorizationToken"},
+            {130, nullptr, "RequestCdnVendorDiscovery"},
+            {131, nullptr, "RefreshDebugAvailability"},
+            {132, nullptr, "ClearResponseSimulationEntry"},
+            {133, nullptr, "RegisterResponseSimulationEntry"},
+            {134, nullptr, "GetProcessedCdnVendors"},
+            {135, nullptr, "RefreshRuntimeBehaviorsForDebug"},
+            {136, nullptr, "RequestOnlineSubscriptionFreeTrialAvailability"},
+            {137, nullptr, "GetNetworkInstallTaskContentMetaCount"},
+            {138, nullptr, "RequestRevokeELicenses"},
+            {139, nullptr, "EnableNetworkConnectionToUseApplicationCore"},
+            {140, nullptr, "DisableNetworkConnectionToUseApplicationCore"},
+            {141, nullptr, "IsNetworkConnectionEnabledToUseApplicationCore"},
+            {142, nullptr, "RequestCheckSafeSystemVersion"},
+            {143, nullptr, "RequestApplicationIcon"},
+            {144, nullptr, "RequestDownloadIdbeIconFile"},
+            {147, nullptr, "Unknown147"}, //18.0.0+
+            {148, nullptr, "Unknown148"}, //18.0.0+
+            {150, nullptr, "Unknown150"}, //19.0.0+
+            {151, nullptr, "Unknown151"}, //20.0.0+
+            {152, nullptr, "Unknown152"}, //20.0.0+
+            {153, nullptr, "Unknown153"}, //20.0.0+
+            {154, nullptr, "Unknown154"}, //20.0.0+
+            {155, nullptr, "Unknown155"}, //20.0.0+
+            {156, nullptr, "Unknown156"}, //20.0.0+
+            {157, nullptr, "Unknown157"}, //20.0.0+
+            {158, nullptr, "Unknown158"}, //20.0.0+
+            {159, nullptr, "Unknown159"}, //20.0.0+
+            {160, nullptr, "Unknown160"}, //20.0.0+
+            {161, nullptr, "Unknown161"}, //20.0.0+
+            {162, nullptr, "Unknown162"}, //20.0.0+
+            {163, nullptr, "Unknown163"}, //20.0.0+
+            {164, nullptr, "Unknown164"}, //20.0.0+
+            {165, nullptr, "Unknown165"}, //20.0.0+
+            {166, nullptr, "Unknown166"}, //20.0.0+
+            {167, nullptr, "Unknown167"}, //20.0.0+
+            {168, nullptr, "Unknown168"}, //20.0.0+
+            {169, nullptr, "Unknown169"}, //20.0.0+
+            {170, nullptr, "Unknown170"}, //20.0.0+
+            {171, nullptr, "Unknown171"}, //20.0.0+
+            {172, nullptr, "Unknown172"}, //20.0.0+
+            {173, nullptr, "Unknown173"}, //20.0.0+
+            {174, nullptr, "Unknown174"}, //20.0.0+
+            {175, nullptr, "Unknown175"}, //20.0.0+
+            {176, nullptr, "Unknown176"}, //20.0.0+
+            {177, nullptr, "Unknown177"}, //20.0.0+
+            {2000, nullptr, "Unknown2000"}, //20.0.0+
+            {2001, nullptr, "Unknown2001"}, //20.0.0+
+            {2002, nullptr, "Unknown2002"}, //20.0.0+
+            {2003, nullptr, "Unknown2003"}, //20.0.0+
+            {2004, nullptr, "Unknown2004"}, //20.0.0+
+            {2007, nullptr, "Unknown2007"}, //20.0.0+
+            {2011, nullptr, "Unknown2011"}, //20.0.0+
+            {2012, nullptr, "Unknown2012"}, //20.0.0+
+            {2013, nullptr, "Unknown2013"}, //20.0.0+
+            {2014, nullptr, "Unknown2014"}, //20.0.0+
+            {2015, nullptr, "Unknown2015"}, //20.0.0+
+            {2016, nullptr, "Unknown2016"}, //20.0.0+
+            {2017, nullptr, "Unknown2017"}, //20.0.0+
+            {2018, nullptr, "Unknown2018"}, //20.0.0+
+            {2019, nullptr, "Unknown2019"}, //20.0.0+
+            {2020, nullptr, "Unknown2020"}, //20.0.0+
+            {2021, nullptr, "Unknown2021"}, //20.0.0+
+            {2022, nullptr, "Unknown2022"}, //20.0.0+
+            {2023, nullptr, "Unknown2023"}, //20.0.0+
+            {2024, nullptr, "Unknown2024"}, //20.0.0+
+            {2025, nullptr, "Unknown2025"}, //20.0.0+
+            {2026, nullptr, "Unknown2026"}, //20.0.0+
+            {2027, nullptr, "Unknown2027"}, //20.0.0+
+            {2028, nullptr, "Unknown2028"}, //20.0.0+
+            {2029, nullptr, "Unknown2029"}, //20.0.0+
+            {2030, nullptr, "Unknown2030"}, //20.0.0+
+            {2031, nullptr, "Unknown2031"}, //20.0.0+
+            {2032, nullptr, "Unknown2032"}, //20.0.0+
+            {2033, nullptr, "Unknown2033"}, //20.0.0+
+            {2034, nullptr, "Unknown2034"}, //20.0.0+
+            {2035, nullptr, "Unknown2035"}, //20.0.0+
+            {2036, nullptr, "Unknown2036"}, //20.0.0+
+            {2037, nullptr, "Unknown2037"}, //20.0.0+
+            {2038, nullptr, "Unknown2038"}, //20.0.0+
+            {2039, nullptr, "Unknown2039"}, //20.0.0+
+            {2040, nullptr, "Unknown2040"}, //20.0.0+
+            {2041, nullptr, "Unknown2041"}, //20.0.0+
+            {2042, nullptr, "Unknown2042"}, //20.0.0+
+            {2043, nullptr, "Unknown2043"}, //20.0.0+
+            {2044, nullptr, "Unknown2044"}, //20.0.0+
+            {2045, nullptr, "Unknown2045"}, //20.0.0+
+            {2046, nullptr, "Unknown2046"}, //20.0.0+
+            {2047, nullptr, "Unknown2047"}, //20.0.0+
+            {2048, nullptr, "Unknown2048"}, //20.0.0+
+            {2049, nullptr, "Unknown2049"}, //20.0.0+
+            {2050, nullptr, "Unknown2050"}, //20.0.0+
+            {2051, nullptr, "Unknown2051"}, //20.0.0+
+            {3000, nullptr, "RequestLatestApplicationIcon"}, //17.0.0+
+            {3001, nullptr, "RequestDownloadIdbeLatestIconFile"}, //17.0.0+
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "CreateSystemUpdateTask"},
-            FunctionInfo{1, nullptr, "DestroySystemUpdateTask"},
-            FunctionInfo{2, nullptr, "ListSystemUpdateTask"},
-            FunctionInfo{3, nullptr, "RequestSystemUpdateTaskRun"},
-            FunctionInfo{4, nullptr, "GetSystemUpdateTaskInfo"},
-            FunctionInfo{5, nullptr, "CommitSystemUpdateTask"},
-            FunctionInfo{6, nullptr, "CreateNetworkInstallTask"},
-            FunctionInfo{7, nullptr, "DestroyNetworkInstallTask"},
-            FunctionInfo{8, nullptr, "ListNetworkInstallTask"},
-            FunctionInfo{9, nullptr, "RequestNetworkInstallTaskRun"},
-            FunctionInfo{10, nullptr, "GetNetworkInstallTaskInfo"},
-            FunctionInfo{11, nullptr, "CommitNetworkInstallTask"},
-            FunctionInfo{12, nullptr, "RequestLatestSystemUpdateMeta"},
-            FunctionInfo{14, nullptr, "ListApplicationNetworkInstallTask"},
-            FunctionInfo{15, nullptr, "ListNetworkInstallTaskContentMeta"},
-            FunctionInfo{16, nullptr, "RequestLatestVersion"},
-            FunctionInfo{17, nullptr, "SetNetworkInstallTaskAttribute"},
-            FunctionInfo{18, nullptr, "AddNetworkInstallTaskContentMeta"},
-            FunctionInfo{19, nullptr, "GetDownloadedSystemDataPath"},
-            FunctionInfo{20, nullptr, "CalculateNetworkInstallTaskRequiredSize"},
-            FunctionInfo{21, nullptr, "IsExFatDriverIncluded"},
-            FunctionInfo{22, nullptr, "GetBackgroundDownloadStressTaskInfo"},
-            FunctionInfo{23, nullptr, "RequestDeviceAuthenticationToken"},
-            FunctionInfo{24, nullptr, "RequestGameCardRegistrationStatus"},
-            FunctionInfo{25, nullptr, "RequestRegisterGameCard"},
-            FunctionInfo{26, nullptr, "RequestRegisterNotificationToken"},
-            FunctionInfo{27, nullptr, "RequestDownloadTaskList"},
-            FunctionInfo{28, nullptr, "RequestApplicationControl"},
-            FunctionInfo{29, nullptr, "RequestLatestApplicationControl"},
-            FunctionInfo{30, nullptr, "RequestVersionList"},
-            FunctionInfo{31, nullptr, "CreateApplyDeltaTask"},
-            FunctionInfo{32, nullptr, "DestroyApplyDeltaTask"},
-            FunctionInfo{33, nullptr, "ListApplicationApplyDeltaTask"},
-            FunctionInfo{34, nullptr, "RequestApplyDeltaTaskRun"},
-            FunctionInfo{35, nullptr, "GetApplyDeltaTaskInfo"},
-            FunctionInfo{36, nullptr, "ListApplyDeltaTask"},
-            FunctionInfo{37, nullptr, "CommitApplyDeltaTask"},
-            FunctionInfo{38, nullptr, "CalculateApplyDeltaTaskRequiredSize"},
-            FunctionInfo{39, nullptr, "PrepareShutdown"},
-            FunctionInfo{40, nullptr, "ListApplyDeltaTask"},
-            FunctionInfo{41, nullptr, "ClearNotEnoughSpaceStateOfApplyDeltaTask"},
-            FunctionInfo{42, nullptr, "CreateApplyDeltaTaskFromDownloadTask"},
-            FunctionInfo{43, nullptr, "GetBackgroundApplyDeltaStressTaskInfo"},
-            FunctionInfo{44, nullptr, "GetApplyDeltaTaskRequiredStorage"},
-            FunctionInfo{45, nullptr, "CalculateNetworkInstallTaskContentsSize"},
-            FunctionInfo{46, nullptr, "PrepareShutdownForSystemUpdate"},
-            FunctionInfo{47, nullptr, "FindMaxRequiredApplicationVersionOfTask"},
-            FunctionInfo{48, nullptr, "CommitNetworkInstallTaskPartially"},
-            FunctionInfo{49, nullptr, "ListNetworkInstallTaskCommittedContentMeta"},
-            FunctionInfo{50, nullptr, "ListNetworkInstallTaskNotCommittedContentMeta"},
-            FunctionInfo{51, nullptr, "FindMaxRequiredSystemVersionOfTask"},
-            FunctionInfo{52, nullptr, "GetNetworkInstallTaskErrorContext"},
-            FunctionInfo{53, nullptr, "CreateLocalCommunicationReceiveApplicationTask"},
-            FunctionInfo{54, nullptr, "DestroyLocalCommunicationReceiveApplicationTask"},
-            FunctionInfo{55, nullptr, "ListLocalCommunicationReceiveApplicationTask"},
-            FunctionInfo{56, nullptr, "RequestLocalCommunicationReceiveApplicationTaskRun"},
-            FunctionInfo{57, nullptr, "GetLocalCommunicationReceiveApplicationTaskInfo"},
-            FunctionInfo{58, nullptr, "CommitLocalCommunicationReceiveApplicationTask"},
-            FunctionInfo{59, nullptr, "ListLocalCommunicationReceiveApplicationTaskContentMeta"},
-            FunctionInfo{60, nullptr, "CreateLocalCommunicationSendApplicationTask"},
-            FunctionInfo{61, nullptr, "RequestLocalCommunicationSendApplicationTaskRun"},
-            FunctionInfo{62, nullptr, "GetLocalCommunicationReceiveApplicationTaskErrorContext"},
-            FunctionInfo{63, nullptr, "GetLocalCommunicationSendApplicationTaskInfo"},
-            FunctionInfo{64, nullptr, "DestroyLocalCommunicationSendApplicationTask"},
-            FunctionInfo{65, nullptr, "GetLocalCommunicationSendApplicationTaskErrorContext"},
-            FunctionInfo{66, nullptr, "CalculateLocalCommunicationReceiveApplicationTaskRequiredSize"},
-            FunctionInfo{67, nullptr, "ListApplicationLocalCommunicationReceiveApplicationTask"},
-            FunctionInfo{68, nullptr, "ListApplicationLocalCommunicationSendApplicationTask"},
-            FunctionInfo{69, nullptr, "CreateLocalCommunicationReceiveSystemUpdateTask"},
-            FunctionInfo{70, nullptr, "DestroyLocalCommunicationReceiveSystemUpdateTask"},
-            FunctionInfo{71, nullptr, "ListLocalCommunicationReceiveSystemUpdateTask"},
-            FunctionInfo{72, nullptr, "RequestLocalCommunicationReceiveSystemUpdateTaskRun"},
-            FunctionInfo{73, nullptr, "GetLocalCommunicationReceiveSystemUpdateTaskInfo"},
-            FunctionInfo{74, nullptr, "CommitLocalCommunicationReceiveSystemUpdateTask"},
-            FunctionInfo{75, nullptr, "GetLocalCommunicationReceiveSystemUpdateTaskErrorContext"},
-            FunctionInfo{76, nullptr, "CreateLocalCommunicationSendSystemUpdateTask"},
-            FunctionInfo{77, nullptr, "RequestLocalCommunicationSendSystemUpdateTaskRun"},
-            FunctionInfo{78, nullptr, "GetLocalCommunicationSendSystemUpdateTaskInfo"},
-            FunctionInfo{79, nullptr, "DestroyLocalCommunicationSendSystemUpdateTask"},
-            FunctionInfo{80, nullptr, "GetLocalCommunicationSendSystemUpdateTaskErrorContext"},
-            FunctionInfo{81, nullptr, "ListLocalCommunicationSendSystemUpdateTask"},
-            FunctionInfo{82, nullptr, "GetReceivedSystemDataPath"},
-            FunctionInfo{83, nullptr, "CalculateApplyDeltaTaskOccupiedSize"},
-            FunctionInfo{84, nullptr, "ReloadErrorSimulation"},
-            FunctionInfo{85, nullptr, "ListNetworkInstallTaskContentMetaFromInstallMeta"},
-            FunctionInfo{86, nullptr, "ListNetworkInstallTaskOccupiedSize"},
-            FunctionInfo{87, nullptr, "RequestQueryAvailableELicenses"},
-            FunctionInfo{88, nullptr, "RequestAssignELicenses"},
-            FunctionInfo{89, nullptr, "RequestExtendELicenses"},
-            FunctionInfo{90, nullptr, "RequestSyncELicenses"},
-            FunctionInfo{91, nullptr, "Unknown91"}, //6.0.0-14.1.2
-            FunctionInfo{92, nullptr, "Unknown92"}, //21.0.0+
-            FunctionInfo{93, nullptr, "RequestReportActiveELicenses"},
-            FunctionInfo{94, nullptr, "RequestReportActiveELicensesPassively"},
-            FunctionInfo{95, nullptr, "RequestRegisterDynamicRightsNotificationToken"},
-            FunctionInfo{96, nullptr, "RequestAssignAllDeviceLinkedELicenses"},
-            FunctionInfo{97, nullptr, "RequestRevokeAllELicenses"},
-            FunctionInfo{98, nullptr, "RequestPrefetchForDynamicRights"},
-            FunctionInfo{99, nullptr, "CreateNetworkInstallTask"},
-            FunctionInfo{100, nullptr, "ListNetworkInstallTaskRightsIds"},
-            FunctionInfo{101, nullptr, "RequestDownloadETickets"},
-            FunctionInfo{102, nullptr, "RequestQueryDownloadableContents"},
-            FunctionInfo{103, nullptr, "DeleteNetworkInstallTaskContentMeta"},
-            FunctionInfo{104, nullptr, "RequestIssueEdgeTokenForDebug"},
-            FunctionInfo{105, nullptr, "RequestQueryAvailableELicenses2"},
-            FunctionInfo{106, nullptr, "RequestAssignELicenses2"},
-            FunctionInfo{107, nullptr, "GetNetworkInstallTaskStateCounter"},
-            FunctionInfo{108, nullptr, "InvalidateDynamicRightsNaIdTokenCacheForDebug"},
-            FunctionInfo{109, nullptr, "ListNetworkInstallTaskPartialInstallContentMeta"},
-            FunctionInfo{110, nullptr, "ListNetworkInstallTaskRightsIdsFromIndex"},
-            FunctionInfo{111, nullptr, "AddNetworkInstallTaskContentMetaForUser"},
-            FunctionInfo{112, nullptr, "RequestAssignELicensesAndDownloadETickets"},
-            FunctionInfo{113, nullptr, "RequestQueryAvailableCommonELicenses"},
-            FunctionInfo{114, nullptr, "SetNetworkInstallTaskExtendedAttribute"},
-            FunctionInfo{115, nullptr, "GetNetworkInstallTaskExtendedAttribute"},
-            FunctionInfo{116, nullptr, "GetAllocatorInfo"},
-            FunctionInfo{117, nullptr, "RequestQueryDownloadableContentsByApplicationId"},
-            FunctionInfo{118, nullptr, "MarkNoDownloadRightsErrorResolved"},
-            FunctionInfo{119, nullptr, "GetApplyDeltaTaskAllAppliedContentMeta"},
-            FunctionInfo{120, nullptr, "PrioritizeNetworkInstallTask"},
-            FunctionInfo{121, nullptr, "RequestQueryAvailableCommonELicenses2"},
-            FunctionInfo{122, nullptr, "RequestAssignCommonELicenses"},
-            FunctionInfo{123, nullptr, "RequestAssignCommonELicenses2"},
-            FunctionInfo{124, nullptr, "IsNetworkInstallTaskFrontOfQueue"},
-            FunctionInfo{125, nullptr, "PrioritizeApplyDeltaTask"},
-            FunctionInfo{126, nullptr, "RerouteDownloadingPatch"},
-            FunctionInfo{127, nullptr, "UnmarkNoDownloadRightsErrorResolved"},
-            FunctionInfo{128, nullptr, "RequestContentsSize"},
-            FunctionInfo{129, nullptr, "RequestContentsAuthorizationToken"},
-            FunctionInfo{130, nullptr, "RequestCdnVendorDiscovery"},
-            FunctionInfo{131, nullptr, "RefreshDebugAvailability"},
-            FunctionInfo{132, nullptr, "ClearResponseSimulationEntry"},
-            FunctionInfo{133, nullptr, "RegisterResponseSimulationEntry"},
-            FunctionInfo{134, nullptr, "GetProcessedCdnVendors"},
-            FunctionInfo{135, nullptr, "RefreshRuntimeBehaviorsForDebug"},
-            FunctionInfo{136, nullptr, "RequestOnlineSubscriptionFreeTrialAvailability"},
-            FunctionInfo{137, nullptr, "GetNetworkInstallTaskContentMetaCount"},
-            FunctionInfo{138, nullptr, "RequestRevokeELicenses"},
-            FunctionInfo{139, nullptr, "EnableNetworkConnectionToUseApplicationCore"},
-            FunctionInfo{140, nullptr, "DisableNetworkConnectionToUseApplicationCore"},
-            FunctionInfo{141, nullptr, "IsNetworkConnectionEnabledToUseApplicationCore"},
-            FunctionInfo{142, nullptr, "RequestCheckSafeSystemVersion"},
-            FunctionInfo{143, nullptr, "RequestApplicationIcon"},
-            FunctionInfo{144, nullptr, "RequestDownloadIdbeIconFile"},
-            FunctionInfo{147, nullptr, "Unknown147"}, //18.0.0+
-            FunctionInfo{148, nullptr, "Unknown148"}, //18.0.0+
-            FunctionInfo{150, nullptr, "Unknown150"}, //19.0.0+
-            FunctionInfo{151, nullptr, "Unknown151"}, //20.0.0+
-            FunctionInfo{152, nullptr, "Unknown152"}, //20.0.0+
-            FunctionInfo{153, nullptr, "Unknown153"}, //20.0.0+
-            FunctionInfo{154, nullptr, "Unknown154"}, //20.0.0+
-            FunctionInfo{155, nullptr, "Unknown155"}, //20.0.0+
-            FunctionInfo{156, nullptr, "Unknown156"}, //20.0.0+
-            FunctionInfo{157, nullptr, "Unknown157"}, //20.0.0+
-            FunctionInfo{158, nullptr, "Unknown158"}, //20.0.0+
-            FunctionInfo{159, nullptr, "Unknown159"}, //20.0.0+
-            FunctionInfo{160, nullptr, "Unknown160"}, //20.0.0+
-            FunctionInfo{161, nullptr, "Unknown161"}, //20.0.0+
-            FunctionInfo{162, nullptr, "Unknown162"}, //20.0.0+
-            FunctionInfo{163, nullptr, "Unknown163"}, //20.0.0+
-            FunctionInfo{164, nullptr, "Unknown164"}, //20.0.0+
-            FunctionInfo{165, nullptr, "Unknown165"}, //20.0.0+
-            FunctionInfo{166, nullptr, "Unknown166"}, //20.0.0+
-            FunctionInfo{167, nullptr, "Unknown167"}, //20.0.0+
-            FunctionInfo{168, nullptr, "Unknown168"}, //20.0.0+
-            FunctionInfo{169, nullptr, "Unknown169"}, //20.0.0+
-            FunctionInfo{170, nullptr, "Unknown170"}, //20.0.0+
-            FunctionInfo{171, nullptr, "Unknown171"}, //20.0.0+
-            FunctionInfo{172, nullptr, "Unknown172"}, //20.0.0+
-            FunctionInfo{173, nullptr, "Unknown173"}, //20.0.0+
-            FunctionInfo{174, nullptr, "Unknown174"}, //20.0.0+
-            FunctionInfo{175, nullptr, "Unknown175"}, //20.0.0+
-            FunctionInfo{176, nullptr, "Unknown176"}, //20.0.0+
-            FunctionInfo{177, nullptr, "Unknown177"}, //20.0.0+
-            FunctionInfo{2000, nullptr, "Unknown2000"}, //20.0.0+
-            FunctionInfo{2001, nullptr, "Unknown2001"}, //20.0.0+
-            FunctionInfo{2002, nullptr, "Unknown2002"}, //20.0.0+
-            FunctionInfo{2003, nullptr, "Unknown2003"}, //20.0.0+
-            FunctionInfo{2004, nullptr, "Unknown2004"}, //20.0.0+
-            FunctionInfo{2007, nullptr, "Unknown2007"}, //20.0.0+
-            FunctionInfo{2011, nullptr, "Unknown2011"}, //20.0.0+
-            FunctionInfo{2012, nullptr, "Unknown2012"}, //20.0.0+
-            FunctionInfo{2013, nullptr, "Unknown2013"}, //20.0.0+
-            FunctionInfo{2014, nullptr, "Unknown2014"}, //20.0.0+
-            FunctionInfo{2015, nullptr, "Unknown2015"}, //20.0.0+
-            FunctionInfo{2016, nullptr, "Unknown2016"}, //20.0.0+
-            FunctionInfo{2017, nullptr, "Unknown2017"}, //20.0.0+
-            FunctionInfo{2018, nullptr, "Unknown2018"}, //20.0.0+
-            FunctionInfo{2019, nullptr, "Unknown2019"}, //20.0.0+
-            FunctionInfo{2020, nullptr, "Unknown2020"}, //20.0.0+
-            FunctionInfo{2021, nullptr, "Unknown2021"}, //20.0.0+
-            FunctionInfo{2022, nullptr, "Unknown2022"}, //20.0.0+
-            FunctionInfo{2023, nullptr, "Unknown2023"}, //20.0.0+
-            FunctionInfo{2024, nullptr, "Unknown2024"}, //20.0.0+
-            FunctionInfo{2025, nullptr, "Unknown2025"}, //20.0.0+
-            FunctionInfo{2026, nullptr, "Unknown2026"}, //20.0.0+
-            FunctionInfo{2027, nullptr, "Unknown2027"}, //20.0.0+
-            FunctionInfo{2028, nullptr, "Unknown2028"}, //20.0.0+
-            FunctionInfo{2029, nullptr, "Unknown2029"}, //20.0.0+
-            FunctionInfo{2030, nullptr, "Unknown2030"}, //20.0.0+
-            FunctionInfo{2031, nullptr, "Unknown2031"}, //20.0.0+
-            FunctionInfo{2032, nullptr, "Unknown2032"}, //20.0.0+
-            FunctionInfo{2033, nullptr, "Unknown2033"}, //20.0.0+
-            FunctionInfo{2034, nullptr, "Unknown2034"}, //20.0.0+
-            FunctionInfo{2035, nullptr, "Unknown2035"}, //20.0.0+
-            FunctionInfo{2036, nullptr, "Unknown2036"}, //20.0.0+
-            FunctionInfo{2037, nullptr, "Unknown2037"}, //20.0.0+
-            FunctionInfo{2038, nullptr, "Unknown2038"}, //20.0.0+
-            FunctionInfo{2039, nullptr, "Unknown2039"}, //20.0.0+
-            FunctionInfo{2040, nullptr, "Unknown2040"}, //20.0.0+
-            FunctionInfo{2041, nullptr, "Unknown2041"}, //20.0.0+
-            FunctionInfo{2042, nullptr, "Unknown2042"}, //20.0.0+
-            FunctionInfo{2043, nullptr, "Unknown2043"}, //20.0.0+
-            FunctionInfo{2044, nullptr, "Unknown2044"}, //20.0.0+
-            FunctionInfo{2045, nullptr, "Unknown2045"}, //20.0.0+
-            FunctionInfo{2046, nullptr, "Unknown2046"}, //20.0.0+
-            FunctionInfo{2047, nullptr, "Unknown2047"}, //20.0.0+
-            FunctionInfo{2048, nullptr, "Unknown2048"}, //20.0.0+
-            FunctionInfo{2049, nullptr, "Unknown2049"}, //20.0.0+
-            FunctionInfo{2050, nullptr, "Unknown2050"}, //20.0.0+
-            FunctionInfo{2051, nullptr, "Unknown2051"}, //20.0.0+
-            FunctionInfo{3000, nullptr, "RequestLatestApplicationIcon"}, //17.0.0+
-            FunctionInfo{3001, nullptr, "RequestDownloadIdbeLatestIconFile"} //17.0.0+
-        );
+        RegisterHandlers(functions);
     }
 };
 
 class NIM_ECA final : public ServiceFramework<NIM_ECA> {
 public:
-    explicit NIM_ECA(Core::System& system_) : ServiceFramework{system_, "nim:eca"} {}
+    explicit NIM_ECA(Core::System& system_) : ServiceFramework{system_, "nim:eca"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &NIM_ECA::CreateServerInterface, "CreateServerInterface"},
+            {1, nullptr, "RefreshDebugAvailability"},
+            {2, nullptr, "ClearDebugResponse"},
+            {3, nullptr, "RegisterDebugResponse"},
+            {4, &NIM_ECA::IsLargeResourceAvailable, "IsLargeResourceAvailable"},
+            {5, &NIM_ECA::CreateServerInterface2, "CreateServerInterface2"} // 17.0.0+
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, &NIM_ECA::CreateServerInterface, "CreateServerInterface"},
-            FunctionInfo{1, nullptr, "RefreshDebugAvailability"},
-            FunctionInfo{2, nullptr, "ClearDebugResponse"},
-            FunctionInfo{3, nullptr, "RegisterDebugResponse"},
-            FunctionInfo{4, &NIM_ECA::IsLargeResourceAvailable, "IsLargeResourceAvailable"},
-            FunctionInfo{5, &NIM_ECA::CreateServerInterface2, "CreateServerInterface2"} // 17.0.0+
-        );
+        RegisterHandlers(functions);
     }
 
 private:
@@ -457,39 +467,41 @@ private:
 
 class NIM_SHP final : public ServiceFramework<NIM_SHP> {
 public:
-    explicit NIM_SHP(Core::System& system_) : ServiceFramework{system_, "nim:shp"} {}
+    explicit NIM_SHP(Core::System& system_) : ServiceFramework{system_, "nim:shp"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "RequestDeviceAuthenticationToken"},
+            {1, nullptr, "RequestCachedDeviceAuthenticationToken"},
+            {2, nullptr, "RequestEdgeToken"},
+            {3, nullptr, "RequestCachedEdgeToken"},
+            {100, nullptr, "RequestRegisterDeviceAccount"},
+            {101, nullptr, "RequestUnregisterDeviceAccount"},
+            {102, nullptr, "RequestDeviceAccountStatus"},
+            {103, nullptr, "GetDeviceAccountInfo"},
+            {104, nullptr, "RequestDeviceRegistrationInfo"},
+            {105, nullptr, "RequestTransferDeviceAccount"},
+            {106, nullptr, "RequestSyncRegistration"},
+            {107, nullptr, "IsOwnDeviceId"},
+            {200, nullptr, "RequestRegisterNotificationToken"},
+            {300, nullptr, "RequestUnlinkDevice"},
+            {301, nullptr, "RequestUnlinkDeviceIntegrated"},
+            {302, nullptr, "RequestLinkDevice"},
+            {303, nullptr, "HasDeviceLink"},
+            {304, nullptr, "RequestUnlinkDeviceAll"},
+            {305, nullptr, "RequestCreateVirtualAccount"},
+            {306, nullptr, "RequestDeviceLinkStatus"},
+            {400, nullptr, "GetAccountByVirtualAccount"},
+            {401, nullptr, "GetVirtualAccount"},
+            {500, nullptr, "RequestSyncTicketLegacy"},
+            {501, nullptr, "RequestDownloadTicket"},
+            {502, nullptr, "RequestDownloadTicketForPrepurchasedContents"},
+            {503, nullptr, "RequestSyncTicket"},
+            {504, nullptr, "RequestDownloadTicketForPrepurchasedContents2"},
+            {505, nullptr, "RequestDownloadTicketForPrepurchasedContentsForAccount"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "RequestDeviceAuthenticationToken"},
-            FunctionInfo{1, nullptr, "RequestCachedDeviceAuthenticationToken"},
-            FunctionInfo{2, nullptr, "RequestEdgeToken"},
-            FunctionInfo{3, nullptr, "RequestCachedEdgeToken"},
-            FunctionInfo{100, nullptr, "RequestRegisterDeviceAccount"},
-            FunctionInfo{101, nullptr, "RequestUnregisterDeviceAccount"},
-            FunctionInfo{102, nullptr, "RequestDeviceAccountStatus"},
-            FunctionInfo{103, nullptr, "GetDeviceAccountInfo"},
-            FunctionInfo{104, nullptr, "RequestDeviceRegistrationInfo"},
-            FunctionInfo{105, nullptr, "RequestTransferDeviceAccount"},
-            FunctionInfo{106, nullptr, "RequestSyncRegistration"},
-            FunctionInfo{107, nullptr, "IsOwnDeviceId"},
-            FunctionInfo{200, nullptr, "RequestRegisterNotificationToken"},
-            FunctionInfo{300, nullptr, "RequestUnlinkDevice"},
-            FunctionInfo{301, nullptr, "RequestUnlinkDeviceIntegrated"},
-            FunctionInfo{302, nullptr, "RequestLinkDevice"},
-            FunctionInfo{303, nullptr, "HasDeviceLink"},
-            FunctionInfo{304, nullptr, "RequestUnlinkDeviceAll"},
-            FunctionInfo{305, nullptr, "RequestCreateVirtualAccount"},
-            FunctionInfo{306, nullptr, "RequestDeviceLinkStatus"},
-            FunctionInfo{400, nullptr, "GetAccountByVirtualAccount"},
-            FunctionInfo{401, nullptr, "GetVirtualAccount"},
-            FunctionInfo{500, nullptr, "RequestSyncTicketLegacy"},
-            FunctionInfo{501, nullptr, "RequestDownloadTicket"},
-            FunctionInfo{502, nullptr, "RequestDownloadTicketForPrepurchasedContents"},
-            FunctionInfo{503, nullptr, "RequestSyncTicket"},
-            FunctionInfo{504, nullptr, "RequestDownloadTicketForPrepurchasedContents2"},
-            FunctionInfo{505, nullptr, "RequestDownloadTicketForPrepurchasedContentsForAccount"}
-        );
+        RegisterHandlers(functions);
     }
 };
 
@@ -500,13 +512,13 @@ public:
         : ServiceFramework{system_, "IEnsureNetworkClockAvailabilityService"},
           service_context{system_, "IEnsureNetworkClockAvailabilityService"} {
         static const FunctionInfo functions[] = {
-            FunctionInfo{0, &IEnsureNetworkClockAvailabilityService::StartTask, "StartTask"},
-            FunctionInfo{1, &IEnsureNetworkClockAvailabilityService::GetFinishNotificationEvent,
+            {0, &IEnsureNetworkClockAvailabilityService::StartTask, "StartTask"},
+            {1, &IEnsureNetworkClockAvailabilityService::GetFinishNotificationEvent,
              "GetFinishNotificationEvent"},
-            FunctionInfo{2, &IEnsureNetworkClockAvailabilityService::GetResult, "GetResult"},
-            FunctionInfo{3, &IEnsureNetworkClockAvailabilityService::Cancel, "Cancel"},
-            FunctionInfo{4, &IEnsureNetworkClockAvailabilityService::IsProcessing, "IsProcessing"},
-            FunctionInfo{5, &IEnsureNetworkClockAvailabilityService::GetServerTime, "GetServerTime"}
+            {2, &IEnsureNetworkClockAvailabilityService::GetResult, "GetResult"},
+            {3, &IEnsureNetworkClockAvailabilityService::Cancel, "Cancel"},
+            {4, &IEnsureNetworkClockAvailabilityService::IsProcessing, "IsProcessing"},
+            {5, &IEnsureNetworkClockAvailabilityService::GetServerTime, "GetServerTime"},
         };
         RegisterHandlers(functions);
 
@@ -575,14 +587,16 @@ private:
 
 class NTC final : public ServiceFramework<NTC> {
 public:
-    explicit NTC(Core::System& system_) : ServiceFramework{system_, "ntc"} {}
+    explicit NTC(Core::System& system_) : ServiceFramework{system_, "ntc"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &NTC::OpenEnsureNetworkClockAvailabilityService, "OpenEnsureNetworkClockAvailabilityService"},
+            {100, &NTC::SuspendAutonomicTimeCorrection, "SuspendAutonomicTimeCorrection"},
+            {101, &NTC::ResumeAutonomicTimeCorrection, "ResumeAutonomicTimeCorrection"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, &NTC::OpenEnsureNetworkClockAvailabilityService, "OpenEnsureNetworkClockAvailabilityService"},
-            FunctionInfo{100, &NTC::SuspendAutonomicTimeCorrection, "SuspendAutonomicTimeCorrection"},
-            FunctionInfo{101, &NTC::ResumeAutonomicTimeCorrection, "ResumeAutonomicTimeCorrection"}
-        );
+        RegisterHandlers(functions);
     }
 
 private:
@@ -612,13 +626,14 @@ private:
 
 class NIM_ECAS final : public ServiceFramework<NIM_ECAS> {
 public:
-    explicit NIM_ECAS(Core::System& system_) : ServiceFramework{system_, "nim:ecas"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "RegisterSpecialClient"},
-            FunctionInfo{1, nullptr, "UnregisterSpecialClient"}
-        );
+    explicit NIM_ECAS(Core::System& system_) : ServiceFramework{system_, "nim:ecas"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "RegisterSpecialClient"},
+            {1, nullptr, "UnregisterSpecialClient"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 

src/core/hle/service/npns/npns.cpp

@@ -19,77 +19,79 @@ class INpnsSystem final : public ServiceFramework<INpnsSystem> {
 public:
     explicit INpnsSystem(Core::System& system_)
         : ServiceFramework{system_, "npns:s"}, service_context{system, "npns:s"},
-          get_receive_event{service_context}, get_request_change_state_cancel_event{service_context} {}
+          get_receive_event{service_context}, get_request_change_state_cancel_event{service_context} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {1, nullptr, "ListenAll"},
+            {2, C<&INpnsSystem::ListenTo>, "ListenTo"},
+            {3, nullptr, "Receive"},
+            {4, nullptr, "ReceiveRaw"},
+            {5, C<&INpnsSystem::GetReceiveEvent>, "GetReceiveEvent"},
+            {6, nullptr, "ListenUndelivered"},
+            {7, nullptr, "GetStateChangeEvent"},
+            {8, C<&INpnsSystem::ListenToByName>, "ListenToByName"},
+            {11, nullptr, "SubscribeTopic"},
+            {12, nullptr, "UnsubscribeTopic"},
+            {13, nullptr, "QueryIsTopicExist"},
+            {14, nullptr, "SubscribeTopicByAccount"}, // 18.0.0+
+            {15, nullptr, "UnsubscribeTopicByAccount"}, // 18.0.0+
+            {16, nullptr, "DownloadSubscriptionList"}, // 18.0.0+
+            {21, nullptr, "CreateToken"},
+            {22, nullptr, "CreateTokenWithApplicationId"},
+            {23, nullptr, "DestroyToken"},
+            {24, nullptr, "DestroyTokenWithApplicationId"},
+            {25, nullptr, "QueryIsTokenValid"},
+            {26, nullptr, "ListenToMyApplicationId"},
+            {27, nullptr, "DestroyTokenAll"},
+            {28, nullptr, "CreateTokenWithName"}, // 18.0.0+
+            {29, nullptr, "DestroyTokenWithName"}, // 18.0.0+
+            {31, nullptr, "UploadTokenToBaaS"},
+            {32, nullptr, "DestroyTokenForBaaS"},
+            {33, nullptr, "CreateTokenForBaaS"},
+            {34, nullptr, "SetBaaSDeviceAccountIdList"},
+            {35, nullptr, "LinkNsaId"}, // 17.0.0+
+            {36, nullptr, "UnlinkNsaId"}, // 17.0.0+
+            {37, nullptr, "RelinkNsaId"}, // 18.0.0+
+            {40, nullptr, "GetNetworkServiceAccountIdTokenRequestEvent"}, // 17.0.0+
+            {41, nullptr, "TryPopNetworkServiceAccountIdTokenRequestUid"}, // 17.0.0+
+            {42, nullptr, "SetNetworkServiceAccountIdTokenSuccess"}, // 17.0.0+
+            {43, nullptr, "SetNetworkServiceAccountIdTokenFailure"}, // 17.0.0+
+            {44, nullptr, "SetUidList"}, // 17.0.0+
+            {45, nullptr, "PutDigitalTwinKeyValue"}, // 17.0.0+
+            {51, nullptr, "DeleteDigitalTwinKeyValue"}, // 18.0.0+
+            {101, nullptr, "Suspend"},
+            {102, nullptr, "Resume"},
+            {103, C<&INpnsSystem::GetState>, "GetState"},
+            {104, nullptr, "GetStatistics"},
+            {105, nullptr, "GetPlayReportRequestEvent"},
+            {106, C<&INpnsSystem::GetLastNotifiedTime>, "GetLastNotifiedTime"}, // 18.0.0+
+            {107, nullptr, "SetLastNotifiedTime"}, // 18.0.0+
+            {111, nullptr, "GetJid"},
+            {112, nullptr, "CreateJid"},
+            {113, nullptr, "DestroyJid"},
+            {114, nullptr, "AttachJid"},
+            {115, nullptr, "DetachJid"},
+            {120, nullptr, "CreateNotificationReceiver"},
+            {151, nullptr, "GetStateWithHandover"},
+            {152, nullptr, "GetStateChangeEventWithHandover"},
+            {153, nullptr, "GetDropEventWithHandover"},
+            {154, nullptr, "CreateTokenAsync"},
+            {155, nullptr, "CreateTokenAsyncWithApplicationId"},
+            {156, nullptr, "CreateTokenWithNameAsync"}, // 18.0.0+
+            {161, C<&INpnsSystem::GetRequestChangeStateCancelEvent>, "GetRequestChangeStateCancelEvent"}, // 10.0.0+
+            {162, nullptr, "RequestChangeStateForceTimedWithCancelEvent"},
+            {201, nullptr, "RequestChangeStateForceTimed"},
+            {202, nullptr, "RequestChangeStateForceAsync"},
+            {301, nullptr, "GetPassword"}, // 18.0.0+
+            {302, nullptr, "GetAllImmigration"}, // 18.0.0+
+            {303, nullptr, "GetNotificationHistories"}, // 18.0.0+
+            {304, nullptr, "GetPersistentConnectionSummary"}, // 18.0.0+
+            {305, nullptr, "GetDigitalTwinSummary"}, // 18.0.0+
+            {306, nullptr, "GetDigitalTwinValue"}, // 18.0.0+
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{1, nullptr, "ListenAll"},
-            FunctionInfo{2, C<&INpnsSystem::ListenTo>, "ListenTo"},
-            FunctionInfo{3, nullptr, "Receive"},
-            FunctionInfo{4, nullptr, "ReceiveRaw"},
-            FunctionInfo{5, C<&INpnsSystem::GetReceiveEvent>, "GetReceiveEvent"},
-            FunctionInfo{6, nullptr, "ListenUndelivered"},
-            FunctionInfo{7, nullptr, "GetStateChangeEvent"},
-            FunctionInfo{8, C<&INpnsSystem::ListenToByName>, "ListenToByName"},
-            FunctionInfo{11, nullptr, "SubscribeTopic"},
-            FunctionInfo{12, nullptr, "UnsubscribeTopic"},
-            FunctionInfo{13, nullptr, "QueryIsTopicExist"},
-            FunctionInfo{14, nullptr, "SubscribeTopicByAccount"}, // 18.0.0+
-            FunctionInfo{15, nullptr, "UnsubscribeTopicByAccount"}, // 18.0.0+
-            FunctionInfo{16, nullptr, "DownloadSubscriptionList"}, // 18.0.0+
-            FunctionInfo{21, nullptr, "CreateToken"},
-            FunctionInfo{22, nullptr, "CreateTokenWithApplicationId"},
-            FunctionInfo{23, nullptr, "DestroyToken"},
-            FunctionInfo{24, nullptr, "DestroyTokenWithApplicationId"},
-            FunctionInfo{25, nullptr, "QueryIsTokenValid"},
-            FunctionInfo{26, nullptr, "ListenToMyApplicationId"},
-            FunctionInfo{27, nullptr, "DestroyTokenAll"},
-            FunctionInfo{28, nullptr, "CreateTokenWithName"}, // 18.0.0+
-            FunctionInfo{29, nullptr, "DestroyTokenWithName"}, // 18.0.0+
-            FunctionInfo{31, nullptr, "UploadTokenToBaaS"},
-            FunctionInfo{32, nullptr, "DestroyTokenForBaaS"},
-            FunctionInfo{33, nullptr, "CreateTokenForBaaS"},
-            FunctionInfo{34, nullptr, "SetBaaSDeviceAccountIdList"},
-            FunctionInfo{35, nullptr, "LinkNsaId"}, // 17.0.0+
-            FunctionInfo{36, nullptr, "UnlinkNsaId"}, // 17.0.0+
-            FunctionInfo{37, nullptr, "RelinkNsaId"}, // 18.0.0+
-            FunctionInfo{40, nullptr, "GetNetworkServiceAccountIdTokenRequestEvent"}, // 17.0.0+
-            FunctionInfo{41, nullptr, "TryPopNetworkServiceAccountIdTokenRequestUid"}, // 17.0.0+
-            FunctionInfo{42, nullptr, "SetNetworkServiceAccountIdTokenSuccess"}, // 17.0.0+
-            FunctionInfo{43, nullptr, "SetNetworkServiceAccountIdTokenFailure"}, // 17.0.0+
-            FunctionInfo{44, nullptr, "SetUidList"}, // 17.0.0+
-            FunctionInfo{45, nullptr, "PutDigitalTwinKeyValue"}, // 17.0.0+
-            FunctionInfo{51, nullptr, "DeleteDigitalTwinKeyValue"}, // 18.0.0+
-            FunctionInfo{101, nullptr, "Suspend"},
-            FunctionInfo{102, nullptr, "Resume"},
-            FunctionInfo{103, C<&INpnsSystem::GetState>, "GetState"},
-            FunctionInfo{104, nullptr, "GetStatistics"},
-            FunctionInfo{105, nullptr, "GetPlayReportRequestEvent"},
-            FunctionInfo{106, C<&INpnsSystem::GetLastNotifiedTime>, "GetLastNotifiedTime"}, // 18.0.0+
-            FunctionInfo{107, nullptr, "SetLastNotifiedTime"}, // 18.0.0+
-            FunctionInfo{111, nullptr, "GetJid"},
-            FunctionInfo{112, nullptr, "CreateJid"},
-            FunctionInfo{113, nullptr, "DestroyJid"},
-            FunctionInfo{114, nullptr, "AttachJid"},
-            FunctionInfo{115, nullptr, "DetachJid"},
-            FunctionInfo{120, nullptr, "CreateNotificationReceiver"},
-            FunctionInfo{151, nullptr, "GetStateWithHandover"},
-            FunctionInfo{152, nullptr, "GetStateChangeEventWithHandover"},
-            FunctionInfo{153, nullptr, "GetDropEventWithHandover"},
-            FunctionInfo{154, nullptr, "CreateTokenAsync"},
-            FunctionInfo{155, nullptr, "CreateTokenAsyncWithApplicationId"},
-            FunctionInfo{156, nullptr, "CreateTokenWithNameAsync"}, // 18.0.0+
-            FunctionInfo{161, C<&INpnsSystem::GetRequestChangeStateCancelEvent>, "GetRequestChangeStateCancelEvent"}, // 10.0.0+
-            FunctionInfo{162, nullptr, "RequestChangeStateForceTimedWithCancelEvent"},
-            FunctionInfo{201, nullptr, "RequestChangeStateForceTimed"},
-            FunctionInfo{202, nullptr, "RequestChangeStateForceAsync"},
-            FunctionInfo{301, nullptr, "GetPassword"}, // 18.0.0+
-            FunctionInfo{302, nullptr, "GetAllImmigration"}, // 18.0.0+
-            FunctionInfo{303, nullptr, "GetNotificationHistories"}, // 18.0.0+
-            FunctionInfo{304, nullptr, "GetPersistentConnectionSummary"}, // 18.0.0+
-            FunctionInfo{305, nullptr, "GetDigitalTwinSummary"}, // 18.0.0+
-            FunctionInfo{306, nullptr, "GetDigitalTwinValue"} // 18.0.0+
-        );
+        RegisterHandlers(functions);
     }
 
     ~INpnsSystem() override = default;
@@ -146,32 +148,34 @@ private:
 class INpnsUser final : public ServiceFramework<INpnsUser> {
 public:
     explicit INpnsUser(Core::System& system_)
-        : ServiceFramework{system_, "npns:u"}, service_context{system, "npns:u"}, get_receive_event{service_context} {}
+        : ServiceFramework{system_, "npns:u"}, service_context{system, "npns:u"}, get_receive_event{service_context} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {1, nullptr, "ListenAll"},
+            {2, nullptr, "ListenTo"},
+            {3, nullptr, "Receive"},
+            {4, nullptr, "ReceiveRaw"},
+            {5, C<&INpnsUser::GetReceiveEvent>, "GetReceiveEvent"},
+            {7, nullptr, "GetStateChangeEvent"},
+            {8, C<&INpnsUser::ListenToByName>, "ListenToByName"}, // 18.0.0+
+            {21, nullptr, "CreateToken"},
+            {23, nullptr, "DestroyToken"},
+            {25, nullptr, "QueryIsTokenValid"},
+            {26, nullptr, "ListenToMyApplicationId"},
+            {101, nullptr, "Suspend"},
+            {102, nullptr, "Resume"},
+            {103, nullptr, "GetState"},
+            {104, nullptr, "GetStatistics"},
+            {111, nullptr, "GetJid"},
+            {120, nullptr, "CreateNotificationReceiver"},
+            {151, nullptr, "GetStateWithHandover"},
+            {152, nullptr, "GetStateChangeEventWithHandover"},
+            {153, nullptr, "GetDropEventWithHandover"},
+            {154, nullptr, "CreateTokenAsync"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{1, nullptr, "ListenAll"},
-            FunctionInfo{2, nullptr, "ListenTo"},
-            FunctionInfo{3, nullptr, "Receive"},
-            FunctionInfo{4, nullptr, "ReceiveRaw"},
-            FunctionInfo{5, C<&INpnsUser::GetReceiveEvent>, "GetReceiveEvent"},
-            FunctionInfo{7, nullptr, "GetStateChangeEvent"},
-            FunctionInfo{8, C<&INpnsUser::ListenToByName>, "ListenToByName"}, // 18.0.0+
-            FunctionInfo{21, nullptr, "CreateToken"},
-            FunctionInfo{23, nullptr, "DestroyToken"},
-            FunctionInfo{25, nullptr, "QueryIsTokenValid"},
-            FunctionInfo{26, nullptr, "ListenToMyApplicationId"},
-            FunctionInfo{101, nullptr, "Suspend"},
-            FunctionInfo{102, nullptr, "Resume"},
-            FunctionInfo{103, nullptr, "GetState"},
-            FunctionInfo{104, nullptr, "GetStatistics"},
-            FunctionInfo{111, nullptr, "GetJid"},
-            FunctionInfo{120, nullptr, "CreateNotificationReceiver"},
-            FunctionInfo{151, nullptr, "GetStateWithHandover"},
-            FunctionInfo{152, nullptr, "GetStateChangeEventWithHandover"},
-            FunctionInfo{153, nullptr, "GetDropEventWithHandover"},
-            FunctionInfo{154, nullptr, "CreateTokenAsync"}
-        );
+        RegisterHandlers(functions);
     }
 
 private:

src/core/hle/service/ns/factory_reset_interface.cpp

@@ -1,6 +1,3 @@
-// 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
 
@@ -12,13 +9,13 @@ IFactoryResetInterface::IFactoryResetInterface(Core::System& system_)
     : ServiceFramework{system_, "IFactoryResetInterface"} {
     // clang-format off
         static const FunctionInfo functions[] = {
-            FunctionInfo{100, nullptr, "ResetToFactorySettings"},
-            FunctionInfo{101, nullptr, "ResetToFactorySettingsWithoutUserSaveData"},
-            FunctionInfo{102, nullptr, "ResetToFactorySettingsForRefurbishment"},
-            FunctionInfo{103, nullptr, "ResetToFactorySettingsWithPlatformRegion"},
-            FunctionInfo{104, nullptr, "ResetToFactorySettingsWithPlatformRegionAuthentication"},
-            FunctionInfo{105, nullptr, "RequestResetToFactorySettingsSecurely"},
-            FunctionInfo{106, nullptr, "RequestResetToFactorySettingsWithPlatformRegionAuthenticationSecurely"}
+            {100, nullptr, "ResetToFactorySettings"},
+            {101, nullptr, "ResetToFactorySettingsWithoutUserSaveData"},
+            {102, nullptr, "ResetToFactorySettingsForRefurbishment"},
+            {103, nullptr, "ResetToFactorySettingsWithPlatformRegion"},
+            {104, nullptr, "ResetToFactorySettingsWithPlatformRegionAuthentication"},
+            {105, nullptr, "RequestResetToFactorySettingsSecurely"},
+            {106, nullptr, "RequestResetToFactorySettingsWithPlatformRegionAuthenticationSecurely"},
         };
     // clang-format on
 

src/core/hle/service/ns/ns.cpp

@@ -19,24 +19,25 @@ namespace Service::NS {
 
 class INotifyService final : public ServiceFramework<INotifyService> {
 public:
-    explicit INotifyService(Core::System& system_) : ServiceFramework{system_, "pdm:ntfy"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "NotifyAppletEvent" },
-            FunctionInfo{2, nullptr, "NotifyOperationModeChangeEvent" },
-            FunctionInfo{3, nullptr, "NotifyPowerStateChangeEvent" },
-            FunctionInfo{4, nullptr, "NotifyClearAllEvent" },
-            FunctionInfo{5, nullptr, "NotifyEventForDebug" },
-            FunctionInfo{6, nullptr, "SuspendUserAccountEventService" },
-            FunctionInfo{7, nullptr, "ResumeUserAccountEventService" },
-            FunctionInfo{8, nullptr, "NotifyLibraryAppletEvent" },
-            FunctionInfo{9, nullptr, "Cmd9" },
-            FunctionInfo{20, nullptr, "Cmd20" },
-            FunctionInfo{30, nullptr, "Cmd30" },
-            FunctionInfo{100, nullptr, "Cmd100" },
-            FunctionInfo{101, nullptr, "Cmd101" }
-        );
+    explicit INotifyService(Core::System& system_) : ServiceFramework{system_, "pdm:ntfy"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            { 0, nullptr, "NotifyAppletEvent" },
+            { 2, nullptr, "NotifyOperationModeChangeEvent" },
+            { 3, nullptr, "NotifyPowerStateChangeEvent" },
+            { 4, nullptr, "NotifyClearAllEvent" },
+            { 5, nullptr, "NotifyEventForDebug" },
+            { 6, nullptr, "SuspendUserAccountEventService" },
+            { 7, nullptr, "ResumeUserAccountEventService" },
+            { 8, nullptr, "NotifyLibraryAppletEvent" },
+            { 9, nullptr, "Cmd9" },
+            { 20, nullptr, "Cmd20" },
+            { 30, nullptr, "Cmd30" },
+            { 100, nullptr, "Cmd100" },
+            { 101, nullptr, "Cmd101" },
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 
@@ -44,17 +45,18 @@ class IVulnerabilityManagerInterface final
     : public ServiceFramework<IVulnerabilityManagerInterface> {
 public:
     explicit IVulnerabilityManagerInterface(Core::System& system_)
-        : ServiceFramework{system_, "ns:vm"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{1200, D<&IVulnerabilityManagerInterface::NeedsUpdateVulnerability>, "NeedsUpdateVulnerability"},
-            FunctionInfo{1201, nullptr, "UpdateSafeSystemVersionForDebug"},
-            FunctionInfo{1202, nullptr, "GetSafeSystemVersion"},
-            FunctionInfo{3100, D<&IVulnerabilityManagerInterface::GetSafeSystemVersionCheckInfo>, "GetSafeSystemVersionCheckInfo"},
-            FunctionInfo{3101, nullptr, "RequestUpdateSafeSystemVersionCheckInfo"},
-            FunctionInfo{3102, D<&IVulnerabilityManagerInterface::ResetSafeSystemVersionCheckInfo>, "ResetSafeSystemVersionCheckInfo"}
-        );
+        : ServiceFramework{system_, "ns:vm"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {1200, D<&IVulnerabilityManagerInterface::NeedsUpdateVulnerability>, "NeedsUpdateVulnerability"},
+            {1201, nullptr, "UpdateSafeSystemVersionForDebug"},
+            {1202, nullptr, "GetSafeSystemVersion"},
+            {3100, D<&IVulnerabilityManagerInterface::GetSafeSystemVersionCheckInfo>, "GetSafeSystemVersionCheckInfo"},
+            {3101, nullptr, "RequestUpdateSafeSystemVersionCheckInfo"},
+            {3102, D<&IVulnerabilityManagerInterface::ResetSafeSystemVersionCheckInfo>, "ResetSafeSystemVersionCheckInfo"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
     ~IVulnerabilityManagerInterface() override = default;
 

src/core/hle/service/ns/query_service.cpp

@@ -38,12 +38,12 @@ IQueryService::IQueryService(Core::System& system_) : ServiceFramework{system_,
         {17, D<&IQueryService::QueryLastPlayTime>, "QueryLastPlayTime"},
         {18, D<&IQueryService::QueryApplicationPlayStatisticsForSystem>, "QueryApplicationPlayStatisticsForSystem"},
         {19, D<&IQueryService::QueryApplicationPlayStatisticsByUserAccountIdForSystem>, "QueryApplicationPlayStatisticsByUserAccountIdForSystem"},
-        FunctionInfo{30, nullptr, "Cmd30" },
-        FunctionInfo{31, nullptr, "Cmd31" },
-        FunctionInfo{100, nullptr, "Cmd100" },
-        FunctionInfo{110, nullptr, "Cmd110" },
-        FunctionInfo{118, nullptr, "Cmd118" },
-        FunctionInfo{119, nullptr, "Cmd119" },
+        { 30, nullptr, "Cmd30" },
+        { 31, nullptr, "Cmd31" },
+        { 100, nullptr, "Cmd100" },
+        { 110, nullptr, "Cmd110" },
+        { 118, nullptr, "Cmd118" },
+        { 119, nullptr, "Cmd119" },
     };
     // clang-format on
 

src/core/hle/service/ns/read_only_application_control_data_interface.cpp

@@ -85,10 +85,10 @@ public:
         , data_size{size}
     {
         static const FunctionInfo functions[] = {
-            FunctionInfo{0, D<&IAsyncValue::GetSize>, "GetSize"},
-            FunctionInfo{1, D<&IAsyncValue::Get>, "Get"},
-            FunctionInfo{2, D<&IAsyncValue::Cancel>, "Cancel"},
-            FunctionInfo{3, D<&IAsyncValue::GetErrorContext>, "GetErrorContext"}
+            {0, D<&IAsyncValue::GetSize>, "GetSize"},
+            {1, D<&IAsyncValue::Get>, "Get"},
+            {2, D<&IAsyncValue::Cancel>, "Cancel"},
+            {3, D<&IAsyncValue::GetErrorContext>, "GetErrorContext"},
         };
         RegisterHandlers(functions);
         completion_event = service_context.CreateEvent("IAsyncValue:Completion");

src/core/hle/service/nvdrv/nvdrv.cpp

@@ -52,14 +52,14 @@ public:
         : ServiceFramework{system_, "nvgem:c"}
     {
         static const FunctionInfo functions[] = {
-            FunctionInfo{0, nullptr, "Initialize"},
-            FunctionInfo{1, nullptr, "GetEventHandle"},
-            FunctionInfo{2, nullptr, "ControlNotification"},
-            FunctionInfo{3, nullptr, "SetNotificationPerm"},
-            FunctionInfo{4, nullptr, "SetCoreDumpPerm"},
-            FunctionInfo{5, nullptr, "GetAruid"},
-            FunctionInfo{6, nullptr, "Reset"},
-            FunctionInfo{7, nullptr, "GetAruid2"}
+            {0, nullptr, "Initialize"},
+            {1, nullptr, "GetEventHandle"},
+            {2, nullptr, "ControlNotification"},
+            {3, nullptr, "SetNotificationPerm"},
+            {4, nullptr, "SetCoreDumpPerm"},
+            {5, nullptr, "GetAruid"},
+            {6, nullptr, "Reset"},
+            {7, nullptr, "GetAruid2"},
         };
         RegisterHandlers(functions);
     }
@@ -71,11 +71,11 @@ public:
         : ServiceFramework{system_, "nvgem:cd"}
     {
         static const FunctionInfo functions[] = {
-            FunctionInfo{0, nullptr, "Initialize"},
-            FunctionInfo{1, nullptr, "GetAruid"},
-            FunctionInfo{2, nullptr, "ReadNextBlock"},
-            FunctionInfo{3, nullptr, "GetNextBlockSize"},
-            FunctionInfo{4, nullptr, "ReadNextBlock2"}
+            {0, nullptr, "Initialize"},
+            {1, nullptr, "GetAruid"},
+            {2, nullptr, "ReadNextBlock"},
+            {3, nullptr, "GetNextBlockSize"},
+            {4, nullptr, "ReadNextBlock2"},
         };
         RegisterHandlers(functions);
     }
@@ -87,15 +87,15 @@ public:
         : ServiceFramework{system_, "nvdbg:d"}
     {
         static const FunctionInfo functions[] = {
-            FunctionInfo{0, nullptr, "Open"},
-            FunctionInfo{1, nullptr, "Ioctl"},
-            FunctionInfo{2, nullptr, "Close"},
-            FunctionInfo{4, nullptr, "QueryEvent"},
-            FunctionInfo{9, nullptr, "DumpStatus"},
-            FunctionInfo{10, nullptr, "InitializeDevtools"},
-            FunctionInfo{11, nullptr, "Ioctl2"},
-            FunctionInfo{12, nullptr, "Ioctl3"},
-            FunctionInfo{13, nullptr, "SetConfiguration"}
+            {0, nullptr, "Open"},
+            {1, nullptr, "Ioctl"},
+            {2, nullptr, "Close"},
+            {4, nullptr, "QueryEvent"},
+            {9, nullptr, "DumpStatus"},
+            {10, nullptr, "InitializeDevtools"},
+            {11, nullptr, "Ioctl2"},
+            {12, nullptr, "Ioctl3"},
+            {13, nullptr, "SetConfiguration"},
         };
         RegisterHandlers(functions);
     }

src/core/hle/service/olsc/olsc.cpp

@@ -18,7 +18,7 @@ public:
         : ServiceFramework{system_, "spbg:sp"}
     {
         static const FunctionInfo functions[] = {
-            FunctionInfo{100, nullptr, "OpenBgAgentController" },
+            { 100, nullptr, "OpenBgAgentController" },
         };
         RegisterHandlers(functions);
     }

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

@@ -1,6 +1,3 @@
-// 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
 
@@ -13,28 +10,28 @@ IOlscServiceForApplication::IOlscServiceForApplication(Core::System& system_)
     : ServiceFramework{system_, "olsc:u"} {
     // clang-format off
         static const FunctionInfo functions[] = {
-            FunctionInfo{0, D<&IOlscServiceForApplication::Initialize>, "Initialize"},
-            FunctionInfo{10, nullptr, "VerifySaveDataBackupLicenseAsync"},
-            FunctionInfo{13, D<&IOlscServiceForApplication::GetSaveDataBackupSetting>, "GetSaveDataBackupSetting"},
-            FunctionInfo{14, D<&IOlscServiceForApplication::SetSaveDataBackupSettingEnabled>, "SetSaveDataBackupSettingEnabled"},
-            FunctionInfo{15, nullptr, "SetCustomData"},
-            FunctionInfo{16, nullptr, "DeleteSaveDataBackupSetting"},
-            FunctionInfo{18, nullptr, "GetSaveDataBackupInfoCache"},
-            FunctionInfo{19, nullptr, "UpdateSaveDataBackupInfoCacheAsync"},
-            FunctionInfo{22, nullptr, "DeleteSaveDataBackupAsync"},
-            FunctionInfo{25, nullptr, "ListDownloadableSaveDataBackupInfoAsync"},
-            FunctionInfo{26, nullptr, "DownloadSaveDataBackupAsync"},
-            FunctionInfo{27, nullptr, "UploadSaveDataBackupAsync"},
-            FunctionInfo{9010, nullptr, "VerifySaveDataBackupLicenseAsyncForDebug"},
-            FunctionInfo{9013, nullptr, "GetSaveDataBackupSettingForDebug"},
-            FunctionInfo{9014, nullptr, "SetSaveDataBackupSettingEnabledForDebug"},
-            FunctionInfo{9015, nullptr, "SetCustomDataForDebug"},
-            FunctionInfo{9016, nullptr, "DeleteSaveDataBackupSettingForDebug"},
-            FunctionInfo{9018, nullptr, "GetSaveDataBackupInfoCacheForDebug"},
-            FunctionInfo{9019, nullptr, "UpdateSaveDataBackupInfoCacheAsyncForDebug"},
-            FunctionInfo{9022, nullptr, "DeleteSaveDataBackupAsyncForDebug"},
-            FunctionInfo{9025, nullptr, "ListDownloadableSaveDataBackupInfoAsyncForDebug"},
-            FunctionInfo{9026, nullptr, "DownloadSaveDataBackupAsyncForDebug"}
+            {0, D<&IOlscServiceForApplication::Initialize>, "Initialize"},
+            {10, nullptr, "VerifySaveDataBackupLicenseAsync"},
+            {13, D<&IOlscServiceForApplication::GetSaveDataBackupSetting>, "GetSaveDataBackupSetting"},
+            {14, D<&IOlscServiceForApplication::SetSaveDataBackupSettingEnabled>, "SetSaveDataBackupSettingEnabled"},
+            {15, nullptr, "SetCustomData"},
+            {16, nullptr, "DeleteSaveDataBackupSetting"},
+            {18, nullptr, "GetSaveDataBackupInfoCache"},
+            {19, nullptr, "UpdateSaveDataBackupInfoCacheAsync"},
+            {22, nullptr, "DeleteSaveDataBackupAsync"},
+            {25, nullptr, "ListDownloadableSaveDataBackupInfoAsync"},
+            {26, nullptr, "DownloadSaveDataBackupAsync"},
+            {27, nullptr, "UploadSaveDataBackupAsync"},
+            {9010, nullptr, "VerifySaveDataBackupLicenseAsyncForDebug"},
+            {9013, nullptr, "GetSaveDataBackupSettingForDebug"},
+            {9014, nullptr, "SetSaveDataBackupSettingEnabledForDebug"},
+            {9015, nullptr, "SetCustomDataForDebug"},
+            {9016, nullptr, "DeleteSaveDataBackupSettingForDebug"},
+            {9018, nullptr, "GetSaveDataBackupInfoCacheForDebug"},
+            {9019, nullptr, "UpdateSaveDataBackupInfoCacheAsyncForDebug"},
+            {9022, nullptr, "DeleteSaveDataBackupAsyncForDebug"},
+            {9025, nullptr, "ListDownloadableSaveDataBackupInfoAsyncForDebug"},
+            {9026, nullptr, "DownloadSaveDataBackupAsyncForDebug"},
         };
     // clang-format on
 

src/core/hle/service/pcie/pcie.cpp

@@ -15,59 +15,64 @@ namespace Service::PCIe {
 
 class ISession final : public ServiceFramework<ISession> {
 public:
-    explicit ISession(Core::System& system_) : ServiceFramework{system_, "ISession"} {}
+    explicit ISession(Core::System& system_) : ServiceFramework{system_, "ISession"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "QueryFunctions"},
+            {1, nullptr, "AcquireFunction"},
+            {2, nullptr, "ReleaseFunction"},
+            {3, nullptr, "GetFunctionState"},
+            {4, nullptr, "GetBarProfile"},
+            {5, nullptr, "ReadConfig"},
+            {6, nullptr, "WriteConfig"},
+            {7, nullptr, "ReadBarRegion"},
+            {8, nullptr, "WriteBarRegion"},
+            {9, nullptr, "FindCapability"},
+            {10, nullptr, "FindExtendedCapability"},
+            {11, nullptr, "MapDma"},
+            {12, nullptr, "UnmapDma"},
+            {13, nullptr, "UnmapDmaBusAddress"},
+            {14, nullptr, "GetDmaBusAddress"},
+            {15, nullptr, "GetDmaBusAddressRange"},
+            {16, nullptr, "SetDmaEnable"},
+            {17, nullptr, "AcquireIrq"},
+            {18, nullptr, "ReleaseIrq"},
+            {19, nullptr, "SetIrqEnable"},
+            {20, nullptr, "GetIrqEvent"},
+            {21, nullptr, "SetAspmEnable"},
+            {22, nullptr, "SetResetUponResumeEnable"},
+            {23, nullptr, "ResetFunction"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "QueryFunctions"},
-            FunctionInfo{1, nullptr, "AcquireFunction"},
-            FunctionInfo{2, nullptr, "ReleaseFunction"},
-            FunctionInfo{3, nullptr, "GetFunctionState"},
-            FunctionInfo{4, nullptr, "GetBarProfile"},
-            FunctionInfo{5, nullptr, "ReadConfig"},
-            FunctionInfo{6, nullptr, "WriteConfig"},
-            FunctionInfo{7, nullptr, "ReadBarRegion"},
-            FunctionInfo{8, nullptr, "WriteBarRegion"},
-            FunctionInfo{9, nullptr, "FindCapability"},
-            FunctionInfo{10, nullptr, "FindExtendedCapability"},
-            FunctionInfo{11, nullptr, "MapDma"},
-            FunctionInfo{12, nullptr, "UnmapDma"},
-            FunctionInfo{13, nullptr, "UnmapDmaBusAddress"},
-            FunctionInfo{14, nullptr, "GetDmaBusAddress"},
-            FunctionInfo{15, nullptr, "GetDmaBusAddressRange"},
-            FunctionInfo{16, nullptr, "SetDmaEnable"},
-            FunctionInfo{17, nullptr, "AcquireIrq"},
-            FunctionInfo{18, nullptr, "ReleaseIrq"},
-            FunctionInfo{19, nullptr, "SetIrqEnable"},
-            FunctionInfo{20, nullptr, "GetIrqEvent"},
-            FunctionInfo{21, nullptr, "SetAspmEnable"},
-            FunctionInfo{22, nullptr, "SetResetUponResumeEnable"},
-            FunctionInfo{23, nullptr, "ResetFunction"}
-        );
+        RegisterHandlers(functions);
     }
 };
 
 class PCIE final : public ServiceFramework<PCIE> {
 public:
-    explicit PCIE(Core::System& system_) : ServiceFramework{system_, "pcie"} {}
+    explicit PCIE(Core::System& system_) : ServiceFramework{system_, "pcie"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "RegisterClassDriver"},
+            {1, nullptr, "QueryFunctionsUnregistered"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "RegisterClassDriver"},
-            FunctionInfo{1, nullptr, "QueryFunctionsUnregistered"}
-        );
+        RegisterHandlers(functions);
     }
 };
 
 class PCIE_LOG final : public ServiceFramework<PCIE_LOG> {
 public:
-    explicit PCIE_LOG(Core::System& system_) : ServiceFramework{system_, "pcie:log"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "GetLoggedState"},
-            FunctionInfo{1, nullptr, "GetLoggedStateEvent"}
-        );
+    explicit PCIE_LOG(Core::System& system_) : ServiceFramework{system_, "pcie:log"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "GetLoggedState"},
+            {1, nullptr, "GetLoggedStateEvent"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 

src/core/hle/service/pcv/pcv.cpp

@@ -15,86 +15,91 @@ namespace Service::PCV {
 
 class PCV final : public ServiceFramework<PCV> {
 public:
-    explicit PCV(Core::System& system_) : ServiceFramework{system_, "pcv"} {}
+    explicit PCV(Core::System& system_) : ServiceFramework{system_, "pcv"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "SetPowerEnabled"},
+            {1, nullptr, "SetClockEnabled"},
+            {2, nullptr, "SetClockRate"},
+            {3, nullptr, "GetClockRate"},
+            {4, nullptr, "GetState"},
+            {5, nullptr, "GetPossibleClockRates"},
+            {6, nullptr, "SetMinVClockRate"},
+            {7, nullptr, "SetReset"},
+            {8, nullptr, "SetVoltageEnabled"},
+            {9, nullptr, "GetVoltageEnabled"},
+            {10, nullptr, "GetVoltageRange"},
+            {11, nullptr, "SetVoltageValue"},
+            {12, nullptr, "GetVoltageValue"},
+            {13, nullptr, "GetTemperatureThresholds"},
+            {14, nullptr, "SetTemperature"},
+            {15, nullptr, "Initialize"},
+            {16, nullptr, "IsInitialized"},
+            {17, nullptr, "Finalize"},
+            {18, nullptr, "PowerOn"},
+            {19, nullptr, "PowerOff"},
+            {20, nullptr, "ChangeVoltage"},
+            {21, nullptr, "GetPowerClockInfoEvent"},
+            {22, nullptr, "GetOscillatorClock"},
+            {23, nullptr, "GetDvfsTable"},
+            {24, nullptr, "GetModuleStateTable"},
+            {25, nullptr, "GetPowerDomainStateTable"},
+            {26, nullptr, "GetFuseInfo"},
+            {27, nullptr, "GetDramId"},
+            {28, nullptr, "IsPoweredOn"},
+            {29, nullptr, "GetVoltage"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "SetPowerEnabled"},
-            FunctionInfo{1, nullptr, "SetClockEnabled"},
-            FunctionInfo{2, nullptr, "SetClockRate"},
-            FunctionInfo{3, nullptr, "GetClockRate"},
-            FunctionInfo{4, nullptr, "GetState"},
-            FunctionInfo{5, nullptr, "GetPossibleClockRates"},
-            FunctionInfo{6, nullptr, "SetMinVClockRate"},
-            FunctionInfo{7, nullptr, "SetReset"},
-            FunctionInfo{8, nullptr, "SetVoltageEnabled"},
-            FunctionInfo{9, nullptr, "GetVoltageEnabled"},
-            FunctionInfo{10, nullptr, "GetVoltageRange"},
-            FunctionInfo{11, nullptr, "SetVoltageValue"},
-            FunctionInfo{12, nullptr, "GetVoltageValue"},
-            FunctionInfo{13, nullptr, "GetTemperatureThresholds"},
-            FunctionInfo{14, nullptr, "SetTemperature"},
-            FunctionInfo{15, nullptr, "Initialize"},
-            FunctionInfo{16, nullptr, "IsInitialized"},
-            FunctionInfo{17, nullptr, "Finalize"},
-            FunctionInfo{18, nullptr, "PowerOn"},
-            FunctionInfo{19, nullptr, "PowerOff"},
-            FunctionInfo{20, nullptr, "ChangeVoltage"},
-            FunctionInfo{21, nullptr, "GetPowerClockInfoEvent"},
-            FunctionInfo{22, nullptr, "GetOscillatorClock"},
-            FunctionInfo{23, nullptr, "GetDvfsTable"},
-            FunctionInfo{24, nullptr, "GetModuleStateTable"},
-            FunctionInfo{25, nullptr, "GetPowerDomainStateTable"},
-            FunctionInfo{26, nullptr, "GetFuseInfo"},
-            FunctionInfo{27, nullptr, "GetDramId"},
-            FunctionInfo{28, nullptr, "IsPoweredOn"},
-            FunctionInfo{29, nullptr, "GetVoltage"}
-        );
+        RegisterHandlers(functions);
     }
 };
 
 class PCV_ARB final : public ServiceFramework<PCV_ARB> {
 public:
-    explicit PCV_ARB(Core::System& system_) : ServiceFramework{system_, "pcv:arb"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "ReleaseControl"}
-        );
+    explicit PCV_ARB(Core::System& system_) : ServiceFramework{system_, "pcv:arb"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "ReleaseControl"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 
 class PCV_IMM final : public ServiceFramework<PCV_IMM> {
 public:
-    explicit PCV_IMM(Core::System& system_) : ServiceFramework{system_, "pcv:imm"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "SetClockRate"}
-        );
+    explicit PCV_IMM(Core::System& system_) : ServiceFramework{system_, "pcv:imm"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "SetClockRate"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 
 class IClkrstSession final : public ServiceFramework<IClkrstSession> {
 public:
     explicit IClkrstSession(Core::System& system_, DeviceCode device_code_)
-        : ServiceFramework{system_, "IClkrstSession"}, device_code(device_code_) {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "SetClockEnabled"},
-            FunctionInfo{1, nullptr, "SetClockDisabled"},
-            FunctionInfo{2, nullptr, "SetResetAsserted"},
-            FunctionInfo{3, nullptr, "SetResetDeasserted"},
-            FunctionInfo{4, nullptr, "SetPowerEnabled"},
-            FunctionInfo{5, nullptr, "SetPowerDisabled"},
-            FunctionInfo{6, nullptr, "GetState"},
-            FunctionInfo{7, &IClkrstSession::SetClockRate, "SetClockRate"},
-            FunctionInfo{8, &IClkrstSession::GetClockRate, "GetClockRate"},
-            FunctionInfo{9, nullptr, "SetMinVClockRate"},
-            FunctionInfo{10, nullptr, "GetPossibleClockRates"},
-            FunctionInfo{11, nullptr, "GetDvfsTable"}
-        );
+        : ServiceFramework{system_, "IClkrstSession"}, device_code(device_code_) {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "SetClockEnabled"},
+            {1, nullptr, "SetClockDisabled"},
+            {2, nullptr, "SetResetAsserted"},
+            {3, nullptr, "SetResetDeasserted"},
+            {4, nullptr, "SetPowerEnabled"},
+            {5, nullptr, "SetPowerDisabled"},
+            {6, nullptr, "GetState"},
+            {7, &IClkrstSession::SetClockRate, "SetClockRate"},
+            {8, &IClkrstSession::GetClockRate, "GetClockRate"},
+            {9, nullptr, "SetMinVClockRate"},
+            {10, nullptr, "GetPossibleClockRates"},
+            {11, nullptr, "GetDvfsTable"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 
 private:
@@ -121,17 +126,19 @@ private:
 
 class CLKRST final : public ServiceFramework<CLKRST> {
 public:
-    explicit CLKRST(Core::System& system_, const char* name) : ServiceFramework{system_, name} {}
+    explicit CLKRST(Core::System& system_, const char* name) : ServiceFramework{system_, name} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &CLKRST::OpenSession, "OpenSession"},
+            {1, nullptr, "GetTemperatureThresholds"},
+            {2, nullptr, "SetTemperature"},
+            {3, nullptr, "GetModuleStateTable"},
+            {4, nullptr, "GetModuleStateTableEvent"},
+            {5, nullptr, "GetModuleStateTableMaxCount"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, &CLKRST::OpenSession, "OpenSession"},
-            FunctionInfo{1, nullptr, "GetTemperatureThresholds"},
-            FunctionInfo{2, nullptr, "SetTemperature"},
-            FunctionInfo{3, nullptr, "GetModuleStateTable"},
-            FunctionInfo{4, nullptr, "GetModuleStateTableEvent"},
-            FunctionInfo{5, nullptr, "GetModuleStateTableMaxCount"}
-        );
+        RegisterHandlers(functions);
     }
 
 private:
@@ -150,12 +157,14 @@ private:
 
 class CLKRST_A final : public ServiceFramework<CLKRST_A> {
 public:
-    explicit CLKRST_A(Core::System& system_) : ServiceFramework{system_, "clkrst:a"} {}
+    explicit CLKRST_A(Core::System& system_) : ServiceFramework{system_, "clkrst:a"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "ReleaseControl"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "ReleaseControl"}
-        );
+        RegisterHandlers(functions);
     }
 };
 

src/core/hle/service/pm/pm.cpp

@@ -49,8 +49,8 @@ class BootMode final : public ServiceFramework<BootMode> {
 public:
     explicit BootMode(Core::System& system_) : ServiceFramework{system_, "pm:bm"} {
         static const FunctionInfo functions[] = {
-            FunctionInfo{0, &BootMode::GetBootMode, "GetBootMode"},
-            FunctionInfo{1, &BootMode::SetMaintenanceBoot, "SetMaintenanceBoot"}
+            {0, &BootMode::GetBootMode, "GetBootMode"},
+            {1, &BootMode::SetMaintenanceBoot, "SetMaintenanceBoot"},
         };
         RegisterHandlers(functions);
     }
@@ -78,20 +78,22 @@ private:
 
 class DebugMonitor final : public ServiceFramework<DebugMonitor> {
 public:
-    explicit DebugMonitor(Core::System& system_) : ServiceFramework{system_, "pm:dmnt"} {}
+    explicit DebugMonitor(Core::System& system_) : ServiceFramework{system_, "pm:dmnt"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "GetJitDebugProcessIdList"},
+            {1, nullptr, "StartProcess"},
+            {2, &DebugMonitor::GetProcessId, "GetProcessId"},
+            {3, nullptr, "HookToCreateProcess"},
+            {4, &DebugMonitor::GetApplicationProcessId, "GetApplicationProcessId"},
+            {5, nullptr, "HookToCreateApplicationProgress"},
+            {6, nullptr, "ClearHook"},
+            {65000, &DebugMonitor::AtmosphereGetProcessInfo, "AtmosphereGetProcessInfo"},
+            {65001, nullptr, "AtmosphereGetCurrentLimitInfo"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "GetJitDebugProcessIdList"},
-            FunctionInfo{1, nullptr, "StartProcess"},
-            FunctionInfo{2, &DebugMonitor::GetProcessId, "GetProcessId"},
-            FunctionInfo{3, nullptr, "HookToCreateProcess"},
-            FunctionInfo{4, &DebugMonitor::GetApplicationProcessId, "GetApplicationProcessId"},
-            FunctionInfo{5, nullptr, "HookToCreateApplicationProgress"},
-            FunctionInfo{6, nullptr, "ClearHook"},
-            FunctionInfo{65000, &DebugMonitor::AtmosphereGetProcessInfo, "AtmosphereGetProcessInfo"},
-            FunctionInfo{65001, nullptr, "AtmosphereGetCurrentLimitInfo"}
-        );
+        RegisterHandlers(functions);
     }
 
 private:
@@ -168,10 +170,10 @@ class Info final : public ServiceFramework<Info> {
 public:
     explicit Info(Core::System& system_) : ServiceFramework{system_, "pm:info"} {
         static const FunctionInfo functions[] = {
-            FunctionInfo{0, &Info::GetProgramId, "GetProgramId"},
-            FunctionInfo{65000, &Info::AtmosphereGetProcessId, "AtmosphereGetProcessId"},
-            FunctionInfo{65001, nullptr, "AtmosphereHasLaunchedProgram"},
-            FunctionInfo{65002, nullptr, "AtmosphereGetProcessInfo"}
+            {0, &Info::GetProgramId, "GetProgramId"},
+            {65000, &Info::AtmosphereGetProcessId, "AtmosphereGetProcessId"},
+            {65001, nullptr, "AtmosphereHasLaunchedProgram"},
+            {65002, nullptr, "AtmosphereGetProcessInfo"},
         };
         RegisterHandlers(functions);
     }
@@ -220,21 +222,23 @@ private:
 
 class Shell final : public ServiceFramework<Shell> {
 public:
-    explicit Shell(Core::System& system_) : ServiceFramework{system_, "pm:shell"} {}
+    explicit Shell(Core::System& system_) : ServiceFramework{system_, "pm:shell"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "LaunchProgram"},
+            {1, nullptr, "TerminateProcess"},
+            {2, nullptr, "TerminateProgram"},
+            {3, nullptr, "GetProcessEventHandle"},
+            {4, nullptr, "GetProcessEventInfo"},
+            {5, nullptr, "NotifyBootFinished"},
+            {6, &Shell::GetApplicationProcessIdForShell, "GetApplicationProcessIdForShell"},
+            {7, nullptr, "BoostSystemMemoryResourceLimit"},
+            {8, nullptr, "BoostApplicationThreadResourceLimit"},
+            {9, nullptr, "GetBootFinishedEventHandle"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "LaunchProgram"},
-            FunctionInfo{1, nullptr, "TerminateProcess"},
-            FunctionInfo{2, nullptr, "TerminateProgram"},
-            FunctionInfo{3, nullptr, "GetProcessEventHandle"},
-            FunctionInfo{4, nullptr, "GetProcessEventInfo"},
-            FunctionInfo{5, nullptr, "NotifyBootFinished"},
-            FunctionInfo{6, &Shell::GetApplicationProcessIdForShell, "GetApplicationProcessIdForShell"},
-            FunctionInfo{7, nullptr, "BoostSystemMemoryResourceLimit"},
-            FunctionInfo{8, nullptr, "BoostApplicationThreadResourceLimit"},
-            FunctionInfo{9, nullptr, "GetBootFinishedEventHandle"}
-        );
+        RegisterHandlers(functions);
     }
 
 private:

src/core/hle/service/prepo/prepo.cpp

@@ -21,43 +21,45 @@ namespace Service::PlayReport {
 
 class PlayReport final : public ServiceFramework<PlayReport> {
 public:
-    explicit PlayReport(const char* name, Core::System& system_) : ServiceFramework{system_, name} {}
+    explicit PlayReport(const char* name, Core::System& system_) : ServiceFramework{system_, name} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {10100, &PlayReport::SaveReport<Core::Reporter::PlayReportType::Old>, "SaveReportOld"},
+            {10101, &PlayReport::SaveReportWithUser<Core::Reporter::PlayReportType::Old>, "SaveReportWithUserOld"},
+            {10102, &PlayReport::SaveReport<Core::Reporter::PlayReportType::Old2>, "SaveReportOld2"},
+            {10103, &PlayReport::SaveReportWithUser<Core::Reporter::PlayReportType::Old2>, "SaveReportWithUserOld2"},
+            {10104, &PlayReport::SaveReport<Core::Reporter::PlayReportType::Old3>, "SaveReportOld3"},
+            {10105, &PlayReport::SaveReportWithUser<Core::Reporter::PlayReportType::Old3>, "SaveReportWithUserOld3"},
+            {10106, &PlayReport::SaveReport<Core::Reporter::PlayReportType::New>, "SaveReport"},
+            {10107, &PlayReport::SaveReportWithUser<Core::Reporter::PlayReportType::New>, "SaveReportWithUser"},
+            {10200, &PlayReport::RequestImmediateTransmission, "RequestImmediateTransmission"},
+            {10300, &PlayReport::GetTransmissionStatus, "GetTransmissionStatus"},
+            {10400, &PlayReport::GetSystemSessionId, "GetSystemSessionId"},
+            {20100, &PlayReport::SaveSystemReportOld, "SaveSystemReport"},
+            {20101, &PlayReport::SaveSystemReportWithUserOld, "SaveSystemReportWithUser"},
+            {20102, &PlayReport::SaveSystemReport, "SaveSystemReport"},
+            {20103, &PlayReport::SaveSystemReportWithUser, "SaveSystemReportWithUser"},
+            {20200, nullptr, "SetOperationMode"},
+            {30100, nullptr, "ClearStorage"},
+            {30200, nullptr, "ClearStatistics"},
+            {30300, nullptr, "GetStorageUsage"},
+            {30400, nullptr, "GetStatistics"},
+            {30401, nullptr, "GetThroughputHistory"},
+            {30500, nullptr, "GetLastUploadError"},
+            {30600, nullptr, "GetApplicationUploadSummary"},
+            {40100, nullptr, "IsUserAgreementCheckEnabled"},
+            {40101, nullptr, "SetUserAgreementCheckEnabled"},
+            {50100, nullptr, "ReadAllApplicationReportFiles"},
+            {90100, nullptr, "ReadAllReportFiles"},
+            {90101, nullptr, "Unknown90101"},
+            {90102, nullptr, "Unknown90102"},
+            {90200, nullptr, "GetStatistics"},
+            {90201, nullptr, "GetThroughputHistory"},
+            {90300, nullptr, "GetLastUploadError"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{10100, &PlayReport::SaveReport<Core::Reporter::PlayReportType::Old>, "SaveReportOld"},
-            FunctionInfo{10101, &PlayReport::SaveReportWithUser<Core::Reporter::PlayReportType::Old>, "SaveReportWithUserOld"},
-            FunctionInfo{10102, &PlayReport::SaveReport<Core::Reporter::PlayReportType::Old2>, "SaveReportOld2"},
-            FunctionInfo{10103, &PlayReport::SaveReportWithUser<Core::Reporter::PlayReportType::Old2>, "SaveReportWithUserOld2"},
-            FunctionInfo{10104, &PlayReport::SaveReport<Core::Reporter::PlayReportType::Old3>, "SaveReportOld3"},
-            FunctionInfo{10105, &PlayReport::SaveReportWithUser<Core::Reporter::PlayReportType::Old3>, "SaveReportWithUserOld3"},
-            FunctionInfo{10106, &PlayReport::SaveReport<Core::Reporter::PlayReportType::New>, "SaveReport"},
-            FunctionInfo{10107, &PlayReport::SaveReportWithUser<Core::Reporter::PlayReportType::New>, "SaveReportWithUser"},
-            FunctionInfo{10200, &PlayReport::RequestImmediateTransmission, "RequestImmediateTransmission"},
-            FunctionInfo{10300, &PlayReport::GetTransmissionStatus, "GetTransmissionStatus"},
-            FunctionInfo{10400, &PlayReport::GetSystemSessionId, "GetSystemSessionId"},
-            FunctionInfo{20100, &PlayReport::SaveSystemReportOld, "SaveSystemReport"},
-            FunctionInfo{20101, &PlayReport::SaveSystemReportWithUserOld, "SaveSystemReportWithUser"},
-            FunctionInfo{20102, &PlayReport::SaveSystemReport, "SaveSystemReport"},
-            FunctionInfo{20103, &PlayReport::SaveSystemReportWithUser, "SaveSystemReportWithUser"},
-            FunctionInfo{20200, nullptr, "SetOperationMode"},
-            FunctionInfo{30100, nullptr, "ClearStorage"},
-            FunctionInfo{30200, nullptr, "ClearStatistics"},
-            FunctionInfo{30300, nullptr, "GetStorageUsage"},
-            FunctionInfo{30400, nullptr, "GetStatistics"},
-            FunctionInfo{30401, nullptr, "GetThroughputHistory"},
-            FunctionInfo{30500, nullptr, "GetLastUploadError"},
-            FunctionInfo{30600, nullptr, "GetApplicationUploadSummary"},
-            FunctionInfo{40100, nullptr, "IsUserAgreementCheckEnabled"},
-            FunctionInfo{40101, nullptr, "SetUserAgreementCheckEnabled"},
-            FunctionInfo{50100, nullptr, "ReadAllApplicationReportFiles"},
-            FunctionInfo{90100, nullptr, "ReadAllReportFiles"},
-            FunctionInfo{90101, nullptr, "Unknown90101"},
-            FunctionInfo{90102, nullptr, "Unknown90102"},
-            FunctionInfo{90200, nullptr, "GetStatistics"},
-            FunctionInfo{90201, nullptr, "GetThroughputHistory"},
-            FunctionInfo{90300, nullptr, "GetLastUploadError"}
-        );
+        RegisterHandlers(functions);
     }
 
 private:

src/core/hle/service/psc/ovln/receiver.cpp

@@ -13,11 +13,11 @@ IReceiver::IReceiver(Core::System& system_)
     : ServiceFramework{system_, "IReceiver"}, service_context{system_, "IReceiver"} {
     // clang-format off
         static const FunctionInfo functions[] = {
-            FunctionInfo{0, D<&IReceiver::AddSource>, "AddSource"},
-            FunctionInfo{1, D<&IReceiver::RemoveSource>, "RemoveSource"},
-            FunctionInfo{2, D<&IReceiver::GetReceiveEventHandle>, "GetReceiveEventHandle"},
-            FunctionInfo{3, D<&IReceiver::Receive>, "Receive"},
-            FunctionInfo{4, D<&IReceiver::ReceiveWithTick>, "ReceiveWithTick"}
+            {0, D<&IReceiver::AddSource>, "AddSource"},
+            {1, D<&IReceiver::RemoveSource>, "RemoveSource"},
+            {2, D<&IReceiver::GetReceiveEventHandle>, "GetReceiveEventHandle"},
+            {3, D<&IReceiver::Receive>, "Receive"},
+            {4, D<&IReceiver::ReceiveWithTick>, "ReceiveWithTick"},
         };
     // clang-format on
 

src/core/hle/service/psc/pm_module.cpp

@@ -1,6 +1,3 @@
-// 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
 
@@ -11,11 +8,11 @@ namespace Service::PSC {
 IPmModule::IPmModule(Core::System& system_) : ServiceFramework{system_, "IPmModule"} {
     // clang-format off
         static const FunctionInfo functions[] = {
-            FunctionInfo{0, nullptr, "Initialize"},
-            FunctionInfo{1, nullptr, "GetRequest"},
-            FunctionInfo{2, nullptr, "Acknowledge"},
-            FunctionInfo{3, nullptr, "Finalize"},
-            FunctionInfo{4, nullptr, "AcknowledgeEx"}
+            {0, nullptr, "Initialize"},
+            {1, nullptr, "GetRequest"},
+            {2, nullptr, "Acknowledge"},
+            {3, nullptr, "Finalize"},
+            {4, nullptr, "AcknowledgeEx"},
         };
     // clang-format on
 

src/core/hle/service/psc/psc.cpp

@@ -19,81 +19,86 @@ namespace Service::PSC {
 
 class PSC_L final : public ServiceFramework<PSC_L> {
 public:
-    explicit PSC_L(Core::System& system_) : ServiceFramework{system_, "psc:l"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "Initialize_3"},
-            FunctionInfo{1, nullptr, "Lock"},
-            FunctionInfo{2, nullptr, "Unlock"},
-            FunctionInfo{3, nullptr, "IsLocked"},
-            FunctionInfo{4, nullptr, "GetRelatedState"}
-        );
+    explicit PSC_L(Core::System& system_) : ServiceFramework{system_, "psc:l"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "Initialize_3"},
+            {1, nullptr, "Lock"},
+            {2, nullptr, "Unlock"},
+            {3, nullptr, "IsLocked"},
+            {4, nullptr, "GetRelatedState"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 
 class INS_R final : public ServiceFramework<INS_R> {
 public:
-    explicit INS_R(Core::System& system_) : ServiceFramework{system_, "ins:r"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "GetInputSourceState"},
-            FunctionInfo{1, nullptr, "GetTriggerTargetEvent"}
-        );
+    explicit INS_R(Core::System& system_) : ServiceFramework{system_, "ins:r"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "GetInputSourceState"},
+            {1, nullptr, "GetTriggerTargetEvent"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 
 class INS_S final : public ServiceFramework<INS_S> {
 public:
-    explicit INS_S(Core::System& system_) : ServiceFramework{system_, "ins:s"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "GetNotifyEvent"}
-        );
+    explicit INS_S(Core::System& system_) : ServiceFramework{system_, "ins:s"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "GetNotifyEvent"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 
 class HSHL_SYS final : public ServiceFramework<HSHL_SYS> {
 public:
-    explicit HSHL_SYS(Core::System& system_) : ServiceFramework{system_, "hshl:sys"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "GetBatteryPercentage"},
-            FunctionInfo{1, nullptr, "GetChargerType"},
-            FunctionInfo{2, nullptr, "OpenChargeSession"},
-            FunctionInfo{3, nullptr, "GetRawBatteryPercentage"},
-            FunctionInfo{4, nullptr, "GetBatteryVoltageLevel"},
-            FunctionInfo{5, nullptr, "OpenThermalSession"},
-            FunctionInfo{6, nullptr, "GetAbnormalTemperatureSet"},
-            FunctionInfo{7, nullptr, "OpenClockSession"},
-            FunctionInfo{8, nullptr, "GetClockRate"},
-            FunctionInfo{9, nullptr, "OpenBridgeSession"},
-            FunctionInfo{10, nullptr, "GetBridgePowerSupply"},
-            FunctionInfo{11, nullptr, "OpenVsysVoltageSession"},
-            FunctionInfo{12, nullptr, "GetIsBatteryEnoughForFullAwake"},
-            FunctionInfo{13, nullptr, "GetIsCharging"},
-            FunctionInfo{14, nullptr, "Cmd14"},
-            FunctionInfo{15, nullptr, "Cmd15"}
-        );
+    explicit HSHL_SYS(Core::System& system_) : ServiceFramework{system_, "hshl:sys"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "GetBatteryPercentage"},
+            {1, nullptr, "GetChargerType"},
+            {2, nullptr, "OpenChargeSession"},
+            {3, nullptr, "GetRawBatteryPercentage"},
+            {4, nullptr, "GetBatteryVoltageLevel"},
+            {5, nullptr, "OpenThermalSession"},
+            {6, nullptr, "GetAbnormalTemperatureSet"},
+            {7, nullptr, "OpenClockSession"},
+            {8, nullptr, "GetClockRate"},
+            {9, nullptr, "OpenBridgeSession"},
+            {10, nullptr, "GetBridgePowerSupply"},
+            {11, nullptr, "OpenVsysVoltageSession"},
+            {12, nullptr, "GetIsBatteryEnoughForFullAwake"},
+            {13, nullptr, "GetIsCharging"},
+            {14, nullptr, "Cmd14"},
+            {15, nullptr, "Cmd15"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 
 class HSHL_SET final : public ServiceFramework<HSHL_SET> {
 public:
-    explicit HSHL_SET(Core::System& system_) : ServiceFramework{system_, "hshl:set"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "OpenChargeSession_2"},
-            FunctionInfo{1, nullptr, "OpenThermalSession_2"},
-            FunctionInfo{2, nullptr, "SetClockRate"},
-            FunctionInfo{3, nullptr, "SetBridgePowerSupply"},
-            FunctionInfo{4, nullptr, "Cmd4"},
-            FunctionInfo{5, nullptr, "Cmd5"}
-        );
+    explicit HSHL_SET(Core::System& system_) : ServiceFramework{system_, "hshl:set"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "OpenChargeSession_2"},
+            {1, nullptr, "OpenThermalSession_2"},
+            {2, nullptr, "SetClockRate"},
+            {3, nullptr, "SetBridgePowerSupply"},
+            {4, nullptr, "Cmd4"},
+            {5, nullptr, "Cmd5"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 

src/core/hle/service/psc/time/power_state_service.cpp

@@ -16,8 +16,8 @@ IPowerStateRequestHandler::IPowerStateRequestHandler(
 {
     // clang-format off
         static const FunctionInfo functions[] = {
-            FunctionInfo{0, D<&IPowerStateRequestHandler::GetPowerStateRequestEventReadableHandle>, "GetPowerStateRequestEventReadableHandle"},
-            FunctionInfo{1, D<&IPowerStateRequestHandler::GetAndClearPowerStateRequest>, "GetAndClearPowerStateRequest"}
+            {0, D<&IPowerStateRequestHandler::GetPowerStateRequestEventReadableHandle>, "GetPowerStateRequestEventReadableHandle"},
+            {1, D<&IPowerStateRequestHandler::GetAndClearPowerStateRequest>, "GetAndClearPowerStateRequest"},
         };
     // clang-format on
 

src/core/hle/service/psc/time/static.cpp

@@ -44,25 +44,25 @@ StaticService::StaticService(Core::System& system_, StaticServiceSetupInfo setup
                                                                         m_time->m_shared_memory} {
     // clang-format off
         static const FunctionInfo functions[] = {
-            FunctionInfo{0,   D<&StaticService::GetStandardUserSystemClock>, "GetStandardUserSystemClock"},
-            FunctionInfo{1,   D<&StaticService::GetStandardNetworkSystemClock>, "GetStandardNetworkSystemClock"},
-            FunctionInfo{2,   D<&StaticService::GetStandardSteadyClock>, "GetStandardSteadyClock"},
-            FunctionInfo{3,   D<&StaticService::GetTimeZoneService>, "GetTimeZoneService"},
-            FunctionInfo{4,   D<&StaticService::GetStandardLocalSystemClock>, "GetStandardLocalSystemClock"},
-            FunctionInfo{5,   D<&StaticService::GetEphemeralNetworkSystemClock>, "GetEphemeralNetworkSystemClock"},
-            FunctionInfo{20,  D<&StaticService::GetSharedMemoryNativeHandle>, "GetSharedMemoryNativeHandle"},
-            FunctionInfo{50,  D<&StaticService::SetStandardSteadyClockInternalOffset>, "SetStandardSteadyClockInternalOffset"},
-            FunctionInfo{51,  D<&StaticService::GetStandardSteadyClockRtcValue>, "GetStandardSteadyClockRtcValue"},
-            FunctionInfo{100, D<&StaticService::IsStandardUserSystemClockAutomaticCorrectionEnabled>, "IsStandardUserSystemClockAutomaticCorrectionEnabled"},
-            FunctionInfo{101, D<&StaticService::SetStandardUserSystemClockAutomaticCorrectionEnabled>, "SetStandardUserSystemClockAutomaticCorrectionEnabled"},
-            FunctionInfo{102, D<&StaticService::GetStandardUserSystemClockInitialYear>, "GetStandardUserSystemClockInitialYear"},
-            FunctionInfo{200, D<&StaticService::IsStandardNetworkSystemClockAccuracySufficient>, "IsStandardNetworkSystemClockAccuracySufficient"},
-            FunctionInfo{201, D<&StaticService::GetStandardUserSystemClockAutomaticCorrectionUpdatedTime>, "GetStandardUserSystemClockAutomaticCorrectionUpdatedTime"},
-            FunctionInfo{300, D<&StaticService::CalculateMonotonicSystemClockBaseTimePoint>, "CalculateMonotonicSystemClockBaseTimePoint"},
-            FunctionInfo{400, D<&StaticService::GetClockSnapshot>, "GetClockSnapshot"},
-            FunctionInfo{401, D<&StaticService::GetClockSnapshotFromSystemClockContext>, "GetClockSnapshotFromSystemClockContext"},
-            FunctionInfo{500, D<&StaticService::CalculateStandardUserSystemClockDifferenceByUser>, "CalculateStandardUserSystemClockDifferenceByUser"},
-            FunctionInfo{501, D<&StaticService::CalculateSpanBetween>, "CalculateSpanBetween"}
+            {0,   D<&StaticService::GetStandardUserSystemClock>, "GetStandardUserSystemClock"},
+            {1,   D<&StaticService::GetStandardNetworkSystemClock>, "GetStandardNetworkSystemClock"},
+            {2,   D<&StaticService::GetStandardSteadyClock>, "GetStandardSteadyClock"},
+            {3,   D<&StaticService::GetTimeZoneService>, "GetTimeZoneService"},
+            {4,   D<&StaticService::GetStandardLocalSystemClock>, "GetStandardLocalSystemClock"},
+            {5,   D<&StaticService::GetEphemeralNetworkSystemClock>, "GetEphemeralNetworkSystemClock"},
+            {20,  D<&StaticService::GetSharedMemoryNativeHandle>, "GetSharedMemoryNativeHandle"},
+            {50,  D<&StaticService::SetStandardSteadyClockInternalOffset>, "SetStandardSteadyClockInternalOffset"},
+            {51,  D<&StaticService::GetStandardSteadyClockRtcValue>, "GetStandardSteadyClockRtcValue"},
+            {100, D<&StaticService::IsStandardUserSystemClockAutomaticCorrectionEnabled>, "IsStandardUserSystemClockAutomaticCorrectionEnabled"},
+            {101, D<&StaticService::SetStandardUserSystemClockAutomaticCorrectionEnabled>, "SetStandardUserSystemClockAutomaticCorrectionEnabled"},
+            {102, D<&StaticService::GetStandardUserSystemClockInitialYear>, "GetStandardUserSystemClockInitialYear"},
+            {200, D<&StaticService::IsStandardNetworkSystemClockAccuracySufficient>, "IsStandardNetworkSystemClockAccuracySufficient"},
+            {201, D<&StaticService::GetStandardUserSystemClockAutomaticCorrectionUpdatedTime>, "GetStandardUserSystemClockAutomaticCorrectionUpdatedTime"},
+            {300, D<&StaticService::CalculateMonotonicSystemClockBaseTimePoint>, "CalculateMonotonicSystemClockBaseTimePoint"},
+            {400, D<&StaticService::GetClockSnapshot>, "GetClockSnapshot"},
+            {401, D<&StaticService::GetClockSnapshotFromSystemClockContext>, "GetClockSnapshotFromSystemClockContext"},
+            {500, D<&StaticService::CalculateStandardUserSystemClockDifferenceByUser>, "CalculateStandardUserSystemClockDifferenceByUser"},
+            {501, D<&StaticService::CalculateSpanBetween>, "CalculateSpanBetween"},
         };
     // clang-format on
 

src/core/hle/service/ptm/psm.cpp

@@ -21,19 +21,20 @@ namespace Service::PTM {
 class IPsmSession final : public ServiceFramework<IPsmSession> {
 public:
     explicit IPsmSession(Core::System& system_)
-        : ServiceFramework{system_, "IPsmSession"}
-        , service_context{system_, "IPsmSession"} {
-        state_change_event = service_context.CreateEvent("IPsmSession::state_change_event");
-    }
+        : ServiceFramework{system_, "IPsmSession"}, service_context{system_, "IPsmSession"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &IPsmSession::BindStateChangeEvent, "BindStateChangeEvent"},
+            {1, &IPsmSession::UnbindStateChangeEvent, "UnbindStateChangeEvent"},
+            {2, &IPsmSession::SetChargerTypeChangeEventEnabled, "SetChargerTypeChangeEventEnabled"},
+            {3, &IPsmSession::SetPowerSupplyChangeEventEnabled, "SetPowerSupplyChangeEventEnabled"},
+            {4, &IPsmSession::SetBatteryVoltageStateChangeEventEnabled, "SetBatteryVoltageStateChangeEventEnabled"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, &IPsmSession::BindStateChangeEvent, "BindStateChangeEvent"},
-            FunctionInfo{1, &IPsmSession::UnbindStateChangeEvent, "UnbindStateChangeEvent"},
-            FunctionInfo{2, &IPsmSession::SetChargerTypeChangeEventEnabled, "SetChargerTypeChangeEventEnabled"},
-            FunctionInfo{3, &IPsmSession::SetPowerSupplyChangeEventEnabled, "SetPowerSupplyChangeEventEnabled"},
-            FunctionInfo{4, &IPsmSession::SetBatteryVoltageStateChangeEventEnabled, "SetBatteryVoltageStateChangeEventEnabled"}
-        );
+        RegisterHandlers(functions);
+
+        state_change_event = service_context.CreateEvent("IPsmSession::state_change_event");
     }
 
     ~IPsmSession() override {

src/core/hle/service/ptm/ptm.cpp

@@ -17,26 +17,28 @@ namespace Service::PTM {
 class PSM_MANU final : public ServiceFramework<PSM_MANU> {
 public:
     explicit PSM_MANU(Core::System& system_)
-        : ServiceFramework{system_, "psm:manu"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "EnableVdd50StateControl"},
-            FunctionInfo{1, nullptr, "DisableVdd50StateControl"},
-            FunctionInfo{2, nullptr, "SetVdd50State"}
-        );
+        : ServiceFramework{system_, "psm:manu"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "EnableVdd50StateControl"},
+            {1, nullptr, "DisableVdd50StateControl"},
+            {2, nullptr, "SetVdd50State"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 
 class POWCTL final : public ServiceFramework<POWCTL> {
 public:
     explicit POWCTL(Core::System& system_)
-        : ServiceFramework{system_, "powctl"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "OpenSession"}
-        );
+        : ServiceFramework{system_, "powctl"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "OpenSession"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 

src/core/hle/service/ptm/ts.cpp

@@ -19,14 +19,16 @@ enum class Location : u8 {
 
 class ISession : public ServiceFramework<ISession> {
 public:
-    explicit ISession(Core::System& system_) : ServiceFramework{system_, "ISession"} {}
+    explicit ISession(Core::System& system_) : ServiceFramework{system_, "ISession"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "GetTemperatureRange"},
+            {2, nullptr, "SetMeasurementMode"},
+            {4, &ISession::GetTemperature, "GetTemperature"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "GetTemperatureRange"},
-            FunctionInfo{2, nullptr, "SetMeasurementMode"},
-            FunctionInfo{4, &ISession::GetTemperature, "GetTemperature"}
-        );
+        RegisterHandlers(functions);
     }
 
 private:

src/core/hle/service/ro/ro.cpp

@@ -505,22 +505,23 @@ private:
 
 class RoInterface : public ServiceFramework<RoInterface> {
 public:
-    explicit RoInterface(Core::System& system_, const char* name_, std::shared_ptr<RoContext> ro, NrrKind nrr_kind)
-        : ServiceFramework{system_, name_}
-        , m_ro(ro)
-        , m_context_id(InvalidContextId)
-        , m_nrr_kind(nrr_kind)
-    {}
+    explicit RoInterface(Core::System& system_, const char* name_, std::shared_ptr<RoContext> ro,
+                         NrrKind nrr_kind)
+        : ServiceFramework{system_, name_}, m_ro(ro), m_context_id(InvalidContextId),
+          m_nrr_kind(nrr_kind) {
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0,  C<&RoInterface::MapManualLoadModuleMemory>, "MapManualLoadModuleMemory"},
-            FunctionInfo{1,  C<&RoInterface::UnmapManualLoadModuleMemory>, "UnmapManualLoadModuleMemory"},
-            FunctionInfo{2,  C<&RoInterface::RegisterModuleInfo>, "RegisterModuleInfo"},
-            FunctionInfo{3,  C<&RoInterface::UnregisterModuleInfo>, "UnregisterModuleInfo"},
-            FunctionInfo{4,  C<&RoInterface::RegisterProcessHandle>, "RegisterProcessHandle"},
-            FunctionInfo{10, C<&RoInterface::RegisterProcessModuleInfo>, "RegisterProcessModuleInfo"}
-        );
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0,  C<&RoInterface::MapManualLoadModuleMemory>, "MapManualLoadModuleMemory"},
+            {1,  C<&RoInterface::UnmapManualLoadModuleMemory>, "UnmapManualLoadModuleMemory"},
+            {2,  C<&RoInterface::RegisterModuleInfo>, "RegisterModuleInfo"},
+            {3,  C<&RoInterface::UnregisterModuleInfo>, "UnregisterModuleInfo"},
+            {4,  C<&RoInterface::RegisterProcessHandle>, "RegisterProcessHandle"},
+            {10, C<&RoInterface::RegisterProcessModuleInfo>, "RegisterProcessModuleInfo"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
     }
 
     ~RoInterface() {
@@ -577,7 +578,7 @@ public:
         : ServiceFramework{system_, "ro:dmnt"}
     {
         static const FunctionInfo functions[] = {
-            FunctionInfo{0, nullptr, "GetProcessModuleInfo" },
+            { 0, nullptr, "GetProcessModuleInfo" },
         };
         RegisterHandlers(functions);
     }

src/core/hle/service/service.cpp

@@ -47,7 +47,22 @@ ServiceFrameworkBase::~ServiceFrameworkBase() {
     const auto guard = ServiceFrameworkBase::LockService();
 }
 
-void ServiceFrameworkBase::ReportUnimplementedFunction(HLERequestContext& ctx, const FunctionInfoBase* info) {
+void ServiceFrameworkBase::RegisterHandlersBase(const FunctionInfoBase* functions, std::size_t n) {
+    // Usually this array is sorted by id already, so hint to insert at the end
+    handlers.reserve(handlers.size() + n);
+    for (std::size_t i = 0; i < n; ++i)
+        handlers.emplace_hint(handlers.cend(), functions[i].expected_header, functions[i]);
+}
+
+void ServiceFrameworkBase::RegisterHandlersBaseTipc(const FunctionInfoBase* functions, std::size_t n) {
+    // Usually this array is sorted by id already, so hint to insert at the end
+    handlers_tipc.reserve(handlers_tipc.size() + n);
+    for (std::size_t i = 0; i < n; ++i)
+        handlers_tipc.emplace_hint(handlers_tipc.cend(), functions[i].expected_header, functions[i]);
+}
+
+void ServiceFrameworkBase::ReportUnimplementedFunction(HLERequestContext& ctx,
+                                                       const FunctionInfoBase* info) {
     auto cmd_buf = ctx.CommandBuffer();
     std::string function_name = info == nullptr ? "<unknown>" : info->name;
 
@@ -67,10 +82,16 @@ void ServiceFrameworkBase::ReportUnimplementedFunction(HLERequestContext& ctx, c
 }
 
 void ServiceFrameworkBase::InvokeRequest(HLERequestContext& ctx) {
-    const bool is_cmd_read = ctx.GetCommand() == 0;
-    auto const info = FindRequest(ctx.GetCommand());
+    const auto command = ctx.GetCommand();
+    auto it = handlers.find(command);
+    const bool is_cmd_read = command == 0;
+    FunctionInfoBase const* info = it == handlers.end() ? nullptr : &it->second;
+    if (info == nullptr || info->handler_callback == nullptr)
+        return ReportUnimplementedFunction(ctx, info);
+
     LOG_TRACE(Service, "{}", MakeFunctionString(info->name, GetServiceName(), ctx.CommandBuffer()));
     handler_invoker(this, info->handler_callback, ctx);
+
     if (is_i_storage && is_cmd_read) {
         const auto* const process = ctx.GetThread().GetOwnerProcess();
         if (process != nullptr && system.IsNVDECActiveForProcess(process->GetId())) {
@@ -80,7 +101,11 @@ void ServiceFrameworkBase::InvokeRequest(HLERequestContext& ctx) {
 }
 
 void ServiceFrameworkBase::InvokeRequestTipc(HLERequestContext& ctx) {
-    auto const info = FindRequestTipc(ctx.GetCommand());
+    auto it = handlers_tipc.find(ctx.GetCommand());
+    FunctionInfoBase const* info = it == handlers_tipc.end() ? nullptr : &it->second;
+    if (info == nullptr || info->handler_callback == nullptr)
+        return ReportUnimplementedFunction(ctx, info);
+
     LOG_TRACE(Service, "{}", MakeFunctionString(info->name, GetServiceName(), ctx.CommandBuffer()));
     handler_invoker(this, info->handler_callback, ctx);
 }

src/core/hle/service/service.h

@@ -7,10 +7,7 @@
 #pragma once
 
 #include <cstddef>
-#include <memory>
 #include <mutex>
-#include <tuple>
-#include "frozen/map.h"
 #include "common/container/unordered_map.h"
 #include "common/common_types.h"
 #include "core/hle/service/hle_ipc.h"
@@ -80,37 +77,30 @@ protected:
     [[nodiscard]] virtual std::unique_lock<std::mutex> LockService() noexcept {
         return std::unique_lock{lock_service};
     }
-
-    static constexpr u32 MakeVersionGate(std::tuple<u32, u32, u32> since, std::tuple<u32, u32, u32> until = {0, 0, 0}) {
-        auto const [s_maj, s_min, s_pat] = since;
-        auto const [u_maj, u_min, u_pat] = until;
-        return (u_pat << 0) | (u_min << 4) | (u_maj << 8)
-            | (s_pat << 12) | (s_min << 16) | (s_maj << 20);
-    }
+private:
+    template <typename T>
+    friend class ServiceFramework;
 
     struct FunctionInfoBase {
         u32 expected_header;
         HandlerFnP<ServiceFrameworkBase> handler_callback;
         const char* name;
-        u32 version_gating;
     };
-private:
-    template <typename T>
-    friend class ServiceFramework;
 
-    using InvokerFn = void(ServiceFrameworkBase* object, HandlerFnP<ServiceFrameworkBase> member, HLERequestContext& ctx);
+    using InvokerFn = void(ServiceFrameworkBase* object, HandlerFnP<ServiceFrameworkBase> member,
+                           HLERequestContext& ctx);
 
-    explicit ServiceFrameworkBase(Core::System& system_, const char* service_name_, u32 max_sessions_, InvokerFn* handler_invoker_);
+    explicit ServiceFrameworkBase(Core::System& system_, const char* service_name_,
+                                  u32 max_sessions_, InvokerFn* handler_invoker_);
     ~ServiceFrameworkBase() override;
 
-    virtual FunctionInfoBase const* FindRequest(u32 key) = 0;
-    virtual FunctionInfoBase const* FindRequestTipc(u32 key) = 0;
-
     void RegisterHandlersBase(const FunctionInfoBase* functions, std::size_t n);
     void RegisterHandlersBaseTipc(const FunctionInfoBase* functions, std::size_t n);
     void ReportUnimplementedFunction(HLERequestContext& ctx, const FunctionInfoBase* info);
 
 protected:
+    ::Common::unordered_map<u32, FunctionInfoBase> handlers;
+    ::Common::unordered_map<u32, FunctionInfoBase> handlers_tipc;
     /// Used to gain exclusive access to the service members, e.g. from CoreTiming thread.
     std::mutex lock_service;
     /// System context that the service operates under.
@@ -153,60 +143,25 @@ protected:
         /// @param expected_header_ request header in the command buffer which will trigger dispatch to this handler
         /// @param handler_callback_ member function in this service which will be called to handle the request
         /// @param name_ human-friendly name for the request. Used mostly for logging purposes.
-        FunctionInfoTyped(u32 expected_header_, HandlerFnP<T> handler_callback_, const char* name_, u32 version_gating_ = 0)
-            : FunctionInfoBase{expected_header_, HandlerFnP<ServiceFrameworkBase>(handler_callback_), name_, version_gating_}
-        {}
+        FunctionInfoTyped(u32 expected_header_, HandlerFnP<T> handler_callback_, const char* name_)
+            : FunctionInfoBase{expected_header_, HandlerFnP<ServiceFrameworkBase>(handler_callback_), name_} {}
     };
     using FunctionInfo = FunctionInfoTyped<Self>;
 
-    template<typename ...Ts>
-        requires (std::same_as<Ts, FunctionInfo> && ...)
-    static FunctionInfoBase const* HandlerTableGenerateWithFind(u32 key, Ts... args) {
-        static auto const map = frozen::map<u32, FunctionInfo, sizeof...(args)>{
-            {args.expected_header, FunctionInfo(args)}...
-        };
-        auto const it = map.find(key);
-        return it != map.end() ? std::addressof(it->second) : nullptr;
-    }
-
-    /// @brief Initializes the handler with no functions installed.
-    /// @param system_ The system context to construct this service under.
-    /// @param service_name_ Name of the service.
-    /// @param max_sessions_ Maximum number of sessions that can be connected to this service at the
-    /// same time.
+    /**
+     * Initializes the handler with no functions installed.
+     *
+     * @param system_ The system context to construct this service under.
+     * @param service_name_ Name of the service.
+     * @param max_sessions_ Maximum number of sessions that can be connected to this service at the
+     * same time.
+     */
     explicit ServiceFramework(Core::System& system_, const char* service_name_, u32 max_sessions_ = ServerSessionCountMax)
-        : ServiceFrameworkBase(system_, service_name_, max_sessions_, Invoker)
-    {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        auto it = handlers.find(key);
-        FunctionInfoBase const* info = it == handlers.end() ? nullptr : &it->second;
-        return !(info == nullptr || info->handler_callback == nullptr) ? info : nullptr;
-    }
-
-    FunctionInfoBase const* FindRequestTipc(u32 key) override {
-        auto it = handlers_tipc.find(key);
-        FunctionInfoBase const* info = it == handlers_tipc.end() ? nullptr : &it->second;
-        return !(info == nullptr || info->handler_callback == nullptr) ? info : nullptr;
-    }
-
-    constexpr void RegisterHandlersBase(const FunctionInfoBase* functions, std::size_t n) {
-        // Usually this array is sorted by id already, so hint to insert at the end
-        handlers.reserve(handlers.size() + n);
-        for (std::size_t i = 0; i < n; ++i)
-            handlers.emplace_hint(handlers.cend(), functions[i].expected_header, functions[i]);
-    }
-
-    constexpr void RegisterHandlersBaseTipc(const FunctionInfoBase* functions, std::size_t n) {
-        // Usually this array is sorted by id already, so hint to insert at the end
-        handlers_tipc.reserve(handlers_tipc.size() + n);
-        for (std::size_t i = 0; i < n; ++i)
-            handlers_tipc.emplace_hint(handlers_tipc.cend(), functions[i].expected_header, functions[i]);
-    }
+        : ServiceFrameworkBase(system_, service_name_, max_sessions_, Invoker) {}
 
     /// Registers handlers in the service.
     template <typename T = Self, std::size_t N>
-    constexpr void RegisterHandlers(const FunctionInfoTyped<T> (&functions)[N]) {
+    void RegisterHandlers(const FunctionInfoTyped<T> (&functions)[N]) {
         RegisterHandlers(functions, N);
     }
 
@@ -215,13 +170,13 @@ protected:
      * overload in order to avoid needing to specify the array size.
      */
     template <typename T = Self>
-    constexpr void RegisterHandlers(const FunctionInfoTyped<T>* functions, std::size_t n) {
+    void RegisterHandlers(const FunctionInfoTyped<T>* functions, std::size_t n) {
         RegisterHandlersBase(functions, n);
     }
 
     /// Registers handlers in the service.
     template <typename T = Self, std::size_t N>
-    constexpr void RegisterHandlersTipc(const FunctionInfoTyped<T> (&functions)[N]) {
+    void RegisterHandlersTipc(const FunctionInfoTyped<T> (&functions)[N]) {
         RegisterHandlersTipc(functions, N);
     }
 
@@ -230,7 +185,7 @@ protected:
      * overload in order to avoid needing to specify the array size.
      */
     template <typename T = Self>
-    constexpr void RegisterHandlersTipc(const FunctionInfoTyped<T>* functions, std::size_t n) {
+    void RegisterHandlersTipc(const FunctionInfoTyped<T>* functions, std::size_t n) {
         RegisterHandlersBaseTipc(functions, n);
     }
 
@@ -262,9 +217,6 @@ private:
         // Cast back up to our original types and call the member function
         (static_cast<Self*>(object)->*HandlerFnP<Self>(member))(ctx);
     }
-
-    ::Common::unordered_map<u32, FunctionInfoBase> handlers;
-    ::Common::unordered_map<u32, FunctionInfoBase> handlers_tipc;
 };
 
 } // namespace Service

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

@@ -15,46 +15,49 @@ namespace Service::Sockets {
 class ETHC_C final : public ServiceFramework<ETHC_C> {
 public:
     explicit ETHC_C(Core::System& system_)
-        : ServiceFramework{system_, "ethc:c"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "Initialize"},
-            FunctionInfo{1, nullptr, "Cancel"},
-            FunctionInfo{2, nullptr, "GetResult"},
-            FunctionInfo{3, nullptr, "GetMediaList"},
-            FunctionInfo{4, nullptr, "SetMediaType"},
-            FunctionInfo{5, nullptr, "GetMediaType"},
-            FunctionInfo{6, nullptr, "GetMacAddress"}
-        );
+        : ServiceFramework{system_, "ethc:c"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "Initialize"},
+            {1, nullptr, "Cancel"},
+            {2, nullptr, "GetResult"},
+            {3, nullptr, "GetMediaList"},
+            {4, nullptr, "SetMediaType"},
+            {5, nullptr, "GetMediaType"},
+            {6, nullptr, "GetMacAddress"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 
 class ETHC_I final : public ServiceFramework<ETHC_I> {
 public:
     explicit ETHC_I(Core::System& system_)
-        : ServiceFramework{system_, "ethc:i"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "GetReadableHandle"},
-            FunctionInfo{1, nullptr, "Cancel"},
-            FunctionInfo{2, nullptr, "GetResult"},
-            FunctionInfo{3, nullptr, "GetInterfaceList"},
-            FunctionInfo{4, nullptr, "GetInterfaceCount"}
-        );
+        : ServiceFramework{system_, "ethc:i"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "GetReadableHandle"},
+            {1, nullptr, "Cancel"},
+            {2, nullptr, "GetResult"},
+            {3, nullptr, "GetInterfaceList"},
+            {4, nullptr, "GetInterfaceCount"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 
 class ISfDriverServiceCreator final : public ServiceFramework<ISfDriverServiceCreator> {
 public:
     explicit ISfDriverServiceCreator(Core::System& system_)
-        : ServiceFramework{system_, "eth:nd"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "CreateDriverService"}
-        );
+        : ServiceFramework{system_, "eth:nd"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "CreateDriverService"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 

src/core/hle/service/spl/spl_module.cpp

@@ -207,7 +207,7 @@ public:
     explicit CSRNG(Core::System& system_, std::shared_ptr<Module> module_)
         : Interface(system_, std::move(module_), "csrng") {
         static const FunctionInfo functions[] = {
-            FunctionInfo{0, &CSRNG::GenerateRandomBytes, "GenerateRandomBytes"}
+            {0, &CSRNG::GenerateRandomBytes, "GenerateRandomBytes"},
         };
         RegisterHandlers(functions);
     }

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

@@ -74,54 +74,57 @@ struct SslContextSharedData {
 
 class ISslConnection final : public ServiceFramework<ISslConnection> {
 public:
-    explicit ISslConnection(Core::System& system_in, SslVersion ssl_version_in, std::shared_ptr<SslContextSharedData>& shared_data_in, std::unique_ptr<SSLConnectionBackend>&& backend_in)
-        : ServiceFramework{system_in, "ISslConnection"}
-        , ssl_version{ssl_version_in}
-        , shared_data{shared_data_in}
-        , backend{std::move(backend_in)} {
-        backend->SetVerifyOption(verify_option);
-        shared_data->connection_count++;
-    }
+    explicit ISslConnection(Core::System& system_in, SslVersion ssl_version_in,
+                            std::shared_ptr<SslContextSharedData>& shared_data_in,
+                            std::unique_ptr<SSLConnectionBackend>&& backend_in)
+        : ServiceFramework{system_in, "ISslConnection"}, ssl_version{ssl_version_in},
+          shared_data{shared_data_in}, backend{std::move(backend_in)} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, D<&ISslConnection::SetSocketDescriptor>, "SetSocketDescriptor"},
+            {1, D<&ISslConnection::SetHostName>, "SetHostName"},
+            {2, D<&ISslConnection::SetVerifyOption>, "SetVerifyOption"},
+            {3, D<&ISslConnection::SetIoMode>, "SetIoMode"},
+            {4, D<&ISslConnection::GetSocketDescriptor>, "GetSocketDescriptor"},
+            {5, D<&ISslConnection::GetHostName>, "GetHostName"},
+            {6, nullptr, "GetVerifyOption"},
+            {7, D<&ISslConnection::GetIoMode>, "GetIoMode"},
+            {8, D<&ISslConnection::DoHandshake>, "DoHandshake"},
+            {9, &ISslConnection::DoHandshakeGetServerCert, "DoHandshakeGetServerCert"},
+            {10, D<&ISslConnection::Read>, "Read"},
+            {11, D<&ISslConnection::Write>, "Write"},
+            {12, D<&ISslConnection::Pending>, "Pending"},
+            {13, D<&ISslConnection::Peek>, "Peek"},
+            {14, D<&ISslConnection::Poll>, "Poll"},
+            {15, D<&ISslConnection::GetVerifyCertError>, "GetVerifyCertError"},
+            {16, D<&ISslConnection::GetNeededServerCertBufferSize>, "GetNeededServerCertBufferSize"},
+            {17, D<&ISslConnection::SetSessionCacheMode>, "SetSessionCacheMode"},
+            {18, D<&ISslConnection::GetSessionCacheMode>, "GetSessionCacheMode"},
+            {19, D<&ISslConnection::FlushSessionCache>, "FlushSessionCache"},
+            {20, D<&ISslConnection::SetRenegotiationMode>, "SetRenegotiationMode"},
+            {21, D<&ISslConnection::GetRenegotiationMode>, "GetRenegotiationMode"},
+            {22, D<&ISslConnection::SetOption>, "SetOption"},
+            {23, D<&ISslConnection::GetOption>, "GetOption"},
+            {24, nullptr, "GetVerifyCertErrors"},
+            {25, nullptr, "GetCipherInfo"},
+            {26, D<&ISslConnection::SetNextAlpnProto>, "SetNextAlpnProto"},
+            {27, D<&ISslConnection::GetNextAlpnProto>, "GetNextAlpnProto"},
+            {28, nullptr, "SetDtlsSocketDescriptor"},
+            {29, nullptr, "GetDtlsHandshakeTimeout"},
+            {30, nullptr, "SetPrivateOption"},
+            {31, nullptr, "SetSrtpCiphers"},
+            {32, nullptr, "GetSrtpCipher"},
+            {33, nullptr, "ExportKeyingMaterial"},
+            {34, nullptr, "SetIoTimeout"},
+            {35, nullptr, "GetIoTimeout"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, D<&ISslConnection::SetSocketDescriptor>, "SetSocketDescriptor"},
-            FunctionInfo{1, D<&ISslConnection::SetHostName>, "SetHostName"},
-            FunctionInfo{2, D<&ISslConnection::SetVerifyOption>, "SetVerifyOption"},
-            FunctionInfo{3, D<&ISslConnection::SetIoMode>, "SetIoMode"},
-            FunctionInfo{4, D<&ISslConnection::GetSocketDescriptor>, "GetSocketDescriptor"},
-            FunctionInfo{5, D<&ISslConnection::GetHostName>, "GetHostName"},
-            FunctionInfo{6, nullptr, "GetVerifyOption"},
-            FunctionInfo{7, D<&ISslConnection::GetIoMode>, "GetIoMode"},
-            FunctionInfo{8, D<&ISslConnection::DoHandshake>, "DoHandshake"},
-            FunctionInfo{9, &ISslConnection::DoHandshakeGetServerCert, "DoHandshakeGetServerCert"},
-            FunctionInfo{10, D<&ISslConnection::Read>, "Read"},
-            FunctionInfo{11, D<&ISslConnection::Write>, "Write"},
-            FunctionInfo{12, D<&ISslConnection::Pending>, "Pending"},
-            FunctionInfo{13, D<&ISslConnection::Peek>, "Peek"},
-            FunctionInfo{14, D<&ISslConnection::Poll>, "Poll"},
-            FunctionInfo{15, D<&ISslConnection::GetVerifyCertError>, "GetVerifyCertError"},
-            FunctionInfo{16, D<&ISslConnection::GetNeededServerCertBufferSize>, "GetNeededServerCertBufferSize"},
-            FunctionInfo{17, D<&ISslConnection::SetSessionCacheMode>, "SetSessionCacheMode"},
-            FunctionInfo{18, D<&ISslConnection::GetSessionCacheMode>, "GetSessionCacheMode"},
-            FunctionInfo{19, D<&ISslConnection::FlushSessionCache>, "FlushSessionCache"},
-            FunctionInfo{20, D<&ISslConnection::SetRenegotiationMode>, "SetRenegotiationMode"},
-            FunctionInfo{21, D<&ISslConnection::GetRenegotiationMode>, "GetRenegotiationMode"},
-            FunctionInfo{22, D<&ISslConnection::SetOption>, "SetOption"},
-            FunctionInfo{23, D<&ISslConnection::GetOption>, "GetOption"},
-            FunctionInfo{24, nullptr, "GetVerifyCertErrors"},
-            FunctionInfo{25, nullptr, "GetCipherInfo"},
-            FunctionInfo{26, D<&ISslConnection::SetNextAlpnProto>, "SetNextAlpnProto"},
-            FunctionInfo{27, D<&ISslConnection::GetNextAlpnProto>, "GetNextAlpnProto"},
-            FunctionInfo{28, nullptr, "SetDtlsSocketDescriptor"},
-            FunctionInfo{29, nullptr, "GetDtlsHandshakeTimeout"},
-            FunctionInfo{30, nullptr, "SetPrivateOption"},
-            FunctionInfo{31, nullptr, "SetSrtpCiphers"},
-            FunctionInfo{32, nullptr, "GetSrtpCipher"},
-            FunctionInfo{33, nullptr, "ExportKeyingMaterial"},
-            FunctionInfo{34, nullptr, "SetIoTimeout"},
-            FunctionInfo{35, nullptr, "GetIoTimeout"}
-        );
+        RegisterHandlers(functions);
+
+        backend->SetVerifyOption(verify_option);
+
+        shared_data->connection_count++;
     }
 
     ~ISslConnection() {
@@ -450,20 +453,20 @@ public:
         : ServiceFramework{system_, "ISslContext"}, ssl_version{version},
           shared_data{std::make_shared<SslContextSharedData>()} {
         static const FunctionInfo functions[] = {
-            FunctionInfo{0, &ISslContext::SetOption, "SetOption"},
-            FunctionInfo{1, &ISslContext::GetOption, "GetOption"},
-            FunctionInfo{2, &ISslContext::CreateConnection, "CreateConnection"},
-            FunctionInfo{3, &ISslContext::GetConnectionCount, "GetConnectionCount"},
-            FunctionInfo{4, &ISslContext::ImportServerPki, "ImportServerPki"},
-            FunctionInfo{5, &ISslContext::ImportClientPki, "ImportClientPki"},
-            FunctionInfo{6, nullptr, "RemoveServerPki"},
-            FunctionInfo{7, nullptr, "RemoveClientPki"},
-            FunctionInfo{8, D<&ISslContext::RegisterInternalPki>, "RegisterInternalPki"},
-            FunctionInfo{9, nullptr, "AddPolicyOid"},
-            FunctionInfo{10, nullptr, "ImportCrl"},
-            FunctionInfo{11, nullptr, "RemoveCrl"},
-            FunctionInfo{12, nullptr, "ImportClientCertKeyPki"},
-            FunctionInfo{13, nullptr, "GeneratePrivateKeyAndCert"}
+            {0, &ISslContext::SetOption, "SetOption"},
+            {1, &ISslContext::GetOption, "GetOption"},
+            {2, &ISslContext::CreateConnection, "CreateConnection"},
+            {3, &ISslContext::GetConnectionCount, "GetConnectionCount"},
+            {4, &ISslContext::ImportServerPki, "ImportServerPki"},
+            {5, &ISslContext::ImportClientPki, "ImportClientPki"},
+            {6, nullptr, "RemoveServerPki"},
+            {7, nullptr, "RemoveClientPki"},
+            {8, D<&ISslContext::RegisterInternalPki>, "RegisterInternalPki"},
+            {9, nullptr, "AddPolicyOid"},
+            {10, nullptr, "ImportCrl"},
+            {11, nullptr, "RemoveCrl"},
+            {12, nullptr, "ImportClientCertKeyPki"},
+            {13, nullptr, "GeneratePrivateKeyAndCert"},
         };
         RegisterHandlers(functions);
     }
@@ -563,21 +566,23 @@ private:
 class ISslService final : public ServiceFramework<ISslService> {
 public:
     explicit ISslService(Core::System& system_)
-        : ServiceFramework{system_, "ssl"}, cert_store{system} {}
+        : ServiceFramework{system_, "ssl"}, cert_store{system} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &ISslService::CreateContext, "CreateContext"},
+            {1, nullptr, "GetContextCount"},
+            {2, D<&ISslService::GetCertificates>, "GetCertificates"},
+            {3, D<&ISslService::GetCertificateBufSize>, "GetCertificateBufSize"},
+            {4, nullptr, "DebugIoctl"},
+            {5, &ISslService::SetInterfaceVersion, "SetInterfaceVersion"},
+            {6, nullptr, "FlushSessionCache"},
+            {7, nullptr, "SetDebugOption"},
+            {8, nullptr, "GetDebugOption"},
+            {8, nullptr, "ClearTls12FallbackFlag"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, &ISslService::CreateContext, "CreateContext"},
-            FunctionInfo{1, nullptr, "GetContextCount"},
-            FunctionInfo{2, D<&ISslService::GetCertificates>, "GetCertificates"},
-            FunctionInfo{3, D<&ISslService::GetCertificateBufSize>, "GetCertificateBufSize"},
-            FunctionInfo{4, nullptr, "DebugIoctl"},
-            FunctionInfo{5, &ISslService::SetInterfaceVersion, "SetInterfaceVersion"},
-            FunctionInfo{6, nullptr, "FlushSessionCache"},
-            FunctionInfo{7, nullptr, "SetDebugOption"},
-            FunctionInfo{8, nullptr, "GetDebugOption"},
-            FunctionInfo{8, nullptr, "ClearTls12FallbackFlag"}
-        );
+        RegisterHandlers(functions);
     }
 
 private:
@@ -631,20 +636,20 @@ class ISslServiceForSystem final : public ServiceFramework<ISslServiceForSystem>
         explicit ISslServiceForSystem(Core::System& system_) : ServiceFramework{system_, "ssl:s"} {
             // clang-format off
             static const FunctionInfo functions[] = {
-                FunctionInfo{0, D<&ISslServiceForSystem::CreateContext>, "CreateContext"},
-                FunctionInfo{1, D<&ISslServiceForSystem::GetContextCount>, "GetContextCount"},
-                FunctionInfo{2, D<&ISslServiceForSystem::GetCertificates>, "GetCertificates"},
-                FunctionInfo{3, D<&ISslServiceForSystem::GetCertificateBufSize>, "GetCertificateBufSize"},
-                FunctionInfo{4, D<&ISslServiceForSystem::DebugIoctl>, "DebugIoctl"},
-                FunctionInfo{5, D<&ISslServiceForSystem::SetInterfaceVersion>, "SetInterfaceVersion"},
-                FunctionInfo{6, D<&ISslServiceForSystem::FlushSessionCache>, "FlushSessionCache"},
-                FunctionInfo{7, D<&ISslServiceForSystem::SetDebugOption>, "SetDebugOption"},
-                FunctionInfo{8, D<&ISslServiceForSystem::GetDebugOption>, "GetDebugOption"},
-                FunctionInfo{9, D<&ISslServiceForSystem::ClearTls12FallbackFlag>, "ClearTls12FallbackFlag"},
-                FunctionInfo{100, D<&ISslServiceForSystem::CreateContextForSystem>, "CreateContextForSystem"},
-                FunctionInfo{101, D<&ISslServiceForSystem::SetThreadCoreMask>, "SetThreadCoreMask"},
-                FunctionInfo{102, D<&ISslServiceForSystem::GetThreadCoreMask>, "GetThreadCoreMask"},
-                FunctionInfo{103, D<&ISslServiceForSystem::VerifySignature>, "VerifySignature"}
+                {0, D<&ISslServiceForSystem::CreateContext>, "CreateContext"},
+                {1, D<&ISslServiceForSystem::GetContextCount>, "GetContextCount"},
+                {2, D<&ISslServiceForSystem::GetCertificates>, "GetCertificates"},
+                {3, D<&ISslServiceForSystem::GetCertificateBufSize>, "GetCertificateBufSize"},
+                {4, D<&ISslServiceForSystem::DebugIoctl>, "DebugIoctl"},
+                {5, D<&ISslServiceForSystem::SetInterfaceVersion>, "SetInterfaceVersion"},
+                {6, D<&ISslServiceForSystem::FlushSessionCache>, "FlushSessionCache"},
+                {7, D<&ISslServiceForSystem::SetDebugOption>, "SetDebugOption"},
+                {8, D<&ISslServiceForSystem::GetDebugOption>, "GetDebugOption"},
+                {9, D<&ISslServiceForSystem::ClearTls12FallbackFlag>, "ClearTls12FallbackFlag"},
+                {100, D<&ISslServiceForSystem::CreateContextForSystem>, "CreateContextForSystem"},
+                {101, D<&ISslServiceForSystem::SetThreadCoreMask>, "SetThreadCoreMask"},
+                {102, D<&ISslServiceForSystem::GetThreadCoreMask>, "GetThreadCoreMask"},
+                {103, D<&ISslServiceForSystem::VerifySignature>, "VerifySignature"}
             };
             // clang-format on
 

src/core/hle/service/tma/tma.cpp

@@ -21,7 +21,7 @@ public:
         : ServiceFramework{system_, "htc:tenv"}
     {
         static const FunctionInfo functions[] = {
-            FunctionInfo{0, nullptr, "GetServiceInterface"}
+            {0, nullptr, "GetServiceInterface"},
         };
         RegisterHandlers(functions);
     }

src/core/hle/service/usb/usb.cpp

@@ -17,123 +17,137 @@ namespace Service::USB {
 
 class IDsInterface final : public ServiceFramework<IDsInterface> {
 public:
-    explicit IDsInterface(Core::System& system_) : ServiceFramework{system_, "IDsInterface"} {}
+    explicit IDsInterface(Core::System& system_) : ServiceFramework{system_, "IDsInterface"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "AddEndpoint"},
+            {1, nullptr, "GetSetupEvent"},
+            {2, nullptr, "GetSetupPacket"},
+            {3, nullptr, "Enable"},
+            {4, nullptr, "Disable"},
+            {5, nullptr, "CtrlIn"},
+            {6, nullptr, "CtrlOut"},
+            {7, nullptr, "GetCtrlInCompletionEvent"},
+            {8, nullptr, "GetCtrlInUrbReport"},
+            {9, nullptr, "GetCtrlOutCompletionEvent"},
+            {10, nullptr, "GetCtrlOutUrbReport"},
+            {11, nullptr, "CtrlStall"},
+            {12, nullptr, "AppendConfigurationData"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "AddEndpoint"},
-            FunctionInfo{1, nullptr, "GetSetupEvent"},
-            FunctionInfo{2, nullptr, "GetSetupPacket"},
-            FunctionInfo{3, nullptr, "Enable"},
-            FunctionInfo{4, nullptr, "Disable"},
-            FunctionInfo{5, nullptr, "CtrlIn"},
-            FunctionInfo{6, nullptr, "CtrlOut"},
-            FunctionInfo{7, nullptr, "GetCtrlInCompletionEvent"},
-            FunctionInfo{8, nullptr, "GetCtrlInUrbReport"},
-            FunctionInfo{9, nullptr, "GetCtrlOutCompletionEvent"},
-            FunctionInfo{10, nullptr, "GetCtrlOutUrbReport"},
-            FunctionInfo{11, nullptr, "CtrlStall"},
-            FunctionInfo{12, nullptr, "AppendConfigurationData"}
-        );
+        RegisterHandlers(functions);
     }
 };
 
 class IDsRootSession final : public ServiceFramework<IDsRootSession> {
 public:
-    explicit IDsRootSession(Core::System& system_) : ServiceFramework{system_, "usb:ds"} {}
+    explicit IDsRootSession(Core::System& system_) : ServiceFramework{system_, "usb:ds"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "OpenDsService"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "OpenDsService"}
-        );
+        RegisterHandlers(functions);
     }
 };
 
 class IClientEpSession final : public ServiceFramework<IClientEpSession> {
 public:
     explicit IClientEpSession(Core::System& system_)
-        : ServiceFramework{system_, "IClientEpSession"} {}
+        : ServiceFramework{system_, "IClientEpSession"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "ReOpen"},
+            {1, nullptr, "Close"},
+            {2, nullptr, "GetCompletionEvent"},
+            {3, nullptr, "PopulateRing"},
+            {4, nullptr, "PostBufferAsync"},
+            {5, nullptr, "GetXferReport"},
+            {6, nullptr, "PostBufferMultiAsync"},
+            {7, nullptr, "CreateSmmuSpace"},
+            {8, nullptr, "ShareReportRing"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "ReOpen"},
-            FunctionInfo{1, nullptr, "Close"},
-            FunctionInfo{2, nullptr, "GetCompletionEvent"},
-            FunctionInfo{3, nullptr, "PopulateRing"},
-            FunctionInfo{4, nullptr, "PostBufferAsync"},
-            FunctionInfo{5, nullptr, "GetXferReport"},
-            FunctionInfo{6, nullptr, "PostBufferMultiAsync"},
-            FunctionInfo{7, nullptr, "CreateSmmuSpace"},
-            FunctionInfo{8, nullptr, "ShareReportRing"}
-        );
+        RegisterHandlers(functions);
     }
 };
 
 class IClientIfSession final : public ServiceFramework<IClientIfSession> {
 public:
     explicit IClientIfSession(Core::System& system_)
-        : ServiceFramework{system_, "IClientIfSession"} {}
+        : ServiceFramework{system_, "IClientIfSession"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "GetStateChangeEvent"},
+            {1, nullptr, "SetInterface"},
+            {2, nullptr, "GetInterface"},
+            {3, nullptr, "GetAlternateInterface"},
+            {4, nullptr, "GetCurrentFrame"},
+            {5, nullptr, "CtrlXferAsync"},
+            {6, nullptr, "GetCtrlXferCompletionEvent"},
+            {7, nullptr, "GetCtrlXferReport"},
+            {8, nullptr, "ResetDevice"},
+            {9, nullptr, "OpenUsbEp"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "GetStateChangeEvent"},
-            FunctionInfo{1, nullptr, "SetInterface"},
-            FunctionInfo{2, nullptr, "GetInterface"},
-            FunctionInfo{3, nullptr, "GetAlternateInterface"},
-            FunctionInfo{4, nullptr, "GetCurrentFrame"},
-            FunctionInfo{5, nullptr, "CtrlXferAsync"},
-            FunctionInfo{6, nullptr, "GetCtrlXferCompletionEvent"},
-            FunctionInfo{7, nullptr, "GetCtrlXferReport"},
-            FunctionInfo{8, nullptr, "ResetDevice"},
-            FunctionInfo{9, nullptr, "OpenUsbEp"}
-        );
+        RegisterHandlers(functions);
     }
 };
 
 class IClientRootSession final : public ServiceFramework<IClientRootSession> {
 public:
-    explicit IClientRootSession(Core::System& system_) : ServiceFramework{system_, "usb:hs"} {}
+    explicit IClientRootSession(Core::System& system_) : ServiceFramework{system_, "usb:hs"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "BindClientProcess"},
+            {1, nullptr, "QueryAllInterfaces"},
+            {2, nullptr, "QueryAvailableInterfaces"},
+            {3, nullptr, "QueryAcquiredInterfaces"},
+            {4, nullptr, "CreateInterfaceAvailableEvent"},
+            {5, nullptr, "DestroyInterfaceAvailableEvent"},
+            {6, nullptr, "GetInterfaceStateChangeEvent"},
+            {7, nullptr, "AcquireUsbIf"},
+            {8, nullptr, "SetTestMode"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "BindClientProcess"},
-            FunctionInfo{1, nullptr, "QueryAllInterfaces"},
-            FunctionInfo{2, nullptr, "QueryAvailableInterfaces"},
-            FunctionInfo{3, nullptr, "QueryAcquiredInterfaces"},
-            FunctionInfo{4, nullptr, "CreateInterfaceAvailableEvent"},
-            FunctionInfo{5, nullptr, "DestroyInterfaceAvailableEvent"},
-            FunctionInfo{6, nullptr, "GetInterfaceStateChangeEvent"},
-            FunctionInfo{7, nullptr, "AcquireUsbIf"},
-            FunctionInfo{8, nullptr, "SetTestMode"}
-        );
+        RegisterHandlers(functions);
     }
 };
 
 class IPdSession final : public ServiceFramework<IPdSession> {
 public:
-    explicit IPdSession(Core::System& system_) : ServiceFramework{system_, "IPdSession"} {}
+    explicit IPdSession(Core::System& system_) : ServiceFramework{system_, "IPdSession"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "BindNoticeEvent"},
+            {1, nullptr, "UnbindNoticeEvent"},
+            {2, nullptr, "GetStatus"},
+            {3, nullptr, "GetNotice"},
+            {4, nullptr, "EnablePowerRequestNotice"},
+            {5, nullptr, "DisablePowerRequestNotice"},
+            {6, nullptr, "ReplyPowerRequest"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "BindNoticeEvent"},
-            FunctionInfo{1, nullptr, "UnbindNoticeEvent"},
-            FunctionInfo{2, nullptr, "GetStatus"},
-            FunctionInfo{3, nullptr, "GetNotice"},
-            FunctionInfo{4, nullptr, "EnablePowerRequestNotice"},
-            FunctionInfo{5, nullptr, "DisablePowerRequestNotice"},
-            FunctionInfo{6, nullptr, "ReplyPowerRequest"}
-        );
+        RegisterHandlers(functions);
     }
 };
 
 class IPdManager final : public ServiceFramework<IPdManager> {
 public:
-    explicit IPdManager(Core::System& system_) : ServiceFramework{system_, "usb:pd"} {}
+    explicit IPdManager(Core::System& system_) : ServiceFramework{system_, "usb:pd"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &IPdManager::OpenSession, "OpenSession"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, &IPdManager::OpenSession, "OpenSession"}
-        );
+        RegisterHandlers(functions);
     }
 
 private:
@@ -149,31 +163,35 @@ private:
 class IPdCradleSession final : public ServiceFramework<IPdCradleSession> {
 public:
     explicit IPdCradleSession(Core::System& system_)
-        : ServiceFramework{system_, "IPdCradleSession"} {}
+        : ServiceFramework{system_, "IPdCradleSession"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "SetCradleVdo"},
+            {1, nullptr, "GetCradleVdo"},
+            {2, nullptr, "ResetCradleUsbHub"},
+            {3, nullptr, "GetHostPdcFirmwareType"},
+            {4, nullptr, "GetHostPdcFirmwareRevision"},
+            {5, nullptr, "GetHostPdcManufactureId"},
+            {6, nullptr, "GetHostPdcDeviceId"},
+            {7, nullptr, "EnableCradleRecovery"},
+            {8, nullptr, "DisableCradleRecovery"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "SetCradleVdo"},
-            FunctionInfo{1, nullptr, "GetCradleVdo"},
-            FunctionInfo{2, nullptr, "ResetCradleUsbHub"},
-            FunctionInfo{3, nullptr, "GetHostPdcFirmwareType"},
-            FunctionInfo{4, nullptr, "GetHostPdcFirmwareRevision"},
-            FunctionInfo{5, nullptr, "GetHostPdcManufactureId"},
-            FunctionInfo{6, nullptr, "GetHostPdcDeviceId"},
-            FunctionInfo{7, nullptr, "EnableCradleRecovery"},
-            FunctionInfo{8, nullptr, "DisableCradleRecovery"}
-        );
+        RegisterHandlers(functions);
     }
 };
 
 class IPdCradleManager final : public ServiceFramework<IPdCradleManager> {
 public:
-    explicit IPdCradleManager(Core::System& system_) : ServiceFramework{system_, "usb:pd:c"} {}
+    explicit IPdCradleManager(Core::System& system_) : ServiceFramework{system_, "usb:pd:c"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &IPdCradleManager::OpenCradleSession, "OpenCradleSession"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, &IPdCradleManager::OpenCradleSession, "OpenCradleSession"}
-        );
+        RegisterHandlers(functions);
     }
 
 private:
@@ -188,52 +206,57 @@ private:
 
 class IPmMainService final : public ServiceFramework<IPmMainService> {
 public:
-    explicit IPmMainService(Core::System& system_) : ServiceFramework{system_, "usb:pm"} {}
+    explicit IPmMainService(Core::System& system_) : ServiceFramework{system_, "usb:pm"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "GetPowerEvent"},
+            {1, nullptr, "GetPowerState"},
+            {2, nullptr, "GetDataEvent"},
+            {3, nullptr, "GetDataRole"},
+            {4, nullptr, "SetDiagData"},
+            {5, nullptr, "GetDiagData"},
+        };
+        // clang-format on
 
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "GetPowerEvent"},
-            FunctionInfo{1, nullptr, "GetPowerState"},
-            FunctionInfo{2, nullptr, "GetDataEvent"},
-            FunctionInfo{3, nullptr, "GetDataRole"},
-            FunctionInfo{4, nullptr, "SetDiagData"},
-            FunctionInfo{5, nullptr, "GetDiagData"}
-        );
+        RegisterHandlers(functions);
     }
 };
 
 class IPdManufactureManager final : public ServiceFramework<IPdManufactureManager> {
 public:
-    explicit IPdManufactureManager(Core::System& system_) : ServiceFramework{system_, "usb:pd:m"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "OpenManufactureSession"}
-        );
+    explicit IPdManufactureManager(Core::System& system_) : ServiceFramework{system_, "usb:pd:m"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "OpenManufactureSession"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 
 class IQdbManager final : public ServiceFramework<IQdbManager> {
 public:
-    explicit IQdbManager(Core::System& system_) : ServiceFramework{system_, "usb:qdb"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "ImportQuirkDevices"},
-            FunctionInfo{1, nullptr, "HasQuirk"}
-        );
+    explicit IQdbManager(Core::System& system_) : ServiceFramework{system_, "usb:qdb"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "ImportQuirkDevices"},
+            {1, nullptr, "HasQuirk"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 
 class IPmObserverService final : public ServiceFramework<IPmObserverService> {
 public:
-    explicit IPmObserverService(Core::System& system_) : ServiceFramework{system_, "usb:obsv"} {}
-
-    FunctionInfoBase const* FindRequest(u32 key) override {
-        return HandlerTableGenerateWithFind(key,
-            FunctionInfo{0, nullptr, "GetTopologyChangeEvent"},
-            FunctionInfo{1, nullptr, "GetFlattenedTopology"}
-        );
+    explicit IPmObserverService(Core::System& system_) : ServiceFramework{system_, "usb:obsv"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, nullptr, "GetTopologyChangeEvent"},
+            {1, nullptr, "GetFlattenedTopology"},
+        };
+        // clang-format on
+        RegisterHandlers(functions);
     }
 };
 

src/core/hle/service/wlan/wlan.cpp

@@ -18,103 +18,103 @@ public:
         : ServiceFramework{system_, "wlan:lcl"}
     {
         static const FunctionInfo functions[] = {
-            FunctionInfo{0, nullptr, "OpenMasterMode" },
-            FunctionInfo{0, nullptr, "OpenMode_2" },
-            FunctionInfo{1, nullptr, "CloseMasterMode" },
-            FunctionInfo{1, nullptr, "CloseMode_2" },
-            FunctionInfo{2, nullptr, "OpenClientMode" },
-            FunctionInfo{2, nullptr, "GetMacAddress_2" },
-            FunctionInfo{3, nullptr, "CloseClientMode" },
-            FunctionInfo{3, nullptr, "CreateBss" },
-            FunctionInfo{4, nullptr, "OpenSpectatorMode" },
-            FunctionInfo{4, nullptr, "DestroyBss" },
-            FunctionInfo{5, nullptr, "CloseSpectatorMode" },
-            FunctionInfo{5, nullptr, "StartScan_2" },
-            FunctionInfo{6, nullptr, "GetMacAddress_2" },
-            FunctionInfo{6, nullptr, "StopScan_2" },
-            FunctionInfo{7, nullptr, "CreateBss" },
-            FunctionInfo{7, nullptr, "Connect_2" },
-            FunctionInfo{8, nullptr, "DestroyBss" },
-            FunctionInfo{8, nullptr, "CancelConnect_2" },
-            FunctionInfo{9, nullptr, "StartScan_2" },
-            FunctionInfo{9, nullptr, "Join" },
-            FunctionInfo{10, nullptr, "StopScan_2" },
-            FunctionInfo{10, nullptr, "CancelJoin" },
-            FunctionInfo{11, nullptr, "Connect_2" },
-            FunctionInfo{11, nullptr, "Disconnect_2" },
-            FunctionInfo{12, nullptr, "CancelConnect_2" },
-            FunctionInfo{12, nullptr, "SetBeaconLostCount" },
-            FunctionInfo{13, nullptr, "Join" },
-            FunctionInfo{13, nullptr, "GetSystemEvent_2" },
-            FunctionInfo{14, nullptr, "CancelJoin" },
-            FunctionInfo{14, nullptr, "GetConnectionStatus_2" },
-            FunctionInfo{15, nullptr, "Disconnect_2" },
-            FunctionInfo{15, nullptr, "GetClientStatus" },
-            FunctionInfo{16, nullptr, "SetBeaconLostCount" },
-            FunctionInfo{16, nullptr, "GetBssIndicationEvent" },
-            FunctionInfo{17, nullptr, "GetSystemEvent_2" },
-            FunctionInfo{17, nullptr, "GetBssIndicationInfo" },
-            FunctionInfo{18, nullptr, "GetConnectionStatus_2" },
-            FunctionInfo{18, nullptr, "GetState_2" },
-            FunctionInfo{19, nullptr, "GetClientStatus" },
-            FunctionInfo{19, nullptr, "GetAllowedChannels" },
-            FunctionInfo{20, nullptr, "GetBssIndicationEvent" },
-            FunctionInfo{20, nullptr, "AddIe" },
-            FunctionInfo{21, nullptr, "GetBssIndicationInfo" },
-            FunctionInfo{21, nullptr, "DeleteIe" },
-            FunctionInfo{22, nullptr, "GetState_2" },
-            FunctionInfo{22, nullptr, "PutFrameRaw" },
-            FunctionInfo{23, nullptr, "GetAllowedChannels" },
-            FunctionInfo{23, nullptr, "CancelGetFrame" },
-            FunctionInfo{24, nullptr, "AddIe" },
-            FunctionInfo{24, nullptr, "CreateRxEntry" },
-            FunctionInfo{25, nullptr, "DeleteIe" },
-            FunctionInfo{25, nullptr, "DeleteRxEntry" },
-            FunctionInfo{26, nullptr, "PutFrameRaw" },
-            FunctionInfo{26, nullptr, "AddEthertypeToRxEntry" },
-            FunctionInfo{27, nullptr, "CancelGetFrame" },
-            FunctionInfo{27, nullptr, "DeleteEthertypeFromRxEntry" },
-            FunctionInfo{28, nullptr, "CreateRxEntry" },
-            FunctionInfo{28, nullptr, "AddMatchingDataToRxEntry" },
-            FunctionInfo{29, nullptr, "DeleteRxEntry" },
-            FunctionInfo{29, nullptr, "RemoveMatchingDataFromRxEntry" },
-            FunctionInfo{30, nullptr, "AddEthertypeToRxEntry" },
-            FunctionInfo{30, nullptr, "GetScanResult_2" },
-            FunctionInfo{31, nullptr, "DeleteEthertypeFromRxEntry" },
-            FunctionInfo{31, nullptr, "PutActionFrameOneShot" },
-            FunctionInfo{32, nullptr, "AddMatchingDataToRxEntry" },
-            FunctionInfo{32, nullptr, "SetActionFrameWithBeacon" },
-            FunctionInfo{33, nullptr, "RemoveMatchingDataFromRxEntry" },
-            FunctionInfo{33, nullptr, "CancelActionFrameWithBeacon" },
-            FunctionInfo{34, nullptr, "GetScanResult_2" },
-            FunctionInfo{34, nullptr, "CreateRxEntryForActionFrame" },
-            FunctionInfo{35, nullptr, "PutActionFrameOneShot" },
-            FunctionInfo{35, nullptr, "DeleteRxEntryForActionFrame" },
-            FunctionInfo{36, nullptr, "SetActionFrameWithBeacon" },
-            FunctionInfo{36, nullptr, "AddSubtypeToRxEntryForActionFrame" },
-            FunctionInfo{37, nullptr, "CancelActionFrameWithBeacon" },
-            FunctionInfo{37, nullptr, "DeleteSubtypeFromRxEntryForActionFrame" },
-            FunctionInfo{38, nullptr, "CreateRxEntryForActionFrame" },
-            FunctionInfo{38, nullptr, "CancelGetActionFrame" },
-            FunctionInfo{39, nullptr, "DeleteRxEntryForActionFrame" },
-            FunctionInfo{39, nullptr, "GetRssi_2" },
-            FunctionInfo{40, nullptr, "AddSubtypeToRxEntryForActionFrame" },
-            FunctionInfo{40, nullptr, "SetMaxAssociationNumber" },
-            FunctionInfo{41, nullptr, "DeleteSubtypeFromRxEntryForActionFrame" },
-            FunctionInfo{41, nullptr, "Cmd41" },
-            FunctionInfo{42, nullptr, "CancelGetActionFrame" },
-            FunctionInfo{42, nullptr, "Cmd42" },
-            FunctionInfo{43, nullptr, "GetRssi_2" },
-            FunctionInfo{43, nullptr, "Cmd43" },
-            FunctionInfo{44, nullptr, "SetMaxAssociationNumber" },
-            FunctionInfo{45, nullptr, "OpenLcsMasterMode" },
-            FunctionInfo{46, nullptr, "CloseLcsMasterMode" },
-            FunctionInfo{47, nullptr, "OpenLcsClientMode" },
-            FunctionInfo{48, nullptr, "CloseLcsClientMode" },
-            FunctionInfo{49, nullptr, "GetChannelStats" },
-            FunctionInfo{50, nullptr, "Cmd50" },
-            FunctionInfo{51, nullptr, "Cmd51" },
-            FunctionInfo{52, nullptr, "Cmd52" },
+            { 0, nullptr, "OpenMasterMode" },
+            { 0, nullptr, "OpenMode_2" },
+            { 1, nullptr, "CloseMasterMode" },
+            { 1, nullptr, "CloseMode_2" },
+            { 2, nullptr, "OpenClientMode" },
+            { 2, nullptr, "GetMacAddress_2" },
+            { 3, nullptr, "CloseClientMode" },
+            { 3, nullptr, "CreateBss" },
+            { 4, nullptr, "OpenSpectatorMode" },
+            { 4, nullptr, "DestroyBss" },
+            { 5, nullptr, "CloseSpectatorMode" },
+            { 5, nullptr, "StartScan_2" },
+            { 6, nullptr, "GetMacAddress_2" },
+            { 6, nullptr, "StopScan_2" },
+            { 7, nullptr, "CreateBss" },
+            { 7, nullptr, "Connect_2" },
+            { 8, nullptr, "DestroyBss" },
+            { 8, nullptr, "CancelConnect_2" },
+            { 9, nullptr, "StartScan_2" },
+            { 9, nullptr, "Join" },
+            { 10, nullptr, "StopScan_2" },
+            { 10, nullptr, "CancelJoin" },
+            { 11, nullptr, "Connect_2" },
+            { 11, nullptr, "Disconnect_2" },
+            { 12, nullptr, "CancelConnect_2" },
+            { 12, nullptr, "SetBeaconLostCount" },
+            { 13, nullptr, "Join" },
+            { 13, nullptr, "GetSystemEvent_2" },
+            { 14, nullptr, "CancelJoin" },
+            { 14, nullptr, "GetConnectionStatus_2" },
+            { 15, nullptr, "Disconnect_2" },
+            { 15, nullptr, "GetClientStatus" },
+            { 16, nullptr, "SetBeaconLostCount" },
+            { 16, nullptr, "GetBssIndicationEvent" },
+            { 17, nullptr, "GetSystemEvent_2" },
+            { 17, nullptr, "GetBssIndicationInfo" },
+            { 18, nullptr, "GetConnectionStatus_2" },
+            { 18, nullptr, "GetState_2" },
+            { 19, nullptr, "GetClientStatus" },
+            { 19, nullptr, "GetAllowedChannels" },
+            { 20, nullptr, "GetBssIndicationEvent" },
+            { 20, nullptr, "AddIe" },
+            { 21, nullptr, "GetBssIndicationInfo" },
+            { 21, nullptr, "DeleteIe" },
+            { 22, nullptr, "GetState_2" },
+            { 22, nullptr, "PutFrameRaw" },
+            { 23, nullptr, "GetAllowedChannels" },
+            { 23, nullptr, "CancelGetFrame" },
+            { 24, nullptr, "AddIe" },
+            { 24, nullptr, "CreateRxEntry" },
+            { 25, nullptr, "DeleteIe" },
+            { 25, nullptr, "DeleteRxEntry" },
+            { 26, nullptr, "PutFrameRaw" },
+            { 26, nullptr, "AddEthertypeToRxEntry" },
+            { 27, nullptr, "CancelGetFrame" },
+            { 27, nullptr, "DeleteEthertypeFromRxEntry" },
+            { 28, nullptr, "CreateRxEntry" },
+            { 28, nullptr, "AddMatchingDataToRxEntry" },
+            { 29, nullptr, "DeleteRxEntry" },
+            { 29, nullptr, "RemoveMatchingDataFromRxEntry" },
+            { 30, nullptr, "AddEthertypeToRxEntry" },
+            { 30, nullptr, "GetScanResult_2" },
+            { 31, nullptr, "DeleteEthertypeFromRxEntry" },
+            { 31, nullptr, "PutActionFrameOneShot" },
+            { 32, nullptr, "AddMatchingDataToRxEntry" },
+            { 32, nullptr, "SetActionFrameWithBeacon" },
+            { 33, nullptr, "RemoveMatchingDataFromRxEntry" },
+            { 33, nullptr, "CancelActionFrameWithBeacon" },
+            { 34, nullptr, "GetScanResult_2" },
+            { 34, nullptr, "CreateRxEntryForActionFrame" },
+            { 35, nullptr, "PutActionFrameOneShot" },
+            { 35, nullptr, "DeleteRxEntryForActionFrame" },
+            { 36, nullptr, "SetActionFrameWithBeacon" },
+            { 36, nullptr, "AddSubtypeToRxEntryForActionFrame" },
+            { 37, nullptr, "CancelActionFrameWithBeacon" },
+            { 37, nullptr, "DeleteSubtypeFromRxEntryForActionFrame" },
+            { 38, nullptr, "CreateRxEntryForActionFrame" },
+            { 38, nullptr, "CancelGetActionFrame" },
+            { 39, nullptr, "DeleteRxEntryForActionFrame" },
+            { 39, nullptr, "GetRssi_2" },
+            { 40, nullptr, "AddSubtypeToRxEntryForActionFrame" },
+            { 40, nullptr, "SetMaxAssociationNumber" },
+            { 41, nullptr, "DeleteSubtypeFromRxEntryForActionFrame" },
+            { 41, nullptr, "Cmd41" },
+            { 42, nullptr, "CancelGetActionFrame" },
+            { 42, nullptr, "Cmd42" },
+            { 43, nullptr, "GetRssi_2" },
+            { 43, nullptr, "Cmd43" },
+            { 44, nullptr, "SetMaxAssociationNumber" },
+            { 45, nullptr, "OpenLcsMasterMode" },
+            { 46, nullptr, "CloseLcsMasterMode" },
+            { 47, nullptr, "OpenLcsClientMode" },
+            { 48, nullptr, "CloseLcsClientMode" },
+            { 49, nullptr, "GetChannelStats" },
+            { 50, nullptr, "Cmd50" },
+            { 51, nullptr, "Cmd51" },
+            { 52, nullptr, "Cmd52" },
         };
         RegisterHandlers(functions);
     }
@@ -126,7 +126,7 @@ public:
         : ServiceFramework{system_, "wlan:lg"}
     {
         static const FunctionInfo functions[] = {
-            FunctionInfo{0, nullptr, "GetFrameRaw" },
+            { 0, nullptr, "GetFrameRaw" },
         };
         RegisterHandlers(functions);
     }
@@ -138,7 +138,7 @@ public:
         : ServiceFramework{system_, "wlan:lga"}
     {
         static const FunctionInfo functions[] = {
-            FunctionInfo{0, nullptr, "GetActionFrame" },
+            { 0, nullptr, "GetActionFrame" },
         };
         RegisterHandlers(functions);
     }
@@ -150,7 +150,7 @@ public:
         : ServiceFramework{system_, "wlan:sg"}
     {
         static const FunctionInfo functions[] = {
-            FunctionInfo{0, nullptr, "GetFrameRaw" },
+            { 0, nullptr, "GetFrameRaw" },
         };
         RegisterHandlers(functions);
     }
@@ -162,19 +162,19 @@ public:
         : ServiceFramework{system_, "wlan:soc"}
     {
         static const FunctionInfo functions[] = {
-            FunctionInfo{0, nullptr, "PutFrameRaw_2" },
-            FunctionInfo{1, nullptr, "CancelGetFrame_2" },
-            FunctionInfo{2, nullptr, "CreateRxEntry_2" },
-            FunctionInfo{3, nullptr, "DeleteRxEntry_2" },
-            FunctionInfo{4, nullptr, "AddEthertypeToRxEntry_2" },
-            FunctionInfo{5, nullptr, "DeleteEthertypeFromRxEntry_2" },
-            FunctionInfo{6, nullptr, "GetMacAddress_3" },
-            FunctionInfo{7, nullptr, "SwitchTsfTimerFunction" },
-            FunctionInfo{8, nullptr, "GetDeltaTimeBetweenSystemAndTsf" },
-            FunctionInfo{9, nullptr, "RegisterSharedMemory" },
-            FunctionInfo{10, nullptr, "UnregisterSharedMemory" },
-            FunctionInfo{11, nullptr, "EnableSharedMemory" },
-            FunctionInfo{12, nullptr, "SetMulticastFilter" },
+            { 0, nullptr, "PutFrameRaw_2" },
+            { 1, nullptr, "CancelGetFrame_2" },
+            { 2, nullptr, "CreateRxEntry_2" },
+            { 3, nullptr, "DeleteRxEntry_2" },
+            { 4, nullptr, "AddEthertypeToRxEntry_2" },
+            { 5, nullptr, "DeleteEthertypeFromRxEntry_2" },
+            { 6, nullptr, "GetMacAddress_3" },
+            { 7, nullptr, "SwitchTsfTimerFunction" },
+            { 8, nullptr, "GetDeltaTimeBetweenSystemAndTsf" },
+            { 9, nullptr, "RegisterSharedMemory" },
+            { 10, nullptr, "UnregisterSharedMemory" },
+            { 11, nullptr, "EnableSharedMemory" },
+            { 12, nullptr, "SetMulticastFilter" },
         };
         RegisterHandlers(functions);
     }
@@ -186,34 +186,34 @@ public:
         : ServiceFramework{system_, "wlan:dtc"}
     {
         static const FunctionInfo functions[] = {
-            FunctionInfo{0, nullptr, "Cmd0" },
-            FunctionInfo{1, nullptr, "Cmd1" },
-            FunctionInfo{2, nullptr, "Cmd2" },
-            FunctionInfo{3, nullptr, "Cmd3" },
-            FunctionInfo{4, nullptr, "Cmd4" },
-            FunctionInfo{5, nullptr, "Cmd5" },
-            FunctionInfo{6, nullptr, "Cmd6" },
-            FunctionInfo{7, nullptr, "Cmd7" },
-            FunctionInfo{8, nullptr, "Cmd8" },
-            FunctionInfo{9, nullptr, "Cmd9" },
-            FunctionInfo{10, nullptr, "Cmd10" },
-            FunctionInfo{11, nullptr, "Cmd11" },
-            FunctionInfo{12, nullptr, "Cmd12" },
-            FunctionInfo{13, nullptr, "Cmd13" },
-            FunctionInfo{14, nullptr, "Cmd14" },
-            FunctionInfo{15, nullptr, "Cmd15" },
-            FunctionInfo{16, nullptr, "Cmd16" },
-            FunctionInfo{17, nullptr, "Cmd17" },
-            FunctionInfo{18, nullptr, "Cmd18" },
-            FunctionInfo{19, nullptr, "Cmd19" },
-            FunctionInfo{20, nullptr, "Cmd20" },
-            FunctionInfo{21, nullptr, "Cmd21" },
-            FunctionInfo{22, nullptr, "Cmd22" },
-            FunctionInfo{23, nullptr, "Cmd23" },
-            FunctionInfo{24, nullptr, "Cmd24" },
-            FunctionInfo{25, nullptr, "Cmd25" },
-            FunctionInfo{26, nullptr, "Cmd26" },
-            FunctionInfo{27, nullptr, "Cmd27" },
+            { 0, nullptr, "Cmd0" },
+            { 1, nullptr, "Cmd1" },
+            { 2, nullptr, "Cmd2" },
+            { 3, nullptr, "Cmd3" },
+            { 4, nullptr, "Cmd4" },
+            { 5, nullptr, "Cmd5" },
+            { 6, nullptr, "Cmd6" },
+            { 7, nullptr, "Cmd7" },
+            { 8, nullptr, "Cmd8" },
+            { 9, nullptr, "Cmd9" },
+            { 10, nullptr, "Cmd10" },
+            { 11, nullptr, "Cmd11" },
+            { 12, nullptr, "Cmd12" },
+            { 13, nullptr, "Cmd13" },
+            { 14, nullptr, "Cmd14" },
+            { 15, nullptr, "Cmd15" },
+            { 16, nullptr, "Cmd16" },
+            { 17, nullptr, "Cmd17" },
+            { 18, nullptr, "Cmd18" },
+            { 19, nullptr, "Cmd19" },
+            { 20, nullptr, "Cmd20" },
+            { 21, nullptr, "Cmd21" },
+            { 22, nullptr, "Cmd22" },
+            { 23, nullptr, "Cmd23" },
+            { 24, nullptr, "Cmd24" },
+            { 25, nullptr, "Cmd25" },
+            { 26, nullptr, "Cmd26" },
+            { 27, nullptr, "Cmd27" },
         };
         RegisterHandlers(functions);
     }
@@ -225,8 +225,8 @@ public:
         : ServiceFramework{system_, "wlan:p"}
     {
         static const FunctionInfo functions[] = {
-            FunctionInfo{0, nullptr, "CreateWirelessCommunicationService" },
-            FunctionInfo{1, nullptr, "CreatePrivateWirelessCommunicationService" },
+            { 0, nullptr, "CreateWirelessCommunicationService" },
+            { 1, nullptr, "CreatePrivateWirelessCommunicationService" },
         };
         RegisterHandlers(functions);
     }
@@ -238,7 +238,7 @@ public:
         : ServiceFramework{system_, "wlan:nd"}
     {
         static const FunctionInfo functions[] = {
-            FunctionInfo{0, nullptr, "CreateDriverService" },
+            { 0, nullptr, "CreateDriverService" },
         };
         RegisterHandlers(functions);
     }

tools/README.md

@@ -8,7 +8,7 @@ Tools for Eden and other subprojects. When adding new scripts please use `#!/bin
 
 ## Binaries
 
-- `maxwell-spirv`: Converts Maxwell shaders (dumped from `.ash` files) into SPIR-V code sent to stdout.
+- `maxwell-spirv`: Converts Maxwell shaders (dumped from `.ash` files) into SPIR-V code (emitted into STDOUT).
 - `maxwell-disas`: Dumb raw Maxwell disassembler.
 - `maxwell-ir`: Dump generated IR of Maxwell shaders.