2026-09-25 16:58:17

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

docs/DesignOverview.md

@@ -1,6 +1,6 @@
 # Design Overview
 
-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.
+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.
 
 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/README.md

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

docs/SubsystemHLE.md

@@ -1,4 +1,6 @@
-# HOS Kernel
+# Subsystem: HLE
+
+## 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.
 
@@ -29,3 +31,42 @@ 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"}
+        );
+    }
+};
+```

src/common/sparse_large_vector.cpp

@@ -8,14 +8,7 @@
 #ifdef _WIN32
 #include <windows.h>
 #include <mutex>
-#include <algorithm>
-#include <vector>
-#endif
-
-#include <cerrno>
-#include <cstring>
-
-#ifndef _WIN32
+#else
 #include <sys/mman.h>
 #endif
 
@@ -26,60 +19,54 @@
 namespace Common {
 
 #ifdef _WIN32
+static std::vector<std::pair<u64, u64>> vector_regions {};
 
-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;
-}
-
+// Workaround for handling non-commited memory accessed by Dynarmic; usually result of an error
 static LONG WINAPI FakePageFaultHandler(PEXCEPTION_POINTERS info) {
-    if (info->ExceptionRecord->ExceptionCode != EXCEPTION_ACCESS_VIOLATION) {
+    DWORD code = info->ExceptionRecord->ExceptionCode;
+    u64 exception_addr = reinterpret_cast<u64>(info->ExceptionRecord->ExceptionAddress);
+
+    if (code != EXCEPTION_ACCESS_VIOLATION) {
+        // Not our problem
         return EXCEPTION_CONTINUE_SEARCH;
     }
 
-    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;
+    u64 addr = 0, addr2 = 0;
 
-    u64 addr = 0;
-    u64 addr2 = 0;
+    for (auto region: vector_regions) {
+        auto addr_shifted = exception_addr >> HostPageBits;
+        if (region.first <= addr_shifted && addr_shifted <= region.second) {
+            addr = addr_shifted;
+        }
 
-    {
-        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;
+        // 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;
         }
     }
 
     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!", fault_addr);
+    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);
 
-    if (addr != 0 && !CommitVectorPage(addr << HostPageBits, is_write)) {
-        return EXCEPTION_CONTINUE_SEARCH;
+    // Commit this region
+    if (addr != 0) {
+        if (!CommitVectorPage(addr << HostPageBits, false)) {
+            return EXCEPTION_CONTINUE_SEARCH;
+        }
     }
-    if (addr2 != 0 && !CommitVectorPage(addr2 << HostPageBits, is_write)) {
-        return EXCEPTION_CONTINUE_SEARCH;
+    // Commit next region if needed
+    if (addr2 != 0) {
+        if (!CommitVectorPage(addr2 << HostPageBits, false)) {
+            return EXCEPTION_CONTINUE_SEARCH;
+        }
     }
 
     return EXCEPTION_CONTINUE_EXECUTION;
@@ -87,31 +74,23 @@ static LONG WINAPI FakePageFaultHandler(PEXCEPTION_POINTERS info) {
 
 bool CommitVectorPage(uintptr_t addr, bool write) noexcept {
     MEMORY_BASIC_INFORMATION info {};
-    const auto res = VirtualQuery(reinterpret_cast<void*>(addr), &info, sizeof(info));
-    const DWORD perm = write ? PAGE_READWRITE : PAGE_READONLY;
-
+    auto res = VirtualQuery(reinterpret_cast<void*>(addr), &info, sizeof(info));
     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} (state {:#x})", addr, info.State);
+        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);
         return false;
     }
 
-    if (VirtualAlloc(reinterpret_cast<LPVOID>(addr), HostPageSize, MEM_COMMIT, perm) == nullptr) {
+    auto perm = write ? PAGE_READWRITE : PAGE_READONLY;
+    void* res2 = VirtualAlloc(reinterpret_cast<LPVOID>(addr), HostPageSize, MEM_COMMIT, perm);
+    if (res2 == nullptr) {
         LOG_ERROR(HW_Memory, "Failed to commit large buffer region at {:#x}, error {}", addr, GetLastError());
         return false;
     }
 
     return true;
 }
-
 #endif
 
 #ifndef MAP_NOCORE
@@ -123,103 +102,57 @@ bool CommitVectorPage(uintptr_t addr, bool write) noexcept {
 
 void DecommitVectorPage(uintptr_t base) noexcept {
 #if defined(_WIN32)
-    if (!VirtualFree(reinterpret_cast<LPVOID>(base), HostPageSize, MEM_DECOMMIT)) {
-        LOG_WARNING(HW_Memory, "VirtualFree(MEM_DECOMMIT) failed at {:#x}, error {}", base, GetLastError());
-    }
+    VirtualFree(reinterpret_cast<LPVOID>(base), HostPageSize, MEM_DECOMMIT);
 #elif defined(__linux__)
-    if (madvise(reinterpret_cast<void*>(base), HostPageSize, MADV_DONTNEED) != 0) {
-        LOG_WARNING(HW_Memory, "madvise(MADV_DONTNEED) failed at {:#x}: {}", base, std::strerror(errno));
-    }
+    // Linux's MADV_DONTNEED zeros out pages for us
+    madvise(reinterpret_cast<void*>(base), HostPageSize, MADV_DONTNEED);
 #else
-    if (madvise(reinterpret_cast<void*>(base), HostPageSize, MADV_FREE) != 0) {
-        LOG_WARNING(HW_Memory, "madvise(MADV_FREE) failed at {:#x}: {}", base, std::strerror(errno));
-    }
+    madvise(reinterpret_cast<void*>(base), HostPageSize, MADV_FREE);
     std::memset(reinterpret_cast<void*>(base), 0, HostPageSize);
 #endif
 }
 
 void* AllocateMemoryPages(std::size_t size) noexcept {
-    if (size == 0) {
-        return nullptr;
-    }
-
-    const auto page = HostPageSize;
-    if (size % page != 0) {
+    if (auto page = HostPageSize; 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) {
-        {
-            std::lock_guard lock(GetVectorRegionsMutex());
-            GetVectorRegions().push_back({
-                reinterpret_cast<u64>(base) >> HostPageBits,
-                (reinterpret_cast<u64>(base) + size) >> HostPageBits,
-            });
-        }
+        vector_regions.emplace_back(reinterpret_cast<u64>(base), reinterpret_cast<u64>(base) + size);
 
         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
-    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) {
+    void* base = mmap(nullptr, size, PROT_READ, MAP_ANON | MAP_PRIVATE | MAP_NOCORE, -1, 0);
+    if (base == MAP_FAILED)
         base = nullptr;
-    }
-#ifdef MADV_HUGEPAGE
-    if (base != nullptr) {
-        madvise(base, size, MADV_HUGEPAGE);
-    }
+    ASSERT_MSG(base, "Failed to allocate {:#x} sized region with error {}", size, strerror(errno));
 #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 (base == nullptr) {
-        return;
-    }
-
-    if (const auto page = HostPageSize; size % page != 0) {
+    if (auto page = HostPageSize; size % page != 0) {
         size = AlignUp(size, page);
     }
-
+    if (!base)
+        return;
 #ifdef _WIN32
-    {
-        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());
-    }
+    ASSERT(VirtualFree(base, 0, MEM_RELEASE));
 #else
-    if (munmap(base, size) != 0) {
-        LOG_ERROR(HW_Memory, "munmap failed: {}", std::strerror(errno));
-    }
+    ASSERT(munmap(base, size) == 0);
 #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,14 +7,10 @@
 
 #pragma once
 
-#include <array>
 #include <atomic>
 #include <bit>
-#include <cerrno>
-#include <cstdlib>
-#include <cstring>
-#include <memory>
-#include <type_traits>
+#include <utility>
+#include <vector>
 
 #ifndef _WIN32
 #include <unistd.h>
@@ -32,9 +28,9 @@ constexpr u64 HostPageBits = 12;
 constexpr u64 HostPageMask = ~(HostPageSize - 1);
 bool CommitVectorPage(uintptr_t addr, bool write) noexcept;
 #else
-inline const u64 HostPageSize = static_cast<u64>(sysconf(_SC_PAGESIZE));
-inline const u64 HostPageBits = std::countr_zero(HostPageSize);
-inline const u64 HostPageMask = ~(HostPageSize - 1);
+const u64 HostPageSize = sysconf(_SC_PAGESIZE);
+const u64 HostPageBits = std::countr_zero(HostPageSize);
+const u64 HostPageMask = ~(HostPageSize - 1);
 #endif
 
 void* AllocateMemoryPages(std::size_t size) noexcept;
@@ -47,18 +43,20 @@ template <typename T>
     // requires std::is_trivially_copyable_v<T>
 class SparseLargeVector final {
 public:
-    SparseLargeVector() = default;
+    constexpr SparseLargeVector() = default;
 
-    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));
+    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);
     }
 
     ~SparseLargeVector() noexcept {
-        Release();
+        FreeMemoryPages(base_ptr, alloc_size);
     }
 
     SparseLargeVector(const SparseLargeVector&) = delete;
@@ -67,181 +65,145 @@ public:
     SparseLargeVector& operator=(SparseLargeVector&& other) = delete;
 
     void ResizeAndClear(std::size_t count) noexcept {
-        if (count > SIZE_MAX / sizeof(T)) {
-            LOG_CRITICAL(Common_Memory, "SparseLargeVector resize overflow: {} elements", count);
-            return;
+        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);
         }
-        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 (base_ptr == nullptr || index >= size()) [[unlikely]] {
-            LOG_CRITICAL(Common_Memory, "SparseLargeVector RW access out of bounds @ {} (size {})", index, size());
-            std::abort();
+        if (index > alloc_size / sizeof(T)) {
+            UNREACHABLE_MSG("Out of bounds RW access on SparseLargeVector @ {}", 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();
+
+        if (!IsCommittedPage(index)) {
+            CommitPage(index);
         }
         return base_ptr[index];
     }
 
-    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();
-        }
+    /// 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 {
 #ifdef _WIN32
-        if (!IsPageCommitted(static_cast<u64>(index) * sizeof(T))) {
-            return DefaultValue();
+        if (!IsCommittedPage(index)) {
+            return *reinterpret_cast<const T*>(&default_val);
         }
 #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 (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);
+        if (index > alloc_size / sizeof(T)) {
+            LOG_CRITICAL(Common_Memory, "Out of bounds write on SparseLargeVector @ {}", index);
             return;
         }
+        if (!IsCommittedPage(index))
+            CommitPage(index);
         base_ptr[index] = value;
     }
 
     void ZeroRegion(std::size_t start, std::size_t end_) noexcept {
-        if (base_ptr == nullptr || start >= end_) return;
+        u64 base = reinterpret_cast<u64>(&base_ptr[start]);
+        const u64 end = reinterpret_cast<u64>(&base_ptr[end_]);
 
-        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;
+        const u64 end_page = AlignUp(base, HostPageSize);
+        const u64 first_size = (std::min)(end_page, end) - base;
 
-        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 (IsCommittedPage(start)) {
+            std::memset(reinterpret_cast<void*>(base), 0, first_size);
         }
 
-        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);
+        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);
             } else {
-                std::memset(reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(base_ptr) + off), 0, remaining);
+                std::memset(reinterpret_cast<void*>(page), 0, end - page);
             }
         }
     }
 
-    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 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));
             }
         }
     }
 
-    T& GetUnchecked(std::size_t index) noexcept { return base_ptr[index]; }
+    constexpr T& GetUnchecked(size_t index) {
+        return base_ptr[index];
+    }
 
-    [[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); }
+    [[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);
+    }
 
 private:
-    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));
+    [[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);
             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
-        SetPageBit(page_index, true);
-        return true;
+
+        committed_pages[page_index >> 6].fetch_or(1ULL << (page_index & 63), std::memory_order_release);
     }
 
-    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);
-    }
+    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;
 
-    [[nodiscard]] const T& DefaultValue() const noexcept {
-        return *reinterpret_cast<const T*>(&default_val);
+        committed_pages[page_index >> 6].fetch_and(~(1ULL << (page_index & 63)), std::memory_order_release);
+        DecommitVectorPage(page);
     }
 
     std::size_t alloc_size{};
     T* base_ptr{};
-    std::unique_ptr<std::atomic<u64>[]> committed_pages{};
-    alignas(T) const std::array<u8, sizeof(T)> default_val{};
+
+    std::vector<std::atomic<u64>> committed_pages{};
+#ifdef _WIN32
+    const std::array<u8, sizeof(T)> default_val{};
+#endif
 };
 
-} // 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)
+target_link_libraries(core PUBLIC httplib::httplib zstd::zstd frozen::frozen-headers)
 
 if (ENABLE_WEB_SERVICE)
     target_compile_definitions(core PUBLIC ENABLE_WEB_SERVICE)

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

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -13,11 +16,11 @@ IPurchaseEventManager::IPurchaseEventManager(Core::System& system_)
                                                                           "IPurchaseEventManager"} {
     // clang-format off
         static const FunctionInfo functions[] = {
-            {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"},
+            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"}
         };
     // 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[] = {
-            {0, &ISession::SetPerformanceConfiguration, "SetPerformanceConfiguration"},
-            {1, &ISession::GetPerformanceConfiguration, "GetPerformanceConfiguration"},
-            {2, &ISession::SetCpuOverclockEnabled, "SetCpuOverclockEnabled"},
+            FunctionInfo{0, &ISession::SetPerformanceConfiguration, "SetPerformanceConfiguration"},
+            FunctionInfo{1, &ISession::GetPerformanceConfiguration, "GetPerformanceConfiguration"},
+            FunctionInfo{2, &ISession::SetCpuOverclockEnabled, "SetCpuOverclockEnabled"}
         };
         RegisterHandlers(functions);
     }

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

@@ -21,164 +21,154 @@ namespace Service::Audio {
 class IAudioOutManagerForApplet final : public ServiceFramework<IAudioOutManagerForApplet> {
 public:
     explicit IAudioOutManagerForApplet(Core::System& system_)
-        : 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);
+        : 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"}
+        );
     }
 };
 
 class IAudioSnoopManager final : public ServiceFramework<IAudioSnoopManager> {
 public:
     explicit IAudioSnoopManager(Core::System& system_)
-        : 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);
+        : 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"}
+        );
     }
 };
 
 class IAudioInManagerForApplet final : public ServiceFramework<IAudioInManagerForApplet> {
 public:
     explicit IAudioInManagerForApplet(Core::System& system_)
-        : 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);
+        : 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"}
+        );
     }
 };
 
 class IAudioRendererManagerForApplet final : public ServiceFramework<IAudioRendererManagerForApplet> {
 public:
     explicit IAudioRendererManagerForApplet(Core::System& system_)
-        : 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);
+        : 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"}
+        );
     }
 };
 
 class IAudioOutManagerForDebugger final : public ServiceFramework<IAudioOutManagerForDebugger> {
 public:
     explicit IAudioOutManagerForDebugger(Core::System& system_)
-        : ServiceFramework{system_, "audout:d"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "RequestSuspend"},
-            {1, nullptr, "RequestResume"},
-        };
-        // clang-format on
-        RegisterHandlers(functions);
+        : ServiceFramework{system_, "audout:d"} {}
+
+    FunctionInfoBase const* FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key,
+            FunctionInfo{0, nullptr, "RequestSuspend"},
+            FunctionInfo{1, nullptr, "RequestResume"}
+        );
     }
 };
 
 class IAudioInManagerForDebugger final : public ServiceFramework<IAudioInManagerForDebugger> {
 public:
     explicit IAudioInManagerForDebugger(Core::System& system_)
-        : ServiceFramework{system_, "audin:d"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "RequestSuspend"},
-            {1, nullptr, "RequestResume"},
-        };
-        // clang-format on
-        RegisterHandlers(functions);
+        : ServiceFramework{system_, "audin:d"} {}
+
+    FunctionInfoBase const* FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key,
+            FunctionInfo{0, nullptr, "RequestSuspend"},
+            FunctionInfo{1, nullptr, "RequestResume"}
+        );
     }
 };
 
 class IFinalOutputRecorderManagerForDebugger final : public ServiceFramework<IFinalOutputRecorderManagerForDebugger> {
 public:
     explicit IFinalOutputRecorderManagerForDebugger(Core::System& system_)
-        : ServiceFramework{system_, "audrec:d"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "RequestSuspend"},
-            {1, nullptr, "RequestResume"},
-        };
-        // clang-format on
-        RegisterHandlers(functions);
+        : ServiceFramework{system_, "audrec:d"} {}
+
+    FunctionInfoBase const* FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key,
+            FunctionInfo{0, nullptr, "RequestSuspend"},
+            FunctionInfo{1, nullptr, "RequestResume"}
+        );
     }
 };
 
 class IAudioRendererManagerForDebugger final : public ServiceFramework<IAudioRendererManagerForDebugger> {
 public:
     explicit IAudioRendererManagerForDebugger(Core::System& system_)
-        : ServiceFramework{system_, "audren:d"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "RequestSuspend"},
-            {1, nullptr, "RequestResume"},
-        };
-        // clang-format on
-        RegisterHandlers(functions);
+        : ServiceFramework{system_, "audren:d"} {}
+
+    FunctionInfoBase const* FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key,
+            FunctionInfo{0, nullptr, "RequestSuspend"},
+            FunctionInfo{1, nullptr, "RequestResume"}
+        );
     }
 };
 
 class IAudioSystemManagerForApplet final : public ServiceFramework<IAudioSystemManagerForApplet> {
 public:
     explicit IAudioSystemManagerForApplet(Core::System& system_)
-        : 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);
+        : 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"}
+        );
     }
 };
 
 class IAudioSystemManagerForDebugger final : public ServiceFramework<IAudioSystemManagerForDebugger> {
 public:
     explicit IAudioSystemManagerForDebugger(Core::System& system_)
-        : ServiceFramework{system_, "aud:d"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "RequestSuspendAudioForDebug"},
-            {1, nullptr, "RequestResumeAudioForDebug"},
-        };
-        // clang-format on
-        RegisterHandlers(functions);
+        : ServiceFramework{system_, "aud:d"} {}
+
+    FunctionInfoBase const* FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key,
+            FunctionInfo{0, nullptr, "RequestSuspendAudioForDebug"},
+            FunctionInfo{1, nullptr, "RequestResumeAudioForDebug"}
+        );
     }
 };
 

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

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -8,25 +11,23 @@ namespace Service::Audio {
 class IFinalOutputRecorder final : public ServiceFramework<IFinalOutputRecorder> {
 public:
     explicit IFinalOutputRecorder(Core::System& system_)
-        : 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
+        : ServiceFramework{system_, "IFinalOutputRecorder"} {}
 
-        RegisterHandlers(functions);
+    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"}
+        );
     }
 };
 

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[] = {
-            {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+
+            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+
         };
     // clang-format on
     RegisterHandlers(functions);

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

@@ -14,103 +14,95 @@ namespace Service::BPC {
 
 class BPC final : public ServiceFramework<BPC> {
 public:
-    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
+    explicit BPC(Core::System& system_) : ServiceFramework{system_, "bpc"} {}
 
-        RegisterHandlers(functions);
+    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"}
+        );
     }
 };
 
 class BPC_R final : public ServiceFramework<BPC_R> {
 public:
-    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
+    explicit BPC_R(Core::System& system_) : ServiceFramework{system_, "bpc:r"} {}
 
-        RegisterHandlers(functions);
+    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"}
+        );
     }
 };
 
 class BPC_C final : public ServiceFramework<BPC_C> {
 public:
-    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);
+    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"}
+        );
     }
 };
 
 class BPC_B final : public ServiceFramework<BPC_B> {
 public:
-    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);
+    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"}
+        );
     }
 };
 
 class BPC_W final : public ServiceFramework<BPC_W> {
 public:
-    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);
+    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"}
+        );
     }
 };
 
 class BPC_AMS final : public ServiceFramework<BPC_AMS> {
 public:
-    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);
+    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"}
+        );
     }
 };
 

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

@@ -20,26 +20,26 @@ namespace Service::BtDrv {
 class IBluetoothUser final : public ServiceFramework<IBluetoothUser> {
 public:
     explicit IBluetoothUser(Core::System& system_)
-        : 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);
-
+        : ServiceFramework{system_, "bt"}
+        , service_context{system_, "bt"} {
         register_event = service_context.CreateEvent("BT:RegisterEvent");
     }
 
+    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"}
+        );
+    }
+
     ~IBluetoothUser() override {
         service_context.CloseEvent(register_event);
     }
@@ -59,144 +59,142 @@ private:
 
 class IBluetoothDriver final : public ServiceFramework<IBluetoothDriver> {
 public:
-    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
+    explicit IBluetoothDriver(Core::System& system_) : ServiceFramework{system_, "btdrv"} {}
 
-        RegisterHandlers(functions);
+    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"}
+        );
     }
 
 private:

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

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
@@ -17,100 +17,98 @@ namespace Service::BTM {
 
 class IBtm final : public ServiceFramework<IBtm> {
 public:
-    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
+    explicit IBtm(Core::System& system_) : ServiceFramework{system_, "btm"} {}
 
-        RegisterHandlers(functions);
+    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+
+        );
     }
 };
 

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

@@ -20,15 +20,14 @@ namespace Service::Capture {
 
 class IDecoderControlService final : public ServiceFramework<IDecoderControlService> {
 public:
-    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);
+    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"}
+        );
     }
 };
 

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

@@ -17,30 +17,28 @@ namespace Service::ERPT {
 
 class ErrorReportContext final : public ServiceFramework<ErrorReportContext> {
 public:
-    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
+    explicit ErrorReportContext(Core::System& system_) : ServiceFramework{system_, "erpt:c"} {}
 
-        RegisterHandlers(functions);
+    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"}
+        );
     }
 
 private:
@@ -89,16 +87,14 @@ private:
 
 class ErrorReportSession final : public ServiceFramework<ErrorReportSession> {
 public:
-    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
+    explicit ErrorReportSession(Core::System& system_) : ServiceFramework{system_, "erpt:r"} {}
 
-        RegisterHandlers(functions);
+    FunctionInfoBase const* FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key,
+            FunctionInfo{0, nullptr, "OpenReport"},
+            FunctionInfo{1, nullptr, "OpenManager"},
+            FunctionInfo{2, nullptr, "OpenAttachment"}
+        );
     }
 };
 

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

@@ -19,110 +19,109 @@ 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{}) {
@@ -323,83 +322,81 @@ private:
 class NDRM_LU final : public ServiceFramework<NDRM_LU> {
 public:
     explicit NDRM_LU(Core::System& system_)
-        : 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);
+        : 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"}
+        );
     }
 };
 
 class NDRM_LA final : public ServiceFramework<NDRM_LA> {
 public:
     explicit NDRM_LA(Core::System& system_)
-        : 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);
+        : 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"}
+        );
     }
 };
 

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

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -11,36 +14,32 @@ namespace Service::EUPLD {
 
 class ErrorUploadContext final : public ServiceFramework<ErrorUploadContext> {
 public:
-    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
+    explicit ErrorUploadContext(Core::System& system_) : ServiceFramework{system_, "eupld:c"} {}
 
-        RegisterHandlers(functions);
+    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"}
+        );
     }
 };
 
 class ErrorUploadRequest final : public ServiceFramework<ErrorUploadRequest> {
 public:
-    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
+    explicit ErrorUploadRequest(Core::System& system_) : ServiceFramework{system_, "eupld:r"} {}
 
-        RegisterHandlers(functions);
+    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"}
+        );
     }
 };
 

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

@@ -16,30 +16,26 @@ namespace Service::FGM {
 
 class IRequest final : public ServiceFramework<IRequest> {
 public:
-    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
+    explicit IRequest(Core::System& system_) : ServiceFramework{system_, "IRequest"} {}
 
-        RegisterHandlers(functions);
+    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"}
+        );
     }
 };
 
 class FGM final : public ServiceFramework<FGM> {
 public:
-    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
+    explicit FGM(Core::System& system_, const char* name) : ServiceFramework{system_, name} {}
 
-        RegisterHandlers(functions);
+    FunctionInfoBase const* FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key,
+            FunctionInfo{0, &FGM::Initialize, "Initialize"}
+        );
     }
 
 private:
@@ -54,16 +50,14 @@ private:
 
 class FGM_DBG final : public ServiceFramework<FGM_DBG> {
 public:
-    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
+    explicit FGM_DBG(Core::System& system_) : ServiceFramework{system_, "fgm:dbg"} {}
 
-        RegisterHandlers(functions);
+    FunctionInfoBase const* FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key,
+            FunctionInfo{0, nullptr, "Initialize"},
+            FunctionInfo{1, nullptr, "Read"},
+            FunctionInfo{2, nullptr, "Cancel"}
+        );
     }
 };
 

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

@@ -22,128 +22,126 @@ class IFriendService final : public ServiceFramework<IFriendService> {
 public:
     explicit IFriendService(Core::System& system_)
         : ServiceFramework{system_, "IFriendService"}, service_context{system, "IFriendService"} {
-        // 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
-
-        RegisterHandlers(functions);
-
         completion_event = service_context.CreateEvent("IFriendService:CompletionEvent");
     }
 
+    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"}
+        );
+    }
+
     ~IFriendService() override {
         service_context.CloseEvent(completion_event);
     }
@@ -375,21 +373,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"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, &INotificationService::GetEvent, "GetEvent"},
-            {1, &INotificationService::Clear, "Clear"},
-            {2, &INotificationService::Pop, "Pop"}
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-
+        : ServiceFramework{system_, "INotificationService"}, uuid{uuid_}
+        , service_context{system_, "INotificationService"} {
         notification_event = service_context.CreateEvent("INotificationService:NotifyEvent");
     }
 
+    FunctionInfoBase const* FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key,
+            FunctionInfo{0, &INotificationService::GetEvent, "GetEvent"},
+            FunctionInfo{1, &INotificationService::Clear, "Clear"},
+            FunctionInfo{2, &INotificationService::Pop, "Pop"}
+        );
+    }
+
     ~INotificationService() override {
         service_context.CloseEvent(notification_event);
     }
@@ -501,12 +497,13 @@ class IServiceForApplication final : public ServiceFramework<IServiceForApplicat
 public:
     explicit IServiceForApplication(Core::System& system_)
         : ServiceFramework{system_, "nd:app"}
-    {
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "GetReceivableNeighborInfoCountMax"},
-            {10, nullptr, "IsNeighborDetectionEnabled"},
-        };
-        RegisterHandlers(functions);
+    {}
+
+    FunctionInfoBase const* FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key,
+            FunctionInfo{0, nullptr, "GetReceivableNeighborInfoCountMax"},
+            FunctionInfo{10, nullptr, "IsNeighborDetectionEnabled"}
+        );
     }
 };
 
@@ -514,47 +511,48 @@ class IServiceForSystem final : public ServiceFramework<IServiceForSystem> {
 public:
     explicit IServiceForSystem(Core::System& system_)
         : ServiceFramework{system_, "nd:sys"}
-    {
-        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);
+    {}
+
+    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"}
+        );
     }
 };
 

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

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

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

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

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

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

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

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -31,25 +34,25 @@ StaticService::StaticService(Core::System& system_,
       m_time_zone_binary{time->m_time_zone_binary} {
     // clang-format off
         static const FunctionInfo functions[] = {
-            {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"},
+            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"}
         };
     // clang-format on
 

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

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

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

@@ -14,32 +14,29 @@ namespace Service::GRC {
 
 class GRC final : public ServiceFramework<GRC> {
 public:
-    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
+    explicit GRC(Core::System& system_) : ServiceFramework{system_, "grc:c"} {}
 
-        RegisterHandlers(functions);
+    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"}
+        );
     }
 };
 
 class GRC_D final : public ServiceFramework<GRC_D> {
 public:
-    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);
+    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"}
+        );
     }
 };
 

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[] = {
-            {0, C<&IActiveVibrationDeviceList::ActivateVibrationDevice>, "ActivateVibrationDevice"},
+            FunctionInfo{0, C<&IActiveVibrationDeviceList::ActivateVibrationDevice>, "ActivateVibrationDevice"}
         };
     // clang-format on
 

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

@@ -22,13 +22,12 @@ namespace Service::HID {
 class IHidTemporaryServer final : public ServiceFramework<IHidTemporaryServer> {
 public:
     explicit IHidTemporaryServer(Core::System& system_)
-    : ServiceFramework{system_, "hid:tmp"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "GetConsoleSixAxisSensorCalibrationValues"},
-        };
-        // clang-format on
-        RegisterHandlers(functions);
+    : ServiceFramework{system_, "hid:tmp"} {}
+
+    FunctionInfoBase const* FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key,
+            FunctionInfo{0, nullptr, "GetConsoleSixAxisSensorCalibrationValues"}
+        );
     }
     ~IHidTemporaryServer() override = default;
 };
@@ -36,17 +35,16 @@ public:
 class AHID_CD final : public ServiceFramework<AHID_CD> {
 public:
     explicit AHID_CD(Core::System& system_)
-    : 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);
+    : 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"}
+        );
     }
     ~AHID_CD() override = default;
 };
@@ -54,18 +52,17 @@ public:
 class AHID_HDR final : public ServiceFramework<AHID_HDR> {
 public:
     explicit AHID_HDR(Core::System& system_)
-    : 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);
+    : 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"}
+        );
     }
     ~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[] = {
-            {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"},
+            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"},
     };
     // clang-format on
 

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

@@ -21,13 +21,13 @@ public:
         : ServiceFramework{system_, "I2CSession"}
     {
         static const FunctionInfo functions[] = {
-            {0, nullptr, "SendOld"},
-            {1, nullptr, "ReceiveOld"},
-            {2, nullptr, "ExecuteCommandListOld"},
-            {10, C<&I2CSession::Send>, "Send"},
-            {11, nullptr, "Receive"},
-            {12, nullptr, "ExecuteCommandList"},
-            {13, nullptr, "SetRetryPolicy"},
+            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"}
         };
         RegisterHandlers(functions);
     }
@@ -49,11 +49,11 @@ public:
         : ServiceFramework{system_, "i2c"}
     {
         static const FunctionInfo functions[] = {
-            {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"},
+            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"}
         };
         RegisterHandlers(functions);
     }

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

@@ -37,18 +37,6 @@ 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();
@@ -59,6 +47,15 @@ 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());
@@ -258,14 +255,12 @@ private:
 
 class JITU final : public ServiceFramework<JITU> {
 public:
-    explicit JITU(Core::System& system_) : ServiceFramework{system_, "jit:u"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, C<&JITU::CreateJitEnvironment>, "CreateJitEnvironment"},
-        };
-        // clang-format on
+    explicit JITU(Core::System& system_) : ServiceFramework{system_, "jit:u"} {}
 
-        RegisterHandlers(functions);
+    FunctionInfoBase const* FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key,
+            FunctionInfo{0, C<&JITU::CreateJitEnvironment>, "CreateJitEnvironment"}
+        );
     }
 
 private:

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

@@ -18,43 +18,41 @@ namespace Service::LBL {
 
 class LBL final : public ServiceFramework<LBL> {
 public:
-    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
+    explicit LBL(Core::System& system_) : ServiceFramework{system_, "lbl"} {}
 
-        RegisterHandlers(functions);
+    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"}
+        );
     }
 
 private:

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

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

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

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -11,9 +14,9 @@ ISfMonitorService::ISfMonitorService(Core::System& system_)
     : ServiceFramework{system_, "ISfMonitorService"} {
     // clang-format off
         static const FunctionInfo functions[] = {
-            {0, C<&ISfMonitorService::Initialize>, "Initialize"},
-            {288, C<&ISfMonitorService::GetGroupInfo>, "GetGroupInfo"},
-            {320, nullptr, "GetLinkLevel"},
+            FunctionInfo{0, C<&ISfMonitorService::Initialize>, "Initialize"},
+            FunctionInfo{288, C<&ISfMonitorService::GetGroupInfo>, "GetGroupInfo"},
+            FunctionInfo{320, nullptr, "GetLinkLevel"}
         };
     // clang-format on
 

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

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -8,24 +11,24 @@ namespace Service::LDN {
 ISfService::ISfService(Core::System& system_) : ServiceFramework{system_, "ISfService"} {
     // clang-format off
     static const FunctionInfo functions[] = {
-            {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"},
+            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"},
     };
     // clang-format on
 

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

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -11,19 +14,19 @@ ISfServiceMonitor::ISfServiceMonitor(Core::System& system_)
     : ServiceFramework{system_, "ISfServiceMonitor"} {
     // clang-format off
         static const FunctionInfo functions[] = {
-            {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"},
+            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"}
         };
     // clang-format on
 

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

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -10,36 +13,36 @@ ISystemLocalCommunicationService::ISystemLocalCommunicationService(Core::System&
     : ServiceFramework{system_, "ISystemLocalCommunicationService"} {
     // clang-format off
         static const FunctionInfo functions[] = {
-            {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"},
+            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"}
         };
     // 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[] = {
-            {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"},
+            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"}
         };
     // clang-format on
 

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

@@ -12,47 +12,41 @@ namespace Service::LDR {
 
 class DebugMonitor final : public ServiceFramework<DebugMonitor> {
 public:
-    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
+    explicit DebugMonitor(Core::System& system_) : ServiceFramework{system_, "ldr:dmnt"} {}
 
-        RegisterHandlers(functions);
+    FunctionInfoBase const* FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key,
+            FunctionInfo{0, nullptr, "SetProgramArgument"},
+            FunctionInfo{1, nullptr, "FlushArguments"},
+            FunctionInfo{2, nullptr, "GetProcessModuleInfo"}
+        );
     }
 };
 
 class ProcessManager final : public ServiceFramework<ProcessManager> {
 public:
-    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
+    explicit ProcessManager(Core::System& system_) : ServiceFramework{system_, "ldr:pm"} {}
 
-        RegisterHandlers(functions);
+    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"}
+        );
     }
 };
 
 class Shell final : public ServiceFramework<Shell> {
 public:
-    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
+    explicit Shell(Core::System& system_) : ServiceFramework{system_, "ldr:shel"} {}
 
-        RegisterHandlers(functions);
+    FunctionInfoBase const* FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key,
+            FunctionInfo{0, nullptr, "SetProgramArgument"},
+            FunctionInfo{1, nullptr, "FlushArguments"}
+        );
     }
 };
 

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

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

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
@@ -14,49 +14,47 @@ namespace Service::Migration {
 
 class MIG_USR final : public ServiceFramework<MIG_USR> {
 public:
-    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
+    explicit MIG_USR(Core::System& system_) : ServiceFramework{system_, "mig:usr"} {}
 
-        RegisterHandlers(functions);
+    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+
+        );
     }
 };
 

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

@@ -24,49 +24,46 @@ 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_} {
-        // 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
-
-        RegisterHandlers(functions);
-
-        m_set_sys = system.ServiceManager().GetService<Service::Set::ISystemSettingsServer>(
-            "set:sys", true);
+    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);
     }
 
+    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"}
+        );
+    }
+
 private:
     Result IsUpdated(Out<bool> out_is_updated, SourceFlag source_flag) {
         LOG_DEBUG(Service_Mii, "called with source_flag={}", source_flag);
@@ -324,27 +321,25 @@ std::shared_ptr<MiiManager> IStaticService::GetMiiManager() {
 
 class IImageDatabaseService final : public ServiceFramework<IImageDatabaseService> {
 public:
-    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
+    explicit IImageDatabaseService(Core::System& system_) : ServiceFramework{system_, "miiimg"} {}
 
-        RegisterHandlers(functions);
+    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"}
+        );
     }
 
 private:

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

@@ -49,21 +49,19 @@ public:
 
 class MM_U final : public ServiceFramework<MM_U> {
 public:
-    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
+    explicit MM_U(Core::System& system_) : ServiceFramework{system_, "mm:u"} {}
 
-        RegisterHandlers(functions);
+    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"}
+        );
     }
 
 private:

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

@@ -14,15 +14,13 @@ namespace Service::MNPP {
 
 class MNPP_APP final : public ServiceFramework<MNPP_APP> {
 public:
-    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
+    explicit MNPP_APP(Core::System& system_) : ServiceFramework{system_, "mnpp:app"} {}
 
-        RegisterHandlers(functions);
+    FunctionInfoBase const* FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key,
+            FunctionInfo{0, &MNPP_APP::Cmd0, "Cmd0"},
+            FunctionInfo{1, &MNPP_APP::Cmd1, "Cmd1"}
+        );
     }
 
 private:
@@ -43,34 +41,32 @@ private:
 
 class MNPP_SYS final : public ServiceFramework<MNPP_SYS> {
 public:
-    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);
+    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"}
+        );
     }
 };
 
 class MNPP_WEB final : public ServiceFramework<MNPP_WEB> {
 public:
-    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);
+    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"}
+        );
     }
 };
 

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

@@ -24,33 +24,31 @@ namespace Service::NCM {
 class ILocationResolver final : public ServiceFramework<ILocationResolver> {
 public:
     explicit ILocationResolver(Core::System& system_, FileSys::StorageId 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
+        : ServiceFramework{system_, "ILocationResolver"}, storage{id} {}
 
-        RegisterHandlers(functions);
+    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"}
+        );
     }
 
 private:
@@ -60,60 +58,54 @@ private:
 class IRegisteredLocationResolver final : public ServiceFramework<IRegisteredLocationResolver> {
 public:
     explicit IRegisteredLocationResolver(Core::System& system_)
-        : 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
+        : ServiceFramework{system_, "IRegisteredLocationResolver"} {}
 
-        RegisterHandlers(functions);
+    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"}
+        );
     }
 };
 
 class IAddOnContentLocationResolver final : public ServiceFramework<IAddOnContentLocationResolver> {
 public:
     explicit IAddOnContentLocationResolver(Core::System& system_)
-        : 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
+        : ServiceFramework{system_, "IAddOnContentLocationResolver"} {}
 
-        RegisterHandlers(functions);
+    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"}
+        );
     }
 };
 
 class IContentStorage final : public ServiceFramework<IContentStorage> {
 public:
     explicit IContentStorage(Core::System& system_, FileSys::StorageId 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
+        : ServiceFramework{system_, "IContentStorage"}, storage{id} {}
 
-        RegisterHandlers(functions);
+    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"}
+        );
     }
 
 private:
@@ -258,17 +250,15 @@ private:
 class IContentMetaDatabase final : public ServiceFramework<IContentMetaDatabase> {
 public:
     explicit IContentMetaDatabase(Core::System& system_, FileSys::StorageId 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
+        : ServiceFramework{system_, "IContentMetaDatabase"}, storage{id} {}
 
-        RegisterHandlers(functions);
+    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"}
+        );
     }
 
 private:
@@ -362,45 +352,41 @@ private:
 
 class LR final : public ServiceFramework<LR> {
 public:
-    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
+    explicit LR(Core::System& system_) : ServiceFramework{system_, "lr"} {}
 
-        RegisterHandlers(functions);
+    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"}
+        );
     }
 };
 
 class NCM final : public ServiceFramework<NCM> {
 public:
-    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
+    explicit NCM(Core::System& system_) : ServiceFramework{system_, "ncm"} {}
 
-        RegisterHandlers(functions);
+    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"}
+        );
     }
 
 private:
@@ -433,7 +419,7 @@ public:
         : ServiceFramework{system_, "ncm:v"}
     {
         static const FunctionInfo functions[] = {
-            {0, nullptr, "GetSystemVersion"},
+            FunctionInfo{0, nullptr, "GetSystemVersion"}
         };
         RegisterHandlers(functions);
     }

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

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

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

@@ -15,7 +15,6 @@ 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"},
@@ -42,10 +41,8 @@ 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);
     }
 };
@@ -53,7 +50,6 @@ 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"},
@@ -82,10 +78,8 @@ 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);
     }
 };
@@ -93,7 +87,6 @@ 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"},
@@ -134,24 +127,20 @@ 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"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, &IUserManager::CreateUserInterface, "CreateUserInterface"},
-        };
-        // clang-format on
+    explicit IUserManager(Core::System& system_) : ServiceFramework{system_, "nfp:user"} {}
 
-        RegisterHandlers(functions);
+    FunctionInfoBase const* FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key,
+            FunctionInfo{0, &IUserManager::CreateUserInterface, "CreateUserInterface"}
+        );
     }
 
 private:
@@ -166,14 +155,12 @@ private:
 
 class ISystemManager final : public ServiceFramework<ISystemManager> {
 public:
-    explicit ISystemManager(Core::System& system_) : ServiceFramework{system_, "nfp:sys"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, &ISystemManager::CreateSystemInterface, "CreateSystemInterface"},
-        };
-        // clang-format on
+    explicit ISystemManager(Core::System& system_) : ServiceFramework{system_, "nfp:sys"} {}
 
-        RegisterHandlers(functions);
+    FunctionInfoBase const* FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key,
+            FunctionInfo{0, &ISystemManager::CreateSystemInterface, "CreateSystemInterface"}
+        );
     }
 
 private:
@@ -188,14 +175,12 @@ private:
 
 class IDebugManager final : public ServiceFramework<IDebugManager> {
 public:
-    explicit IDebugManager(Core::System& system_) : ServiceFramework{system_, "nfp:dbg"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, &IDebugManager::CreateDebugInterface, "CreateDebugInterface"},
-        };
-        // clang-format on
+    explicit IDebugManager(Core::System& system_) : ServiceFramework{system_, "nfp:dbg"} {}
 
-        RegisterHandlers(functions);
+    FunctionInfoBase const* FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key,
+            FunctionInfo{0, &IDebugManager::CreateDebugInterface, "CreateDebugInterface"}
+        );
     }
 
 private:

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

@@ -21,15 +21,13 @@ namespace Service::NGC {
 
 class IService final : public ServiceFramework<IService> {
 public:
-    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
+    explicit IService(Core::System& system_) : ServiceFramework{system_, "ngct:u"} {}
 
-        RegisterHandlers(functions);
+    FunctionInfoBase const* FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key,
+            FunctionInfo{0, &IService::Match, "Match"},
+            FunctionInfo{1, &IService::Filter, "Filter"}
+        );
     }
 
 private:
@@ -65,19 +63,17 @@ private:
 
 class NgcServiceImpl final : public ServiceFramework<NgcServiceImpl> {
 public:
-    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
+    explicit NgcServiceImpl(Core::System& system_) : ServiceFramework(system_, "ngc:u") {}
 
-        RegisterHandlers(functions);
+    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"}
+        );
     }
 
 private:
@@ -154,21 +150,20 @@ private:
 
 class IServiceWithManagementApi final : public ServiceFramework<IServiceWithManagementApi> {
 public:
-    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);
+    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"}
+        );
     }
 };
 
@@ -179,20 +174,19 @@ static_assert(sizeof(SaveDataHandle) == 0x08);
 
 class IUserShimScopedObject final : public ServiceFramework<IUserShimScopedObject> {
 public:
-    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);
+    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"}
+        );
     }
 
     Result OpenSaveData(Account::Uid unk0, Out<SaveDataHandle> unk1) {
@@ -214,13 +208,12 @@ public:
 
 class IUserService final : public ServiceFramework<IUserService> {
 public:
-    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);
+    explicit IUserService(Core::System& system_) : ServiceFramework(system_, "stpl:u") {}
+
+    FunctionInfoBase const* FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key,
+            FunctionInfo{0, D<&IUserService::Cmd0>, "Cmd0"}
+        );
     }
     Result Cmd0(u32 unk0, OutInterface<IUserShimScopedObject> out_interface) {
         LOG_WARNING(Service_NGC, "stubbed");
@@ -231,21 +224,20 @@ public:
 
 class ISystemShimScopedObject final : public ServiceFramework<ISystemShimScopedObject> {
 public:
-    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);
+    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"}
+        );
     }
 
     Result Cmd108() {
@@ -261,13 +253,12 @@ public:
 
 class ISystemService final : public ServiceFramework<ISystemService> {
 public:
-    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);
+    explicit ISystemService(Core::System& system_) : ServiceFramework(system_, "stpl:sys") {}
+
+    FunctionInfoBase const* FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key,
+            FunctionInfo{0, D<&ISystemService::Cmd0>, "Cmd0"}
+        );
     }
     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[] = {
-            {0, &IScanRequest::Submit, "Submit"},
-            {1, &IScanRequest::IsProcessing, "IsProcessing"},
-            {2, &IScanRequest::GetResult, "GetResult"},
-            {3, &IScanRequest::GetSystemEventReadableHandle, "GetSystemEventReadableHandle"},
-            {4, &IScanRequest::SetChannels, "SetChannels"},
+            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"}
         };
         RegisterHandlers(functions);
 
@@ -343,32 +343,32 @@ public:
     explicit IRequest(Core::System& system_)
         : ServiceFramework{system_, "IRequest"}, service_context{system_, "IRequest"} {
         static const FunctionInfo functions[] = {
-            {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+
+            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+
         };
         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[] = {
-            {0, nullptr, "Update"},
-            {1, nullptr, "PersistOld"},
-            {2, nullptr, "Persist"},
+            FunctionInfo{0, nullptr, "Update"},
+            FunctionInfo{1, nullptr, "PersistOld"},
+            FunctionInfo{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[] = {
-            {4, &NetworkInterface::CreateGeneralServiceOld, "CreateGeneralServiceOld"},
-            {5, &NetworkInterface::CreateGeneralService, "CreateGeneralService"},
+            FunctionInfo{4, &NetworkInterface::CreateGeneralServiceOld, "CreateGeneralServiceOld"},
+            FunctionInfo{5, &NetworkInterface::CreateGeneralService, "CreateGeneralService"}
         };
         RegisterHandlers(functions);
     }

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

@@ -24,24 +24,22 @@ namespace Service::NIM {
 class IShopServiceAsync final : public ServiceFramework<IShopServiceAsync> {
 public:
     explicit IShopServiceAsync(Core::System& system_)
-        : 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
-
-        RegisterHandlers(functions);
-
+        : ServiceFramework{system_, "IShopServiceAsync"}
+        , service_context{system_, "IShopServiceAsync"} {
         completion_event = service_context.CreateEvent("IShopServiceAsync:Completion");
     }
 
+    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"}
+        );
+    }
+
     ~IShopServiceAsync() override {
         CancelImpl();
         service_context.CloseEvent(completion_event);
@@ -141,14 +139,12 @@ private:
 class IShopServiceAccessor final : public ServiceFramework<IShopServiceAccessor> {
 public:
     explicit IShopServiceAccessor(Core::System& system_)
-        : ServiceFramework{system_, "IShopServiceAccessor"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, &IShopServiceAccessor::CreateAsyncInterface, "CreateAsyncInterface"},
-        };
-        // clang-format on
+        : ServiceFramework{system_, "IShopServiceAccessor"} {}
 
-        RegisterHandlers(functions);
+    FunctionInfoBase const* FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key,
+            FunctionInfo{0, &IShopServiceAccessor::CreateAsyncInterface, "CreateAsyncInterface"}
+        );
     }
 
 private:
@@ -165,14 +161,12 @@ private:
 class IShopServiceAccessServer final : public ServiceFramework<IShopServiceAccessServer> {
 public:
     explicit IShopServiceAccessServer(Core::System& system_)
-        : ServiceFramework{system_, "IShopServiceAccessServer"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, &IShopServiceAccessServer::CreateAccessorInterface, "CreateAccessorInterface"},
-        };
-        // clang-format on
+        : ServiceFramework{system_, "IShopServiceAccessServer"} {}
 
-        RegisterHandlers(functions);
+    FunctionInfoBase const* FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key,
+            FunctionInfo{0, &IShopServiceAccessServer::CreateAccessorInterface, "CreateAccessorInterface"}
+        );
     }
 
 private:
@@ -186,254 +180,250 @@ private:
 
 class NIM final : public ServiceFramework<NIM> {
 public:
-    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
+    explicit NIM(Core::System& system_) : ServiceFramework{system_, "nim"} {}
 
-        RegisterHandlers(functions);
+    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+
+        );
     }
 };
 
 class NIM_ECA final : public ServiceFramework<NIM_ECA> {
 public:
-    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
+    explicit NIM_ECA(Core::System& system_) : ServiceFramework{system_, "nim:eca"} {}
 
-        RegisterHandlers(functions);
+    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+
+        );
     }
 
 private:
@@ -467,41 +457,39 @@ private:
 
 class NIM_SHP final : public ServiceFramework<NIM_SHP> {
 public:
-    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
+    explicit NIM_SHP(Core::System& system_) : ServiceFramework{system_, "nim:shp"} {}
 
-        RegisterHandlers(functions);
+    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"}
+        );
     }
 };
 
@@ -512,13 +500,13 @@ public:
         : ServiceFramework{system_, "IEnsureNetworkClockAvailabilityService"},
           service_context{system_, "IEnsureNetworkClockAvailabilityService"} {
         static const FunctionInfo functions[] = {
-            {0, &IEnsureNetworkClockAvailabilityService::StartTask, "StartTask"},
-            {1, &IEnsureNetworkClockAvailabilityService::GetFinishNotificationEvent,
+            FunctionInfo{0, &IEnsureNetworkClockAvailabilityService::StartTask, "StartTask"},
+            FunctionInfo{1, &IEnsureNetworkClockAvailabilityService::GetFinishNotificationEvent,
              "GetFinishNotificationEvent"},
-            {2, &IEnsureNetworkClockAvailabilityService::GetResult, "GetResult"},
-            {3, &IEnsureNetworkClockAvailabilityService::Cancel, "Cancel"},
-            {4, &IEnsureNetworkClockAvailabilityService::IsProcessing, "IsProcessing"},
-            {5, &IEnsureNetworkClockAvailabilityService::GetServerTime, "GetServerTime"},
+            FunctionInfo{2, &IEnsureNetworkClockAvailabilityService::GetResult, "GetResult"},
+            FunctionInfo{3, &IEnsureNetworkClockAvailabilityService::Cancel, "Cancel"},
+            FunctionInfo{4, &IEnsureNetworkClockAvailabilityService::IsProcessing, "IsProcessing"},
+            FunctionInfo{5, &IEnsureNetworkClockAvailabilityService::GetServerTime, "GetServerTime"}
         };
         RegisterHandlers(functions);
 
@@ -587,16 +575,14 @@ private:
 
 class NTC final : public ServiceFramework<NTC> {
 public:
-    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
+    explicit NTC(Core::System& system_) : ServiceFramework{system_, "ntc"} {}
 
-        RegisterHandlers(functions);
+    FunctionInfoBase const* FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key,
+            FunctionInfo{0, &NTC::OpenEnsureNetworkClockAvailabilityService, "OpenEnsureNetworkClockAvailabilityService"},
+            FunctionInfo{100, &NTC::SuspendAutonomicTimeCorrection, "SuspendAutonomicTimeCorrection"},
+            FunctionInfo{101, &NTC::ResumeAutonomicTimeCorrection, "ResumeAutonomicTimeCorrection"}
+        );
     }
 
 private:
@@ -626,14 +612,13 @@ private:
 
 class NIM_ECAS final : public ServiceFramework<NIM_ECAS> {
 public:
-    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);
+    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"}
+        );
     }
 };
 

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

@@ -19,79 +19,77 @@ 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} {
-        // 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
+          get_receive_event{service_context}, get_request_change_state_cancel_event{service_context} {}
 
-        RegisterHandlers(functions);
+    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+
+        );
     }
 
     ~INpnsSystem() override = default;
@@ -148,34 +146,32 @@ 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} {
-        // 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
+        : ServiceFramework{system_, "npns:u"}, service_context{system, "npns:u"}, get_receive_event{service_context} {}
 
-        RegisterHandlers(functions);
+    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"}
+        );
     }
 
 private:

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

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -9,13 +12,13 @@ IFactoryResetInterface::IFactoryResetInterface(Core::System& system_)
     : ServiceFramework{system_, "IFactoryResetInterface"} {
     // clang-format off
         static const FunctionInfo functions[] = {
-            {100, nullptr, "ResetToFactorySettings"},
-            {101, nullptr, "ResetToFactorySettingsWithoutUserSaveData"},
-            {102, nullptr, "ResetToFactorySettingsForRefurbishment"},
-            {103, nullptr, "ResetToFactorySettingsWithPlatformRegion"},
-            {104, nullptr, "ResetToFactorySettingsWithPlatformRegionAuthentication"},
-            {105, nullptr, "RequestResetToFactorySettingsSecurely"},
-            {106, nullptr, "RequestResetToFactorySettingsWithPlatformRegionAuthenticationSecurely"},
+            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"}
         };
     // clang-format on
 

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

@@ -19,25 +19,24 @@ namespace Service::NS {
 
 class INotifyService final : public ServiceFramework<INotifyService> {
 public:
-    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);
+    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" }
+        );
     }
 };
 
@@ -45,18 +44,17 @@ class IVulnerabilityManagerInterface final
     : public ServiceFramework<IVulnerabilityManagerInterface> {
 public:
     explicit IVulnerabilityManagerInterface(Core::System& system_)
-        : 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);
+        : 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"}
+        );
     }
     ~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"},
-        { 30, nullptr, "Cmd30" },
-        { 31, nullptr, "Cmd31" },
-        { 100, nullptr, "Cmd100" },
-        { 110, nullptr, "Cmd110" },
-        { 118, nullptr, "Cmd118" },
-        { 119, nullptr, "Cmd119" },
+        FunctionInfo{30, nullptr, "Cmd30" },
+        FunctionInfo{31, nullptr, "Cmd31" },
+        FunctionInfo{100, nullptr, "Cmd100" },
+        FunctionInfo{110, nullptr, "Cmd110" },
+        FunctionInfo{118, nullptr, "Cmd118" },
+        FunctionInfo{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[] = {
-            {0, D<&IAsyncValue::GetSize>, "GetSize"},
-            {1, D<&IAsyncValue::Get>, "Get"},
-            {2, D<&IAsyncValue::Cancel>, "Cancel"},
-            {3, D<&IAsyncValue::GetErrorContext>, "GetErrorContext"},
+            FunctionInfo{0, D<&IAsyncValue::GetSize>, "GetSize"},
+            FunctionInfo{1, D<&IAsyncValue::Get>, "Get"},
+            FunctionInfo{2, D<&IAsyncValue::Cancel>, "Cancel"},
+            FunctionInfo{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[] = {
-            {0, nullptr, "Initialize"},
-            {1, nullptr, "GetEventHandle"},
-            {2, nullptr, "ControlNotification"},
-            {3, nullptr, "SetNotificationPerm"},
-            {4, nullptr, "SetCoreDumpPerm"},
-            {5, nullptr, "GetAruid"},
-            {6, nullptr, "Reset"},
-            {7, nullptr, "GetAruid2"},
+            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"}
         };
         RegisterHandlers(functions);
     }
@@ -71,11 +71,11 @@ public:
         : ServiceFramework{system_, "nvgem:cd"}
     {
         static const FunctionInfo functions[] = {
-            {0, nullptr, "Initialize"},
-            {1, nullptr, "GetAruid"},
-            {2, nullptr, "ReadNextBlock"},
-            {3, nullptr, "GetNextBlockSize"},
-            {4, nullptr, "ReadNextBlock2"},
+            FunctionInfo{0, nullptr, "Initialize"},
+            FunctionInfo{1, nullptr, "GetAruid"},
+            FunctionInfo{2, nullptr, "ReadNextBlock"},
+            FunctionInfo{3, nullptr, "GetNextBlockSize"},
+            FunctionInfo{4, nullptr, "ReadNextBlock2"}
         };
         RegisterHandlers(functions);
     }
@@ -87,15 +87,15 @@ public:
         : ServiceFramework{system_, "nvdbg:d"}
     {
         static const FunctionInfo functions[] = {
-            {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"},
+            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"}
         };
         RegisterHandlers(functions);
     }

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

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

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

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -10,28 +13,28 @@ IOlscServiceForApplication::IOlscServiceForApplication(Core::System& system_)
     : ServiceFramework{system_, "olsc:u"} {
     // clang-format off
         static const FunctionInfo functions[] = {
-            {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"},
+            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"}
         };
     // clang-format on
 

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

@@ -15,64 +15,59 @@ namespace Service::PCIe {
 
 class ISession final : public ServiceFramework<ISession> {
 public:
-    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
+    explicit ISession(Core::System& system_) : ServiceFramework{system_, "ISession"} {}
 
-        RegisterHandlers(functions);
+    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"}
+        );
     }
 };
 
 class PCIE final : public ServiceFramework<PCIE> {
 public:
-    explicit PCIE(Core::System& system_) : ServiceFramework{system_, "pcie"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "RegisterClassDriver"},
-            {1, nullptr, "QueryFunctionsUnregistered"},
-        };
-        // clang-format on
+    explicit PCIE(Core::System& system_) : ServiceFramework{system_, "pcie"} {}
 
-        RegisterHandlers(functions);
+    FunctionInfoBase const* FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key,
+            FunctionInfo{0, nullptr, "RegisterClassDriver"},
+            FunctionInfo{1, nullptr, "QueryFunctionsUnregistered"}
+        );
     }
 };
 
 class PCIE_LOG final : public ServiceFramework<PCIE_LOG> {
 public:
-    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);
+    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"}
+        );
     }
 };
 

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

@@ -15,91 +15,86 @@ namespace Service::PCV {
 
 class PCV final : public ServiceFramework<PCV> {
 public:
-    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
+    explicit PCV(Core::System& system_) : ServiceFramework{system_, "pcv"} {}
 
-        RegisterHandlers(functions);
+    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"}
+        );
     }
 };
 
 class PCV_ARB final : public ServiceFramework<PCV_ARB> {
 public:
-    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);
+    explicit PCV_ARB(Core::System& system_) : ServiceFramework{system_, "pcv:arb"} {}
+
+    FunctionInfoBase const* FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key,
+            FunctionInfo{0, nullptr, "ReleaseControl"}
+        );
     }
 };
 
 class PCV_IMM final : public ServiceFramework<PCV_IMM> {
 public:
-    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);
+    explicit PCV_IMM(Core::System& system_) : ServiceFramework{system_, "pcv:imm"} {}
+
+    FunctionInfoBase const* FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key,
+            FunctionInfo{0, nullptr, "SetClockRate"}
+        );
     }
 };
 
 class IClkrstSession final : public ServiceFramework<IClkrstSession> {
 public:
     explicit IClkrstSession(Core::System& system_, DeviceCode device_code_)
-        : 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);
+        : 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"}
+        );
     }
 
 private:
@@ -126,19 +121,17 @@ private:
 
 class CLKRST final : public ServiceFramework<CLKRST> {
 public:
-    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
+    explicit CLKRST(Core::System& system_, const char* name) : ServiceFramework{system_, name} {}
 
-        RegisterHandlers(functions);
+    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"}
+        );
     }
 
 private:
@@ -157,14 +150,12 @@ private:
 
 class CLKRST_A final : public ServiceFramework<CLKRST_A> {
 public:
-    explicit CLKRST_A(Core::System& system_) : ServiceFramework{system_, "clkrst:a"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "ReleaseControl"},
-        };
-        // clang-format on
+    explicit CLKRST_A(Core::System& system_) : ServiceFramework{system_, "clkrst:a"} {}
 
-        RegisterHandlers(functions);
+    FunctionInfoBase const* FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key,
+            FunctionInfo{0, nullptr, "ReleaseControl"}
+        );
     }
 };
 

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[] = {
-            {0, &BootMode::GetBootMode, "GetBootMode"},
-            {1, &BootMode::SetMaintenanceBoot, "SetMaintenanceBoot"},
+            FunctionInfo{0, &BootMode::GetBootMode, "GetBootMode"},
+            FunctionInfo{1, &BootMode::SetMaintenanceBoot, "SetMaintenanceBoot"}
         };
         RegisterHandlers(functions);
     }
@@ -78,22 +78,20 @@ private:
 
 class DebugMonitor final : public ServiceFramework<DebugMonitor> {
 public:
-    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
+    explicit DebugMonitor(Core::System& system_) : ServiceFramework{system_, "pm:dmnt"} {}
 
-        RegisterHandlers(functions);
+    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"}
+        );
     }
 
 private:
@@ -170,10 +168,10 @@ class Info final : public ServiceFramework<Info> {
 public:
     explicit Info(Core::System& system_) : ServiceFramework{system_, "pm:info"} {
         static const FunctionInfo functions[] = {
-            {0, &Info::GetProgramId, "GetProgramId"},
-            {65000, &Info::AtmosphereGetProcessId, "AtmosphereGetProcessId"},
-            {65001, nullptr, "AtmosphereHasLaunchedProgram"},
-            {65002, nullptr, "AtmosphereGetProcessInfo"},
+            FunctionInfo{0, &Info::GetProgramId, "GetProgramId"},
+            FunctionInfo{65000, &Info::AtmosphereGetProcessId, "AtmosphereGetProcessId"},
+            FunctionInfo{65001, nullptr, "AtmosphereHasLaunchedProgram"},
+            FunctionInfo{65002, nullptr, "AtmosphereGetProcessInfo"}
         };
         RegisterHandlers(functions);
     }
@@ -222,23 +220,21 @@ private:
 
 class Shell final : public ServiceFramework<Shell> {
 public:
-    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
+    explicit Shell(Core::System& system_) : ServiceFramework{system_, "pm:shell"} {}
 
-        RegisterHandlers(functions);
+    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"}
+        );
     }
 
 private:

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

@@ -21,45 +21,43 @@ namespace Service::PlayReport {
 
 class PlayReport final : public ServiceFramework<PlayReport> {
 public:
-    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
+    explicit PlayReport(const char* name, Core::System& system_) : ServiceFramework{system_, name} {}
 
-        RegisterHandlers(functions);
+    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"}
+        );
     }
 
 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[] = {
-            {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"},
+            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"}
         };
     // clang-format on
 

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

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -8,11 +11,11 @@ namespace Service::PSC {
 IPmModule::IPmModule(Core::System& system_) : ServiceFramework{system_, "IPmModule"} {
     // clang-format off
         static const FunctionInfo functions[] = {
-            {0, nullptr, "Initialize"},
-            {1, nullptr, "GetRequest"},
-            {2, nullptr, "Acknowledge"},
-            {3, nullptr, "Finalize"},
-            {4, nullptr, "AcknowledgeEx"},
+            FunctionInfo{0, nullptr, "Initialize"},
+            FunctionInfo{1, nullptr, "GetRequest"},
+            FunctionInfo{2, nullptr, "Acknowledge"},
+            FunctionInfo{3, nullptr, "Finalize"},
+            FunctionInfo{4, nullptr, "AcknowledgeEx"}
         };
     // clang-format on
 

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

@@ -19,86 +19,81 @@ namespace Service::PSC {
 
 class PSC_L final : public ServiceFramework<PSC_L> {
 public:
-    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);
+    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"}
+        );
     }
 };
 
 class INS_R final : public ServiceFramework<INS_R> {
 public:
-    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);
+    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"}
+        );
     }
 };
 
 class INS_S final : public ServiceFramework<INS_S> {
 public:
-    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);
+    explicit INS_S(Core::System& system_) : ServiceFramework{system_, "ins:s"} {}
+
+    FunctionInfoBase const* FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key,
+            FunctionInfo{0, nullptr, "GetNotifyEvent"}
+        );
     }
 };
 
 class HSHL_SYS final : public ServiceFramework<HSHL_SYS> {
 public:
-    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);
+    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"}
+        );
     }
 };
 
 class HSHL_SET final : public ServiceFramework<HSHL_SET> {
 public:
-    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);
+    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"}
+        );
     }
 };
 

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

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

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

@@ -21,22 +21,21 @@ namespace Service::PTM {
 class IPsmSession final : public ServiceFramework<IPsmSession> {
 public:
     explicit IPsmSession(Core::System& system_)
-        : 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
-
-        RegisterHandlers(functions);
-
+        : ServiceFramework{system_, "IPsmSession"}
+        , service_context{system_, "IPsmSession"} {
         state_change_event = service_context.CreateEvent("IPsmSession::state_change_event");
     }
 
+    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"}
+        );
+    }
+
     ~IPsmSession() override {
         service_context.CloseEvent(state_change_event);
     }

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

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

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

@@ -19,16 +19,14 @@ enum class Location : u8 {
 
 class ISession : public ServiceFramework<ISession> {
 public:
-    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
+    explicit ISession(Core::System& system_) : ServiceFramework{system_, "ISession"} {}
 
-        RegisterHandlers(functions);
+    FunctionInfoBase const* FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key,
+            FunctionInfo{0, nullptr, "GetTemperatureRange"},
+            FunctionInfo{2, nullptr, "SetMeasurementMode"},
+            FunctionInfo{4, &ISession::GetTemperature, "GetTemperature"}
+        );
     }
 
 private:

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

@@ -505,23 +505,22 @@ 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)
+    {}
 
-        // 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);
+    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"}
+        );
     }
 
     ~RoInterface() {
@@ -578,7 +577,7 @@ public:
         : ServiceFramework{system_, "ro:dmnt"}
     {
         static const FunctionInfo functions[] = {
-            { 0, nullptr, "GetProcessModuleInfo" },
+            FunctionInfo{0, nullptr, "GetProcessModuleInfo" },
         };
         RegisterHandlers(functions);
     }

src/core/hle/service/service.cpp

@@ -47,22 +47,7 @@ ServiceFrameworkBase::~ServiceFrameworkBase() {
     const auto guard = ServiceFrameworkBase::LockService();
 }
 
-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) {
+void ServiceFrameworkBase::ReportUnimplementedFunction(HLERequestContext& ctx, const FunctionInfoBase* info) {
     auto cmd_buf = ctx.CommandBuffer();
     std::string function_name = info == nullptr ? "<unknown>" : info->name;
 
@@ -82,16 +67,10 @@ void ServiceFrameworkBase::ReportUnimplementedFunction(HLERequestContext& ctx,
 }
 
 void ServiceFrameworkBase::InvokeRequest(HLERequestContext& ctx) {
-    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);
-
+    const bool is_cmd_read = ctx.GetCommand() == 0;
+    auto const info = FindRequest(ctx.GetCommand());
     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())) {
@@ -101,11 +80,7 @@ void ServiceFrameworkBase::InvokeRequest(HLERequestContext& ctx) {
 }
 
 void ServiceFrameworkBase::InvokeRequestTipc(HLERequestContext& ctx) {
-    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);
-
+    auto const info = FindRequestTipc(ctx.GetCommand());
     LOG_TRACE(Service, "{}", MakeFunctionString(info->name, GetServiceName(), ctx.CommandBuffer()));
     handler_invoker(this, info->handler_callback, ctx);
 }

src/core/hle/service/service.h

@@ -7,7 +7,10 @@
 #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"
@@ -77,30 +80,37 @@ protected:
     [[nodiscard]] virtual std::unique_lock<std::mutex> LockService() noexcept {
         return std::unique_lock{lock_service};
     }
-private:
-    template <typename T>
-    friend class ServiceFramework;
+
+    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);
+    }
 
     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.
@@ -143,25 +153,60 @@ 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_)
-            : FunctionInfoBase{expected_header_, HandlerFnP<ServiceFrameworkBase>(handler_callback_), name_} {}
+        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_}
+        {}
     };
     using FunctionInfo = FunctionInfoTyped<Self>;
 
-    /**
-     * 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.
-     */
+    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.
     explicit ServiceFramework(Core::System& system_, const char* service_name_, u32 max_sessions_ = ServerSessionCountMax)
-        : ServiceFrameworkBase(system_, service_name_, max_sessions_, Invoker) {}
+        : 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]);
+    }
 
     /// Registers handlers in the service.
     template <typename T = Self, std::size_t N>
-    void RegisterHandlers(const FunctionInfoTyped<T> (&functions)[N]) {
+    constexpr void RegisterHandlers(const FunctionInfoTyped<T> (&functions)[N]) {
         RegisterHandlers(functions, N);
     }
 
@@ -170,13 +215,13 @@ protected:
      * overload in order to avoid needing to specify the array size.
      */
     template <typename T = Self>
-    void RegisterHandlers(const FunctionInfoTyped<T>* functions, std::size_t n) {
+    constexpr 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>
-    void RegisterHandlersTipc(const FunctionInfoTyped<T> (&functions)[N]) {
+    constexpr void RegisterHandlersTipc(const FunctionInfoTyped<T> (&functions)[N]) {
         RegisterHandlersTipc(functions, N);
     }
 
@@ -185,7 +230,7 @@ protected:
      * overload in order to avoid needing to specify the array size.
      */
     template <typename T = Self>
-    void RegisterHandlersTipc(const FunctionInfoTyped<T>* functions, std::size_t n) {
+    constexpr void RegisterHandlersTipc(const FunctionInfoTyped<T>* functions, std::size_t n) {
         RegisterHandlersBaseTipc(functions, n);
     }
 
@@ -217,6 +262,9 @@ 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,49 +15,46 @@ namespace Service::Sockets {
 class ETHC_C final : public ServiceFramework<ETHC_C> {
 public:
     explicit ETHC_C(Core::System& system_)
-        : 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);
+        : 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"}
+        );
     }
 };
 
 class ETHC_I final : public ServiceFramework<ETHC_I> {
 public:
     explicit ETHC_I(Core::System& system_)
-        : 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);
+        : 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"}
+        );
     }
 };
 
 class ISfDriverServiceCreator final : public ServiceFramework<ISfDriverServiceCreator> {
 public:
     explicit ISfDriverServiceCreator(Core::System& system_)
-        : ServiceFramework{system_, "eth:nd"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "CreateDriverService"},
-        };
-        // clang-format on
-        RegisterHandlers(functions);
+        : ServiceFramework{system_, "eth:nd"} {}
+
+    FunctionInfoBase const* FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key,
+            FunctionInfo{0, nullptr, "CreateDriverService"}
+        );
     }
 };
 

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[] = {
-            {0, &CSRNG::GenerateRandomBytes, "GenerateRandomBytes"},
+            FunctionInfo{0, &CSRNG::GenerateRandomBytes, "GenerateRandomBytes"}
         };
         RegisterHandlers(functions);
     }

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

@@ -74,59 +74,56 @@ 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)} {
-        // 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
-
-        RegisterHandlers(functions);
-
+    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++;
     }
 
+    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"}
+        );
+    }
+
     ~ISslConnection() {
         shared_data->connection_count--;
         if (fd_to_close.has_value()) {
@@ -453,20 +450,20 @@ public:
         : ServiceFramework{system_, "ISslContext"}, ssl_version{version},
           shared_data{std::make_shared<SslContextSharedData>()} {
         static const FunctionInfo functions[] = {
-            {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"},
+            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"}
         };
         RegisterHandlers(functions);
     }
@@ -566,23 +563,21 @@ private:
 class ISslService final : public ServiceFramework<ISslService> {
 public:
     explicit ISslService(Core::System& 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
+        : ServiceFramework{system_, "ssl"}, cert_store{system} {}
 
-        RegisterHandlers(functions);
+    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"}
+        );
     }
 
 private:
@@ -636,20 +631,20 @@ class ISslServiceForSystem final : public ServiceFramework<ISslServiceForSystem>
         explicit ISslServiceForSystem(Core::System& system_) : ServiceFramework{system_, "ssl:s"} {
             // clang-format off
             static const FunctionInfo functions[] = {
-                {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"}
+                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"}
             };
             // clang-format on
 

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

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

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

@@ -17,137 +17,123 @@ namespace Service::USB {
 
 class IDsInterface final : public ServiceFramework<IDsInterface> {
 public:
-    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
+    explicit IDsInterface(Core::System& system_) : ServiceFramework{system_, "IDsInterface"} {}
 
-        RegisterHandlers(functions);
+    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"}
+        );
     }
 };
 
 class IDsRootSession final : public ServiceFramework<IDsRootSession> {
 public:
-    explicit IDsRootSession(Core::System& system_) : ServiceFramework{system_, "usb:ds"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, nullptr, "OpenDsService"},
-        };
-        // clang-format on
+    explicit IDsRootSession(Core::System& system_) : ServiceFramework{system_, "usb:ds"} {}
 
-        RegisterHandlers(functions);
+    FunctionInfoBase const* FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key,
+            FunctionInfo{0, nullptr, "OpenDsService"}
+        );
     }
 };
 
 class IClientEpSession final : public ServiceFramework<IClientEpSession> {
 public:
     explicit IClientEpSession(Core::System& system_)
-        : 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
+        : ServiceFramework{system_, "IClientEpSession"} {}
 
-        RegisterHandlers(functions);
+    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"}
+        );
     }
 };
 
 class IClientIfSession final : public ServiceFramework<IClientIfSession> {
 public:
     explicit IClientIfSession(Core::System& system_)
-        : 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
+        : ServiceFramework{system_, "IClientIfSession"} {}
 
-        RegisterHandlers(functions);
+    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"}
+        );
     }
 };
 
 class IClientRootSession final : public ServiceFramework<IClientRootSession> {
 public:
-    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
+    explicit IClientRootSession(Core::System& system_) : ServiceFramework{system_, "usb:hs"} {}
 
-        RegisterHandlers(functions);
+    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"}
+        );
     }
 };
 
 class IPdSession final : public ServiceFramework<IPdSession> {
 public:
-    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
+    explicit IPdSession(Core::System& system_) : ServiceFramework{system_, "IPdSession"} {}
 
-        RegisterHandlers(functions);
+    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"}
+        );
     }
 };
 
 class IPdManager final : public ServiceFramework<IPdManager> {
 public:
-    explicit IPdManager(Core::System& system_) : ServiceFramework{system_, "usb:pd"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, &IPdManager::OpenSession, "OpenSession"},
-        };
-        // clang-format on
+    explicit IPdManager(Core::System& system_) : ServiceFramework{system_, "usb:pd"} {}
 
-        RegisterHandlers(functions);
+    FunctionInfoBase const* FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key,
+            FunctionInfo{0, &IPdManager::OpenSession, "OpenSession"}
+        );
     }
 
 private:
@@ -163,35 +149,31 @@ private:
 class IPdCradleSession final : public ServiceFramework<IPdCradleSession> {
 public:
     explicit IPdCradleSession(Core::System& system_)
-        : 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
+        : ServiceFramework{system_, "IPdCradleSession"} {}
 
-        RegisterHandlers(functions);
+    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"}
+        );
     }
 };
 
 class IPdCradleManager final : public ServiceFramework<IPdCradleManager> {
 public:
-    explicit IPdCradleManager(Core::System& system_) : ServiceFramework{system_, "usb:pd:c"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, &IPdCradleManager::OpenCradleSession, "OpenCradleSession"},
-        };
-        // clang-format on
+    explicit IPdCradleManager(Core::System& system_) : ServiceFramework{system_, "usb:pd:c"} {}
 
-        RegisterHandlers(functions);
+    FunctionInfoBase const* FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key,
+            FunctionInfo{0, &IPdCradleManager::OpenCradleSession, "OpenCradleSession"}
+        );
     }
 
 private:
@@ -206,57 +188,52 @@ private:
 
 class IPmMainService final : public ServiceFramework<IPmMainService> {
 public:
-    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
+    explicit IPmMainService(Core::System& system_) : ServiceFramework{system_, "usb:pm"} {}
 
-        RegisterHandlers(functions);
+    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"}
+        );
     }
 };
 
 class IPdManufactureManager final : public ServiceFramework<IPdManufactureManager> {
 public:
-    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);
+    explicit IPdManufactureManager(Core::System& system_) : ServiceFramework{system_, "usb:pd:m"} {}
+
+    FunctionInfoBase const* FindRequest(u32 key) override {
+        return HandlerTableGenerateWithFind(key,
+            FunctionInfo{0, nullptr, "OpenManufactureSession"}
+        );
     }
 };
 
 class IQdbManager final : public ServiceFramework<IQdbManager> {
 public:
-    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);
+    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"}
+        );
     }
 };
 
 class IPmObserverService final : public ServiceFramework<IPmObserverService> {
 public:
-    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);
+    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"}
+        );
     }
 };
 

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

@@ -18,103 +18,103 @@ public:
         : ServiceFramework{system_, "wlan:lcl"}
     {
         static const FunctionInfo functions[] = {
-            { 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" },
+            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" },
         };
         RegisterHandlers(functions);
     }
@@ -126,7 +126,7 @@ public:
         : ServiceFramework{system_, "wlan:lg"}
     {
         static const FunctionInfo functions[] = {
-            { 0, nullptr, "GetFrameRaw" },
+            FunctionInfo{0, nullptr, "GetFrameRaw" },
         };
         RegisterHandlers(functions);
     }
@@ -138,7 +138,7 @@ public:
         : ServiceFramework{system_, "wlan:lga"}
     {
         static const FunctionInfo functions[] = {
-            { 0, nullptr, "GetActionFrame" },
+            FunctionInfo{0, nullptr, "GetActionFrame" },
         };
         RegisterHandlers(functions);
     }
@@ -150,7 +150,7 @@ public:
         : ServiceFramework{system_, "wlan:sg"}
     {
         static const FunctionInfo functions[] = {
-            { 0, nullptr, "GetFrameRaw" },
+            FunctionInfo{0, nullptr, "GetFrameRaw" },
         };
         RegisterHandlers(functions);
     }
@@ -162,19 +162,19 @@ public:
         : ServiceFramework{system_, "wlan:soc"}
     {
         static const FunctionInfo functions[] = {
-            { 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" },
+            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" },
         };
         RegisterHandlers(functions);
     }
@@ -186,34 +186,34 @@ public:
         : ServiceFramework{system_, "wlan:dtc"}
     {
         static const FunctionInfo functions[] = {
-            { 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" },
+            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" },
         };
         RegisterHandlers(functions);
     }
@@ -225,8 +225,8 @@ public:
         : ServiceFramework{system_, "wlan:p"}
     {
         static const FunctionInfo functions[] = {
-            { 0, nullptr, "CreateWirelessCommunicationService" },
-            { 1, nullptr, "CreatePrivateWirelessCommunicationService" },
+            FunctionInfo{0, nullptr, "CreateWirelessCommunicationService" },
+            FunctionInfo{1, nullptr, "CreatePrivateWirelessCommunicationService" },
         };
         RegisterHandlers(functions);
     }
@@ -238,7 +238,7 @@ public:
         : ServiceFramework{system_, "wlan:nd"}
     {
         static const FunctionInfo functions[] = {
-            { 0, nullptr, "CreateDriverService" },
+            FunctionInfo{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 (emitted into STDOUT).
+- `maxwell-spirv`: Converts Maxwell shaders (dumped from `.ash` files) into SPIR-V code sent to stdout.
 - `maxwell-disas`: Dumb raw Maxwell disassembler.
 - `maxwell-ir`: Dump generated IR of Maxwell shaders.