From df3b935b5b9cfc9ebbcd6241676a19b5993a265b Mon Sep 17 00:00:00 2001 From: lizzie Date: Mon, 20 Oct 2025 02:21:49 +0000 Subject: [PATCH] [tools, hle/kernel] generate condensed version of svc.cpp; move svc_generator.py and generate_converters.py to tools Signed-off-by: lizzie --- src/core/hle/kernel/svc.cpp | 4052 +++++------------ src/core/hle/kernel/svc.h | 9 +- tools/README.md | 3 +- .../generate_converters.py | 0 .../hle/kernel => tools}/svc_generator.py | 90 +- 5 files changed, 1099 insertions(+), 3055 deletions(-) rename {src/video_core/engines/sw_blitter => tools}/generate_converters.py (100%) rename {src/core/hle/kernel => tools}/svc_generator.py (95%) mode change 100644 => 100755 diff --git a/src/core/hle/kernel/svc.cpp b/src/core/hle/kernel/svc.cpp index 8370e62bc4..30c6d75c13 100644 --- a/src/core/hle/kernel/svc.cpp +++ b/src/core/hle/kernel/svc.cpp @@ -1,10 +1,10 @@ // SPDX-FileCopyrightText: Copyright 2025 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 +// SPDX-License-Identifier: GPL-2.0-or-late // This file is automatically generated using svc_generator.py. +// DO NOT MODIFY IT MANUALLY #include @@ -16,7 +16,7 @@ namespace Kernel::Svc { static uint32_t GetArg32(std::span args, int n) { - return static_cast(args[n]); + return uint32_t(args[n]); } static void SetArg32(std::span args, int n, uint32_t result) { @@ -37,17 +37,12 @@ template requires(std::is_trivial_v && std::is_trivially_copyable_v) static To Convert(const From& from) { To to{}; - - if constexpr (sizeof(To) >= sizeof(From)) { + if constexpr (sizeof(To) >= sizeof(From)) std::memcpy(std::addressof(to), std::addressof(from), sizeof(From)); - } else { + else std::memcpy(std::addressof(to), std::addressof(from), sizeof(To)); - } - return to; } - -// clang-format off static_assert(sizeof(ArbitrationType) == 4); static_assert(sizeof(BreakReason) == 4); static_assert(sizeof(CodeMemoryOperation) == 4); @@ -83,97 +78,51 @@ static_assert(sizeof(uint32_t) == 4); static_assert(sizeof(uint64_t) == 8); static void SvcWrap_SetHeapSize64From32(Core::System& system, std::span args) { - Result ret{}; - + uint32_t size = Convert(GetArg32(args, 1)); uint64_t out_address{}; - uint32_t size{}; - - size = Convert(GetArg32(args, 1)); - - ret = SetHeapSize64From32(system, std::addressof(out_address), size); - + Result ret = SetHeapSize64From32(system, std::addressof(out_address), size); SetArg32(args, 0, Convert(ret)); SetArg32(args, 1, Convert(out_address)); } static void SvcWrap_SetMemoryPermission64From32(Core::System& system, std::span args) { - Result ret{}; - - uint32_t address{}; - uint32_t size{}; - MemoryPermission perm{}; - - address = Convert(GetArg32(args, 0)); - size = Convert(GetArg32(args, 1)); - perm = Convert(GetArg32(args, 2)); - - ret = SetMemoryPermission64From32(system, address, size, perm); - + uint32_t address = Convert(GetArg32(args, 0)); + uint32_t size = Convert(GetArg32(args, 1)); + MemoryPermission perm = Convert(GetArg32(args, 2)); + Result ret = SetMemoryPermission64From32(system, address, size, perm); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_SetMemoryAttribute64From32(Core::System& system, std::span args) { - Result ret{}; - - uint32_t address{}; - uint32_t size{}; - uint32_t mask{}; - uint32_t attr{}; - - address = Convert(GetArg32(args, 0)); - size = Convert(GetArg32(args, 1)); - mask = Convert(GetArg32(args, 2)); - attr = Convert(GetArg32(args, 3)); - - ret = SetMemoryAttribute64From32(system, address, size, mask, attr); - + uint32_t address = Convert(GetArg32(args, 0)); + uint32_t size = Convert(GetArg32(args, 1)); + uint32_t mask = Convert(GetArg32(args, 2)); + uint32_t attr = Convert(GetArg32(args, 3)); + Result ret = SetMemoryAttribute64From32(system, address, size, mask, attr); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_MapMemory64From32(Core::System& system, std::span args) { - Result ret{}; - - uint32_t dst_address{}; - uint32_t src_address{}; - uint32_t size{}; - - dst_address = Convert(GetArg32(args, 0)); - src_address = Convert(GetArg32(args, 1)); - size = Convert(GetArg32(args, 2)); - - ret = MapMemory64From32(system, dst_address, src_address, size); - + uint32_t dst_address = Convert(GetArg32(args, 0)); + uint32_t src_address = Convert(GetArg32(args, 1)); + uint32_t size = Convert(GetArg32(args, 2)); + Result ret = MapMemory64From32(system, dst_address, src_address, size); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_UnmapMemory64From32(Core::System& system, std::span args) { - Result ret{}; - - uint32_t dst_address{}; - uint32_t src_address{}; - uint32_t size{}; - - dst_address = Convert(GetArg32(args, 0)); - src_address = Convert(GetArg32(args, 1)); - size = Convert(GetArg32(args, 2)); - - ret = UnmapMemory64From32(system, dst_address, src_address, size); - + uint32_t dst_address = Convert(GetArg32(args, 0)); + uint32_t src_address = Convert(GetArg32(args, 1)); + uint32_t size = Convert(GetArg32(args, 2)); + Result ret = UnmapMemory64From32(system, dst_address, src_address, size); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_QueryMemory64From32(Core::System& system, std::span args) { - Result ret{}; - + uint32_t out_memory_info = Convert(GetArg32(args, 0)); + uint32_t address = Convert(GetArg32(args, 2)); PageInfo out_page_info{}; - uint32_t out_memory_info{}; - uint32_t address{}; - - out_memory_info = Convert(GetArg32(args, 0)); - address = Convert(GetArg32(args, 2)); - - ret = QueryMemory64From32(system, out_memory_info, std::addressof(out_page_info), address); - + Result ret = QueryMemory64From32(system, out_memory_info, std::addressof(out_page_info), address); SetArg32(args, 0, Convert(ret)); SetArg32(args, 1, Convert(out_page_info)); } @@ -183,36 +132,20 @@ static void SvcWrap_ExitProcess64From32(Core::System& system, std::span args) { - Result ret{}; - + uint32_t func = Convert(GetArg32(args, 1)); + uint32_t arg = Convert(GetArg32(args, 2)); + uint32_t stack_bottom = Convert(GetArg32(args, 3)); + int32_t priority = Convert(GetArg32(args, 0)); + int32_t core_id = Convert(GetArg32(args, 4)); Handle out_handle{}; - uint32_t func{}; - uint32_t arg{}; - uint32_t stack_bottom{}; - int32_t priority{}; - int32_t core_id{}; - - func = Convert(GetArg32(args, 1)); - arg = Convert(GetArg32(args, 2)); - stack_bottom = Convert(GetArg32(args, 3)); - priority = Convert(GetArg32(args, 0)); - core_id = Convert(GetArg32(args, 4)); - - ret = CreateThread64From32(system, std::addressof(out_handle), func, arg, stack_bottom, priority, core_id); - + Result ret = CreateThread64From32(system, std::addressof(out_handle), func, arg, stack_bottom, priority, core_id); SetArg32(args, 0, Convert(ret)); SetArg32(args, 1, Convert(out_handle)); } static void SvcWrap_StartThread64From32(Core::System& system, std::span args) { - Result ret{}; - - Handle thread_handle{}; - - thread_handle = Convert(GetArg32(args, 0)); - - ret = StartThread64From32(system, thread_handle); - + Handle thread_handle = Convert(GetArg32(args, 0)); + Result ret = StartThread64From32(system, thread_handle); SetArg32(args, 0, Convert(ret)); } @@ -221,55 +154,33 @@ static void SvcWrap_ExitThread64From32(Core::System& system, std::span args) { - int64_t ns{}; - std::array ns_gather{}; ns_gather[0] = GetArg32(args, 0); ns_gather[1] = GetArg32(args, 1); - ns = Convert(ns_gather); - + int64_t ns = Convert(ns_gather); SleepThread64From32(system, ns); } static void SvcWrap_GetThreadPriority64From32(Core::System& system, std::span args) { - Result ret{}; - + Handle thread_handle = Convert(GetArg32(args, 1)); int32_t out_priority{}; - Handle thread_handle{}; - - thread_handle = Convert(GetArg32(args, 1)); - - ret = GetThreadPriority64From32(system, std::addressof(out_priority), thread_handle); - + Result ret = GetThreadPriority64From32(system, std::addressof(out_priority), thread_handle); SetArg32(args, 0, Convert(ret)); SetArg32(args, 1, Convert(out_priority)); } static void SvcWrap_SetThreadPriority64From32(Core::System& system, std::span args) { - Result ret{}; - - Handle thread_handle{}; - int32_t priority{}; - - thread_handle = Convert(GetArg32(args, 0)); - priority = Convert(GetArg32(args, 1)); - - ret = SetThreadPriority64From32(system, thread_handle, priority); - + Handle thread_handle = Convert(GetArg32(args, 0)); + int32_t priority = Convert(GetArg32(args, 1)); + Result ret = SetThreadPriority64From32(system, thread_handle, priority); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_GetThreadCoreMask64From32(Core::System& system, std::span args) { - Result ret{}; - + Handle thread_handle = Convert(GetArg32(args, 2)); int32_t out_core_id{}; uint64_t out_affinity_mask{}; - Handle thread_handle{}; - - thread_handle = Convert(GetArg32(args, 2)); - - ret = GetThreadCoreMask64From32(system, std::addressof(out_core_id), std::addressof(out_affinity_mask), thread_handle); - + Result ret = GetThreadCoreMask64From32(system, std::addressof(out_core_id), std::addressof(out_affinity_mask), thread_handle); SetArg32(args, 0, Convert(ret)); SetArg32(args, 1, Convert(out_core_id)); auto out_affinity_mask_scatter = Convert>(out_affinity_mask); @@ -278,304 +189,166 @@ static void SvcWrap_GetThreadCoreMask64From32(Core::System& system, std::span args) { - Result ret{}; - - Handle thread_handle{}; - int32_t core_id{}; - uint64_t affinity_mask{}; - - thread_handle = Convert(GetArg32(args, 0)); - core_id = Convert(GetArg32(args, 1)); + Handle thread_handle = Convert(GetArg32(args, 0)); + int32_t core_id = Convert(GetArg32(args, 1)); std::array affinity_mask_gather{}; affinity_mask_gather[0] = GetArg32(args, 2); affinity_mask_gather[1] = GetArg32(args, 3); - affinity_mask = Convert(affinity_mask_gather); - - ret = SetThreadCoreMask64From32(system, thread_handle, core_id, affinity_mask); - + uint64_t affinity_mask = Convert(affinity_mask_gather); + Result ret = SetThreadCoreMask64From32(system, thread_handle, core_id, affinity_mask); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_GetCurrentProcessorNumber64From32(Core::System& system, std::span args) { - int32_t ret{}; - - ret = GetCurrentProcessorNumber64From32(system); - + int32_t ret = GetCurrentProcessorNumber64From32(system); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_SignalEvent64From32(Core::System& system, std::span args) { - Result ret{}; - - Handle event_handle{}; - - event_handle = Convert(GetArg32(args, 0)); - - ret = SignalEvent64From32(system, event_handle); - + Handle event_handle = Convert(GetArg32(args, 0)); + Result ret = SignalEvent64From32(system, event_handle); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_ClearEvent64From32(Core::System& system, std::span args) { - Result ret{}; - - Handle event_handle{}; - - event_handle = Convert(GetArg32(args, 0)); - - ret = ClearEvent64From32(system, event_handle); - + Handle event_handle = Convert(GetArg32(args, 0)); + Result ret = ClearEvent64From32(system, event_handle); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_MapSharedMemory64From32(Core::System& system, std::span args) { - Result ret{}; - - Handle shmem_handle{}; - uint32_t address{}; - uint32_t size{}; - MemoryPermission map_perm{}; - - shmem_handle = Convert(GetArg32(args, 0)); - address = Convert(GetArg32(args, 1)); - size = Convert(GetArg32(args, 2)); - map_perm = Convert(GetArg32(args, 3)); - - ret = MapSharedMemory64From32(system, shmem_handle, address, size, map_perm); - + Handle shmem_handle = Convert(GetArg32(args, 0)); + uint32_t address = Convert(GetArg32(args, 1)); + uint32_t size = Convert(GetArg32(args, 2)); + MemoryPermission map_perm = Convert(GetArg32(args, 3)); + Result ret = MapSharedMemory64From32(system, shmem_handle, address, size, map_perm); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_UnmapSharedMemory64From32(Core::System& system, std::span args) { - Result ret{}; - - Handle shmem_handle{}; - uint32_t address{}; - uint32_t size{}; - - shmem_handle = Convert(GetArg32(args, 0)); - address = Convert(GetArg32(args, 1)); - size = Convert(GetArg32(args, 2)); - - ret = UnmapSharedMemory64From32(system, shmem_handle, address, size); - + Handle shmem_handle = Convert(GetArg32(args, 0)); + uint32_t address = Convert(GetArg32(args, 1)); + uint32_t size = Convert(GetArg32(args, 2)); + Result ret = UnmapSharedMemory64From32(system, shmem_handle, address, size); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_CreateTransferMemory64From32(Core::System& system, std::span args) { - Result ret{}; - + uint32_t address = Convert(GetArg32(args, 1)); + uint32_t size = Convert(GetArg32(args, 2)); + MemoryPermission map_perm = Convert(GetArg32(args, 3)); Handle out_handle{}; - uint32_t address{}; - uint32_t size{}; - MemoryPermission map_perm{}; - - address = Convert(GetArg32(args, 1)); - size = Convert(GetArg32(args, 2)); - map_perm = Convert(GetArg32(args, 3)); - - ret = CreateTransferMemory64From32(system, std::addressof(out_handle), address, size, map_perm); - + Result ret = CreateTransferMemory64From32(system, std::addressof(out_handle), address, size, map_perm); SetArg32(args, 0, Convert(ret)); SetArg32(args, 1, Convert(out_handle)); } static void SvcWrap_CloseHandle64From32(Core::System& system, std::span args) { - Result ret{}; - - Handle handle{}; - - handle = Convert(GetArg32(args, 0)); - - ret = CloseHandle64From32(system, handle); - + Handle handle = Convert(GetArg32(args, 0)); + Result ret = CloseHandle64From32(system, handle); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_ResetSignal64From32(Core::System& system, std::span args) { - Result ret{}; - - Handle handle{}; - - handle = Convert(GetArg32(args, 0)); - - ret = ResetSignal64From32(system, handle); - + Handle handle = Convert(GetArg32(args, 0)); + Result ret = ResetSignal64From32(system, handle); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_WaitSynchronization64From32(Core::System& system, std::span args) { - Result ret{}; - - int32_t out_index{}; - uint32_t handles{}; - int32_t num_handles{}; - int64_t timeout_ns{}; - - handles = Convert(GetArg32(args, 1)); - num_handles = Convert(GetArg32(args, 2)); + uint32_t handles = Convert(GetArg32(args, 1)); + int32_t num_handles = Convert(GetArg32(args, 2)); std::array timeout_ns_gather{}; timeout_ns_gather[0] = GetArg32(args, 0); timeout_ns_gather[1] = GetArg32(args, 3); - timeout_ns = Convert(timeout_ns_gather); - - ret = WaitSynchronization64From32(system, std::addressof(out_index), handles, num_handles, timeout_ns); - + int64_t timeout_ns = Convert(timeout_ns_gather); + int32_t out_index{}; + Result ret = WaitSynchronization64From32(system, std::addressof(out_index), handles, num_handles, timeout_ns); SetArg32(args, 0, Convert(ret)); SetArg32(args, 1, Convert(out_index)); } static void SvcWrap_CancelSynchronization64From32(Core::System& system, std::span args) { - Result ret{}; - - Handle handle{}; - - handle = Convert(GetArg32(args, 0)); - - ret = CancelSynchronization64From32(system, handle); - + Handle handle = Convert(GetArg32(args, 0)); + Result ret = CancelSynchronization64From32(system, handle); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_ArbitrateLock64From32(Core::System& system, std::span args) { - Result ret{}; - - Handle thread_handle{}; - uint32_t address{}; - uint32_t tag{}; - - thread_handle = Convert(GetArg32(args, 0)); - address = Convert(GetArg32(args, 1)); - tag = Convert(GetArg32(args, 2)); - - ret = ArbitrateLock64From32(system, thread_handle, address, tag); - + Handle thread_handle = Convert(GetArg32(args, 0)); + uint32_t address = Convert(GetArg32(args, 1)); + uint32_t tag = Convert(GetArg32(args, 2)); + Result ret = ArbitrateLock64From32(system, thread_handle, address, tag); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_ArbitrateUnlock64From32(Core::System& system, std::span args) { - Result ret{}; - - uint32_t address{}; - - address = Convert(GetArg32(args, 0)); - - ret = ArbitrateUnlock64From32(system, address); - + uint32_t address = Convert(GetArg32(args, 0)); + Result ret = ArbitrateUnlock64From32(system, address); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_WaitProcessWideKeyAtomic64From32(Core::System& system, std::span args) { - Result ret{}; - - uint32_t address{}; - uint32_t cv_key{}; - uint32_t tag{}; - int64_t timeout_ns{}; - - address = Convert(GetArg32(args, 0)); - cv_key = Convert(GetArg32(args, 1)); - tag = Convert(GetArg32(args, 2)); + uint32_t address = Convert(GetArg32(args, 0)); + uint32_t cv_key = Convert(GetArg32(args, 1)); + uint32_t tag = Convert(GetArg32(args, 2)); std::array timeout_ns_gather{}; timeout_ns_gather[0] = GetArg32(args, 3); timeout_ns_gather[1] = GetArg32(args, 4); - timeout_ns = Convert(timeout_ns_gather); - - ret = WaitProcessWideKeyAtomic64From32(system, address, cv_key, tag, timeout_ns); - + int64_t timeout_ns = Convert(timeout_ns_gather); + Result ret = WaitProcessWideKeyAtomic64From32(system, address, cv_key, tag, timeout_ns); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_SignalProcessWideKey64From32(Core::System& system, std::span args) { - uint32_t cv_key{}; - int32_t count{}; - - cv_key = Convert(GetArg32(args, 0)); - count = Convert(GetArg32(args, 1)); - + uint32_t cv_key = Convert(GetArg32(args, 0)); + int32_t count = Convert(GetArg32(args, 1)); SignalProcessWideKey64From32(system, cv_key, count); } static void SvcWrap_GetSystemTick64From32(Core::System& system, std::span args) { - int64_t ret{}; - - ret = GetSystemTick64From32(system); - + int64_t ret = GetSystemTick64From32(system); auto ret_scatter = Convert>(ret); SetArg32(args, 0, ret_scatter[0]); SetArg32(args, 1, ret_scatter[1]); } static void SvcWrap_ConnectToNamedPort64From32(Core::System& system, std::span args) { - Result ret{}; - + uint32_t name = Convert(GetArg32(args, 1)); Handle out_handle{}; - uint32_t name{}; - - name = Convert(GetArg32(args, 1)); - - ret = ConnectToNamedPort64From32(system, std::addressof(out_handle), name); - + Result ret = ConnectToNamedPort64From32(system, std::addressof(out_handle), name); SetArg32(args, 0, Convert(ret)); SetArg32(args, 1, Convert(out_handle)); } static void SvcWrap_SendSyncRequest64From32(Core::System& system, std::span args) { - Result ret{}; - - Handle session_handle{}; - - session_handle = Convert(GetArg32(args, 0)); - - ret = SendSyncRequest64From32(system, session_handle); - + Handle session_handle = Convert(GetArg32(args, 0)); + Result ret = SendSyncRequest64From32(system, session_handle); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_SendSyncRequestWithUserBuffer64From32(Core::System& system, std::span args) { - Result ret{}; - - uint32_t message_buffer{}; - uint32_t message_buffer_size{}; - Handle session_handle{}; - - message_buffer = Convert(GetArg32(args, 0)); - message_buffer_size = Convert(GetArg32(args, 1)); - session_handle = Convert(GetArg32(args, 2)); - - ret = SendSyncRequestWithUserBuffer64From32(system, message_buffer, message_buffer_size, session_handle); - + uint32_t message_buffer = Convert(GetArg32(args, 0)); + uint32_t message_buffer_size = Convert(GetArg32(args, 1)); + Handle session_handle = Convert(GetArg32(args, 2)); + Result ret = SendSyncRequestWithUserBuffer64From32(system, message_buffer, message_buffer_size, session_handle); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_SendAsyncRequestWithUserBuffer64From32(Core::System& system, std::span args) { - Result ret{}; - + uint32_t message_buffer = Convert(GetArg32(args, 1)); + uint32_t message_buffer_size = Convert(GetArg32(args, 2)); + Handle session_handle = Convert(GetArg32(args, 3)); Handle out_event_handle{}; - uint32_t message_buffer{}; - uint32_t message_buffer_size{}; - Handle session_handle{}; - - message_buffer = Convert(GetArg32(args, 1)); - message_buffer_size = Convert(GetArg32(args, 2)); - session_handle = Convert(GetArg32(args, 3)); - - ret = SendAsyncRequestWithUserBuffer64From32(system, std::addressof(out_event_handle), message_buffer, message_buffer_size, session_handle); - + Result ret = SendAsyncRequestWithUserBuffer64From32(system, std::addressof(out_event_handle), message_buffer, message_buffer_size, session_handle); SetArg32(args, 0, Convert(ret)); SetArg32(args, 1, Convert(out_event_handle)); } static void SvcWrap_GetProcessId64From32(Core::System& system, std::span args) { - Result ret{}; - + Handle process_handle = Convert(GetArg32(args, 1)); uint64_t out_process_id{}; - Handle process_handle{}; - - process_handle = Convert(GetArg32(args, 1)); - - ret = GetProcessId64From32(system, std::addressof(out_process_id), process_handle); - + Result ret = GetProcessId64From32(system, std::addressof(out_process_id), process_handle); SetArg32(args, 0, Convert(ret)); auto out_process_id_scatter = Convert>(out_process_id); SetArg32(args, 1, out_process_id_scatter[0]); @@ -583,15 +356,9 @@ static void SvcWrap_GetProcessId64From32(Core::System& system, std::span args) { - Result ret{}; - + Handle thread_handle = Convert(GetArg32(args, 1)); uint64_t out_thread_id{}; - Handle thread_handle{}; - - thread_handle = Convert(GetArg32(args, 1)); - - ret = GetThreadId64From32(system, std::addressof(out_thread_id), thread_handle); - + Result ret = GetThreadId64From32(system, std::addressof(out_thread_id), thread_handle); SetArg32(args, 0, Convert(ret)); auto out_thread_id_scatter = Convert>(out_thread_id); SetArg32(args, 1, out_thread_id_scatter[0]); @@ -599,56 +366,33 @@ static void SvcWrap_GetThreadId64From32(Core::System& system, std::span args) { - BreakReason break_reason{}; - uint32_t arg{}; - uint32_t size{}; - - break_reason = Convert(GetArg32(args, 0)); - arg = Convert(GetArg32(args, 1)); - size = Convert(GetArg32(args, 2)); - + BreakReason break_reason = Convert(GetArg32(args, 0)); + uint32_t arg = Convert(GetArg32(args, 1)); + uint32_t size = Convert(GetArg32(args, 2)); Break64From32(system, break_reason, arg, size); } static void SvcWrap_OutputDebugString64From32(Core::System& system, std::span args) { - Result ret{}; - - uint32_t debug_str{}; - uint32_t len{}; - - debug_str = Convert(GetArg32(args, 0)); - len = Convert(GetArg32(args, 1)); - - ret = OutputDebugString64From32(system, debug_str, len); - + uint32_t debug_str = Convert(GetArg32(args, 0)); + uint32_t len = Convert(GetArg32(args, 1)); + Result ret = OutputDebugString64From32(system, debug_str, len); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_ReturnFromException64From32(Core::System& system, std::span args) { - Result result{}; - - result = Convert(GetArg32(args, 0)); - + Result result = Convert(GetArg32(args, 0)); ReturnFromException64From32(system, result); } static void SvcWrap_GetInfo64From32(Core::System& system, std::span args) { - Result ret{}; - - uint64_t out{}; - InfoType info_type{}; - Handle handle{}; - uint64_t info_subtype{}; - - info_type = Convert(GetArg32(args, 1)); - handle = Convert(GetArg32(args, 2)); + InfoType info_type = Convert(GetArg32(args, 1)); + Handle handle = Convert(GetArg32(args, 2)); std::array info_subtype_gather{}; info_subtype_gather[0] = GetArg32(args, 0); info_subtype_gather[1] = GetArg32(args, 3); - info_subtype = Convert(info_subtype_gather); - - ret = GetInfo64From32(system, std::addressof(out), info_type, handle, info_subtype); - + uint64_t info_subtype = Convert(info_subtype_gather); + uint64_t out{}; + Result ret = GetInfo64From32(system, std::addressof(out), info_type, handle, info_subtype); SetArg32(args, 0, Convert(ret)); auto out_scatter = Convert>(out); SetArg32(args, 1, out_scatter[0]); @@ -660,63 +404,35 @@ static void SvcWrap_FlushEntireDataCache64From32(Core::System& system, std::span } static void SvcWrap_FlushDataCache64From32(Core::System& system, std::span args) { - Result ret{}; - - uint32_t address{}; - uint32_t size{}; - - address = Convert(GetArg32(args, 0)); - size = Convert(GetArg32(args, 1)); - - ret = FlushDataCache64From32(system, address, size); - + uint32_t address = Convert(GetArg32(args, 0)); + uint32_t size = Convert(GetArg32(args, 1)); + Result ret = FlushDataCache64From32(system, address, size); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_MapPhysicalMemory64From32(Core::System& system, std::span args) { - Result ret{}; - - uint32_t address{}; - uint32_t size{}; - - address = Convert(GetArg32(args, 0)); - size = Convert(GetArg32(args, 1)); - - ret = MapPhysicalMemory64From32(system, address, size); - + uint32_t address = Convert(GetArg32(args, 0)); + uint32_t size = Convert(GetArg32(args, 1)); + Result ret = MapPhysicalMemory64From32(system, address, size); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_UnmapPhysicalMemory64From32(Core::System& system, std::span args) { - Result ret{}; - - uint32_t address{}; - uint32_t size{}; - - address = Convert(GetArg32(args, 0)); - size = Convert(GetArg32(args, 1)); - - ret = UnmapPhysicalMemory64From32(system, address, size); - + uint32_t address = Convert(GetArg32(args, 0)); + uint32_t size = Convert(GetArg32(args, 1)); + Result ret = UnmapPhysicalMemory64From32(system, address, size); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_GetDebugFutureThreadInfo64From32(Core::System& system, std::span args) { - Result ret{}; - - ilp32::LastThreadContext out_context{}; - uint64_t out_thread_id{}; - Handle debug_handle{}; - int64_t ns{}; - - debug_handle = Convert(GetArg32(args, 2)); + Handle debug_handle = Convert(GetArg32(args, 2)); std::array ns_gather{}; ns_gather[0] = GetArg32(args, 0); ns_gather[1] = GetArg32(args, 1); - ns = Convert(ns_gather); - - ret = GetDebugFutureThreadInfo64From32(system, std::addressof(out_context), std::addressof(out_thread_id), debug_handle, ns); - + int64_t ns = Convert(ns_gather); + ilp32::LastThreadContext out_context{}; + uint64_t out_thread_id{}; + Result ret = GetDebugFutureThreadInfo64From32(system, std::addressof(out_context), std::addressof(out_thread_id), debug_handle, ns); SetArg32(args, 0, Convert(ret)); auto out_context_scatter = Convert>(out_context); SetArg32(args, 1, out_context_scatter[0]); @@ -729,14 +445,10 @@ static void SvcWrap_GetDebugFutureThreadInfo64From32(Core::System& system, std:: } static void SvcWrap_GetLastThreadInfo64From32(Core::System& system, std::span args) { - Result ret{}; - ilp32::LastThreadContext out_context{}; uint64_t out_tls_address{}; uint32_t out_flags{}; - - ret = GetLastThreadInfo64From32(system, std::addressof(out_context), std::addressof(out_tls_address), std::addressof(out_flags)); - + Result ret = GetLastThreadInfo64From32(system, std::addressof(out_context), std::addressof(out_tls_address), std::addressof(out_flags)); SetArg32(args, 0, Convert(ret)); auto out_context_scatter = Convert>(out_context); SetArg32(args, 1, out_context_scatter[0]); @@ -748,17 +460,10 @@ static void SvcWrap_GetLastThreadInfo64From32(Core::System& system, std::span args) { - Result ret{}; - + Handle resource_limit_handle = Convert(GetArg32(args, 1)); + LimitableResource which = Convert(GetArg32(args, 2)); int64_t out_limit_value{}; - Handle resource_limit_handle{}; - LimitableResource which{}; - - resource_limit_handle = Convert(GetArg32(args, 1)); - which = Convert(GetArg32(args, 2)); - - ret = GetResourceLimitLimitValue64From32(system, std::addressof(out_limit_value), resource_limit_handle, which); - + Result ret = GetResourceLimitLimitValue64From32(system, std::addressof(out_limit_value), resource_limit_handle, which); SetArg32(args, 0, Convert(ret)); auto out_limit_value_scatter = Convert>(out_limit_value); SetArg32(args, 1, out_limit_value_scatter[0]); @@ -766,17 +471,10 @@ static void SvcWrap_GetResourceLimitLimitValue64From32(Core::System& system, std } static void SvcWrap_GetResourceLimitCurrentValue64From32(Core::System& system, std::span args) { - Result ret{}; - + Handle resource_limit_handle = Convert(GetArg32(args, 1)); + LimitableResource which = Convert(GetArg32(args, 2)); int64_t out_current_value{}; - Handle resource_limit_handle{}; - LimitableResource which{}; - - resource_limit_handle = Convert(GetArg32(args, 1)); - which = Convert(GetArg32(args, 2)); - - ret = GetResourceLimitCurrentValue64From32(system, std::addressof(out_current_value), resource_limit_handle, which); - + Result ret = GetResourceLimitCurrentValue64From32(system, std::addressof(out_current_value), resource_limit_handle, which); SetArg32(args, 0, Convert(ret)); auto out_current_value_scatter = Convert>(out_current_value); SetArg32(args, 1, out_current_value_scatter[0]); @@ -784,69 +482,37 @@ static void SvcWrap_GetResourceLimitCurrentValue64From32(Core::System& system, s } static void SvcWrap_SetThreadActivity64From32(Core::System& system, std::span args) { - Result ret{}; - - Handle thread_handle{}; - ThreadActivity thread_activity{}; - - thread_handle = Convert(GetArg32(args, 0)); - thread_activity = Convert(GetArg32(args, 1)); - - ret = SetThreadActivity64From32(system, thread_handle, thread_activity); - + Handle thread_handle = Convert(GetArg32(args, 0)); + ThreadActivity thread_activity = Convert(GetArg32(args, 1)); + Result ret = SetThreadActivity64From32(system, thread_handle, thread_activity); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_GetThreadContext364From32(Core::System& system, std::span args) { - Result ret{}; - - uint32_t out_context{}; - Handle thread_handle{}; - - out_context = Convert(GetArg32(args, 0)); - thread_handle = Convert(GetArg32(args, 1)); - - ret = GetThreadContext364From32(system, out_context, thread_handle); - + uint32_t out_context = Convert(GetArg32(args, 0)); + Handle thread_handle = Convert(GetArg32(args, 1)); + Result ret = GetThreadContext364From32(system, out_context, thread_handle); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_WaitForAddress64From32(Core::System& system, std::span args) { - Result ret{}; - - uint32_t address{}; - ArbitrationType arb_type{}; - int32_t value{}; - int64_t timeout_ns{}; - - address = Convert(GetArg32(args, 0)); - arb_type = Convert(GetArg32(args, 1)); - value = Convert(GetArg32(args, 2)); + uint32_t address = Convert(GetArg32(args, 0)); + ArbitrationType arb_type = Convert(GetArg32(args, 1)); + int32_t value = Convert(GetArg32(args, 2)); std::array timeout_ns_gather{}; timeout_ns_gather[0] = GetArg32(args, 3); timeout_ns_gather[1] = GetArg32(args, 4); - timeout_ns = Convert(timeout_ns_gather); - - ret = WaitForAddress64From32(system, address, arb_type, value, timeout_ns); - + int64_t timeout_ns = Convert(timeout_ns_gather); + Result ret = WaitForAddress64From32(system, address, arb_type, value, timeout_ns); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_SignalToAddress64From32(Core::System& system, std::span args) { - Result ret{}; - - uint32_t address{}; - SignalType signal_type{}; - int32_t value{}; - int32_t count{}; - - address = Convert(GetArg32(args, 0)); - signal_type = Convert(GetArg32(args, 1)); - value = Convert(GetArg32(args, 2)); - count = Convert(GetArg32(args, 3)); - - ret = SignalToAddress64From32(system, address, signal_type, value, count); - + uint32_t address = Convert(GetArg32(args, 0)); + SignalType signal_type = Convert(GetArg32(args, 1)); + int32_t value = Convert(GetArg32(args, 2)); + int32_t count = Convert(GetArg32(args, 3)); + Result ret = SignalToAddress64From32(system, address, signal_type, value, count); SetArg32(args, 0, Convert(ret)); } @@ -855,17 +521,10 @@ static void SvcWrap_SynchronizePreemptionState64From32(Core::System& system, std } static void SvcWrap_GetResourceLimitPeakValue64From32(Core::System& system, std::span args) { - Result ret{}; - + Handle resource_limit_handle = Convert(GetArg32(args, 1)); + LimitableResource which = Convert(GetArg32(args, 2)); int64_t out_peak_value{}; - Handle resource_limit_handle{}; - LimitableResource which{}; - - resource_limit_handle = Convert(GetArg32(args, 1)); - which = Convert(GetArg32(args, 2)); - - ret = GetResourceLimitPeakValue64From32(system, std::addressof(out_peak_value), resource_limit_handle, which); - + Result ret = GetResourceLimitPeakValue64From32(system, std::addressof(out_peak_value), resource_limit_handle, which); SetArg32(args, 0, Convert(ret)); auto out_peak_value_scatter = Convert>(out_peak_value); SetArg32(args, 1, out_peak_value_scatter[0]); @@ -873,283 +532,167 @@ static void SvcWrap_GetResourceLimitPeakValue64From32(Core::System& system, std: } static void SvcWrap_CreateIoPool64From32(Core::System& system, std::span args) { - Result ret{}; - + IoPoolType which = Convert(GetArg32(args, 1)); Handle out_handle{}; - IoPoolType which{}; - - which = Convert(GetArg32(args, 1)); - - ret = CreateIoPool64From32(system, std::addressof(out_handle), which); - + Result ret = CreateIoPool64From32(system, std::addressof(out_handle), which); SetArg32(args, 0, Convert(ret)); SetArg32(args, 1, Convert(out_handle)); } static void SvcWrap_CreateIoRegion64From32(Core::System& system, std::span args) { - Result ret{}; - - Handle out_handle{}; - Handle io_pool{}; - uint64_t physical_address{}; - uint32_t size{}; - MemoryMapping mapping{}; - MemoryPermission perm{}; - - io_pool = Convert(GetArg32(args, 1)); + Handle io_pool = Convert(GetArg32(args, 1)); std::array physical_address_gather{}; physical_address_gather[0] = GetArg32(args, 2); physical_address_gather[1] = GetArg32(args, 3); - physical_address = Convert(physical_address_gather); - size = Convert(GetArg32(args, 0)); - mapping = Convert(GetArg32(args, 4)); - perm = Convert(GetArg32(args, 5)); - - ret = CreateIoRegion64From32(system, std::addressof(out_handle), io_pool, physical_address, size, mapping, perm); - + uint64_t physical_address = Convert(physical_address_gather); + uint32_t size = Convert(GetArg32(args, 0)); + MemoryMapping mapping = Convert(GetArg32(args, 4)); + MemoryPermission perm = Convert(GetArg32(args, 5)); + Handle out_handle{}; + Result ret = CreateIoRegion64From32(system, std::addressof(out_handle), io_pool, physical_address, size, mapping, perm); SetArg32(args, 0, Convert(ret)); SetArg32(args, 1, Convert(out_handle)); } static void SvcWrap_KernelDebug64From32(Core::System& system, std::span args) { - KernelDebugType kern_debug_type{}; - uint64_t arg0{}; - uint64_t arg1{}; - uint64_t arg2{}; - - kern_debug_type = Convert(GetArg32(args, 0)); + KernelDebugType kern_debug_type = Convert(GetArg32(args, 0)); std::array arg0_gather{}; arg0_gather[0] = GetArg32(args, 2); arg0_gather[1] = GetArg32(args, 3); - arg0 = Convert(arg0_gather); + uint64_t arg0 = Convert(arg0_gather); std::array arg1_gather{}; arg1_gather[0] = GetArg32(args, 1); arg1_gather[1] = GetArg32(args, 4); - arg1 = Convert(arg1_gather); + uint64_t arg1 = Convert(arg1_gather); std::array arg2_gather{}; arg2_gather[0] = GetArg32(args, 5); arg2_gather[1] = GetArg32(args, 6); - arg2 = Convert(arg2_gather); - + uint64_t arg2 = Convert(arg2_gather); KernelDebug64From32(system, kern_debug_type, arg0, arg1, arg2); } static void SvcWrap_ChangeKernelTraceState64From32(Core::System& system, std::span args) { - KernelTraceState kern_trace_state{}; - - kern_trace_state = Convert(GetArg32(args, 0)); - + KernelTraceState kern_trace_state = Convert(GetArg32(args, 0)); ChangeKernelTraceState64From32(system, kern_trace_state); } static void SvcWrap_CreateSession64From32(Core::System& system, std::span args) { - Result ret{}; - + bool is_light = Convert(GetArg32(args, 2)); + uint32_t name = Convert(GetArg32(args, 3)); Handle out_server_session_handle{}; Handle out_client_session_handle{}; - bool is_light{}; - uint32_t name{}; - - is_light = Convert(GetArg32(args, 2)); - name = Convert(GetArg32(args, 3)); - - ret = CreateSession64From32(system, std::addressof(out_server_session_handle), std::addressof(out_client_session_handle), is_light, name); - + Result ret = CreateSession64From32(system, std::addressof(out_server_session_handle), std::addressof(out_client_session_handle), is_light, name); SetArg32(args, 0, Convert(ret)); SetArg32(args, 1, Convert(out_server_session_handle)); SetArg32(args, 2, Convert(out_client_session_handle)); } static void SvcWrap_AcceptSession64From32(Core::System& system, std::span args) { - Result ret{}; - + Handle port = Convert(GetArg32(args, 1)); Handle out_handle{}; - Handle port{}; - - port = Convert(GetArg32(args, 1)); - - ret = AcceptSession64From32(system, std::addressof(out_handle), port); - + Result ret = AcceptSession64From32(system, std::addressof(out_handle), port); SetArg32(args, 0, Convert(ret)); SetArg32(args, 1, Convert(out_handle)); } static void SvcWrap_ReplyAndReceive64From32(Core::System& system, std::span args) { - Result ret{}; - - int32_t out_index{}; - uint32_t handles{}; - int32_t num_handles{}; - Handle reply_target{}; - int64_t timeout_ns{}; - - handles = Convert(GetArg32(args, 1)); - num_handles = Convert(GetArg32(args, 2)); - reply_target = Convert(GetArg32(args, 3)); + uint32_t handles = Convert(GetArg32(args, 1)); + int32_t num_handles = Convert(GetArg32(args, 2)); + Handle reply_target = Convert(GetArg32(args, 3)); std::array timeout_ns_gather{}; timeout_ns_gather[0] = GetArg32(args, 0); timeout_ns_gather[1] = GetArg32(args, 4); - timeout_ns = Convert(timeout_ns_gather); - - ret = ReplyAndReceive64From32(system, std::addressof(out_index), handles, num_handles, reply_target, timeout_ns); - + int64_t timeout_ns = Convert(timeout_ns_gather); + int32_t out_index{}; + Result ret = ReplyAndReceive64From32(system, std::addressof(out_index), handles, num_handles, reply_target, timeout_ns); SetArg32(args, 0, Convert(ret)); SetArg32(args, 1, Convert(out_index)); } static void SvcWrap_ReplyAndReceiveWithUserBuffer64From32(Core::System& system, std::span args) { - Result ret{}; - - int32_t out_index{}; - uint32_t message_buffer{}; - uint32_t message_buffer_size{}; - uint32_t handles{}; - int32_t num_handles{}; - Handle reply_target{}; - int64_t timeout_ns{}; - - message_buffer = Convert(GetArg32(args, 1)); - message_buffer_size = Convert(GetArg32(args, 2)); - handles = Convert(GetArg32(args, 3)); - num_handles = Convert(GetArg32(args, 0)); - reply_target = Convert(GetArg32(args, 4)); + uint32_t message_buffer = Convert(GetArg32(args, 1)); + uint32_t message_buffer_size = Convert(GetArg32(args, 2)); + uint32_t handles = Convert(GetArg32(args, 3)); + int32_t num_handles = Convert(GetArg32(args, 0)); + Handle reply_target = Convert(GetArg32(args, 4)); std::array timeout_ns_gather{}; timeout_ns_gather[0] = GetArg32(args, 5); timeout_ns_gather[1] = GetArg32(args, 6); - timeout_ns = Convert(timeout_ns_gather); - - ret = ReplyAndReceiveWithUserBuffer64From32(system, std::addressof(out_index), message_buffer, message_buffer_size, handles, num_handles, reply_target, timeout_ns); - + int64_t timeout_ns = Convert(timeout_ns_gather); + int32_t out_index{}; + Result ret = ReplyAndReceiveWithUserBuffer64From32(system, std::addressof(out_index), message_buffer, message_buffer_size, handles, num_handles, reply_target, timeout_ns); SetArg32(args, 0, Convert(ret)); SetArg32(args, 1, Convert(out_index)); } static void SvcWrap_CreateEvent64From32(Core::System& system, std::span args) { - Result ret{}; - Handle out_write_handle{}; Handle out_read_handle{}; - - ret = CreateEvent64From32(system, std::addressof(out_write_handle), std::addressof(out_read_handle)); - + Result ret = CreateEvent64From32(system, std::addressof(out_write_handle), std::addressof(out_read_handle)); SetArg32(args, 0, Convert(ret)); SetArg32(args, 1, Convert(out_write_handle)); SetArg32(args, 2, Convert(out_read_handle)); } static void SvcWrap_MapIoRegion64From32(Core::System& system, std::span args) { - Result ret{}; - - Handle io_region{}; - uint32_t address{}; - uint32_t size{}; - MemoryPermission perm{}; - - io_region = Convert(GetArg32(args, 0)); - address = Convert(GetArg32(args, 1)); - size = Convert(GetArg32(args, 2)); - perm = Convert(GetArg32(args, 3)); - - ret = MapIoRegion64From32(system, io_region, address, size, perm); - + Handle io_region = Convert(GetArg32(args, 0)); + uint32_t address = Convert(GetArg32(args, 1)); + uint32_t size = Convert(GetArg32(args, 2)); + MemoryPermission perm = Convert(GetArg32(args, 3)); + Result ret = MapIoRegion64From32(system, io_region, address, size, perm); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_UnmapIoRegion64From32(Core::System& system, std::span args) { - Result ret{}; - - Handle io_region{}; - uint32_t address{}; - uint32_t size{}; - - io_region = Convert(GetArg32(args, 0)); - address = Convert(GetArg32(args, 1)); - size = Convert(GetArg32(args, 2)); - - ret = UnmapIoRegion64From32(system, io_region, address, size); - + Handle io_region = Convert(GetArg32(args, 0)); + uint32_t address = Convert(GetArg32(args, 1)); + uint32_t size = Convert(GetArg32(args, 2)); + Result ret = UnmapIoRegion64From32(system, io_region, address, size); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_MapPhysicalMemoryUnsafe64From32(Core::System& system, std::span args) { - Result ret{}; - - uint32_t address{}; - uint32_t size{}; - - address = Convert(GetArg32(args, 0)); - size = Convert(GetArg32(args, 1)); - - ret = MapPhysicalMemoryUnsafe64From32(system, address, size); - + uint32_t address = Convert(GetArg32(args, 0)); + uint32_t size = Convert(GetArg32(args, 1)); + Result ret = MapPhysicalMemoryUnsafe64From32(system, address, size); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_UnmapPhysicalMemoryUnsafe64From32(Core::System& system, std::span args) { - Result ret{}; - - uint32_t address{}; - uint32_t size{}; - - address = Convert(GetArg32(args, 0)); - size = Convert(GetArg32(args, 1)); - - ret = UnmapPhysicalMemoryUnsafe64From32(system, address, size); - + uint32_t address = Convert(GetArg32(args, 0)); + uint32_t size = Convert(GetArg32(args, 1)); + Result ret = UnmapPhysicalMemoryUnsafe64From32(system, address, size); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_SetUnsafeLimit64From32(Core::System& system, std::span args) { - Result ret{}; - - uint32_t limit{}; - - limit = Convert(GetArg32(args, 0)); - - ret = SetUnsafeLimit64From32(system, limit); - + uint32_t limit = Convert(GetArg32(args, 0)); + Result ret = SetUnsafeLimit64From32(system, limit); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_CreateCodeMemory64From32(Core::System& system, std::span args) { - Result ret{}; - + uint32_t address = Convert(GetArg32(args, 1)); + uint32_t size = Convert(GetArg32(args, 2)); Handle out_handle{}; - uint32_t address{}; - uint32_t size{}; - - address = Convert(GetArg32(args, 1)); - size = Convert(GetArg32(args, 2)); - - ret = CreateCodeMemory64From32(system, std::addressof(out_handle), address, size); - + Result ret = CreateCodeMemory64From32(system, std::addressof(out_handle), address, size); SetArg32(args, 0, Convert(ret)); SetArg32(args, 1, Convert(out_handle)); } static void SvcWrap_ControlCodeMemory64From32(Core::System& system, std::span args) { - Result ret{}; - - Handle code_memory_handle{}; - CodeMemoryOperation operation{}; - uint64_t address{}; - uint64_t size{}; - MemoryPermission perm{}; - - code_memory_handle = Convert(GetArg32(args, 0)); - operation = Convert(GetArg32(args, 1)); + Handle code_memory_handle = Convert(GetArg32(args, 0)); + CodeMemoryOperation operation = Convert(GetArg32(args, 1)); std::array address_gather{}; address_gather[0] = GetArg32(args, 2); address_gather[1] = GetArg32(args, 3); - address = Convert(address_gather); + uint64_t address = Convert(address_gather); std::array size_gather{}; size_gather[0] = GetArg32(args, 4); size_gather[1] = GetArg32(args, 5); - size = Convert(size_gather); - perm = Convert(GetArg32(args, 6)); - - ret = ControlCodeMemory64From32(system, code_memory_handle, operation, address, size, perm); - + uint64_t size = Convert(size_gather); + MemoryPermission perm = Convert(GetArg32(args, 6)); + Result ret = ControlCodeMemory64From32(system, code_memory_handle, operation, address, size, perm); SetArg32(args, 0, Convert(ret)); } @@ -1158,118 +701,65 @@ static void SvcWrap_SleepSystem64From32(Core::System& system, std::span args) { - Result ret{}; - - uint32_t out_value{}; - uint64_t address{}; - uint32_t mask{}; - uint32_t value{}; - std::array address_gather{}; address_gather[0] = GetArg32(args, 2); address_gather[1] = GetArg32(args, 3); - address = Convert(address_gather); - mask = Convert(GetArg32(args, 0)); - value = Convert(GetArg32(args, 1)); - - ret = ReadWriteRegister64From32(system, std::addressof(out_value), address, mask, value); - + uint64_t address = Convert(address_gather); + uint32_t mask = Convert(GetArg32(args, 0)); + uint32_t value = Convert(GetArg32(args, 1)); + uint32_t out_value{}; + Result ret = ReadWriteRegister64From32(system, std::addressof(out_value), address, mask, value); SetArg32(args, 0, Convert(ret)); SetArg32(args, 1, Convert(out_value)); } static void SvcWrap_SetProcessActivity64From32(Core::System& system, std::span args) { - Result ret{}; - - Handle process_handle{}; - ProcessActivity process_activity{}; - - process_handle = Convert(GetArg32(args, 0)); - process_activity = Convert(GetArg32(args, 1)); - - ret = SetProcessActivity64From32(system, process_handle, process_activity); - + Handle process_handle = Convert(GetArg32(args, 0)); + ProcessActivity process_activity = Convert(GetArg32(args, 1)); + Result ret = SetProcessActivity64From32(system, process_handle, process_activity); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_CreateSharedMemory64From32(Core::System& system, std::span args) { - Result ret{}; - + uint32_t size = Convert(GetArg32(args, 1)); + MemoryPermission owner_perm = Convert(GetArg32(args, 2)); + MemoryPermission remote_perm = Convert(GetArg32(args, 3)); Handle out_handle{}; - uint32_t size{}; - MemoryPermission owner_perm{}; - MemoryPermission remote_perm{}; - - size = Convert(GetArg32(args, 1)); - owner_perm = Convert(GetArg32(args, 2)); - remote_perm = Convert(GetArg32(args, 3)); - - ret = CreateSharedMemory64From32(system, std::addressof(out_handle), size, owner_perm, remote_perm); - + Result ret = CreateSharedMemory64From32(system, std::addressof(out_handle), size, owner_perm, remote_perm); SetArg32(args, 0, Convert(ret)); SetArg32(args, 1, Convert(out_handle)); } static void SvcWrap_MapTransferMemory64From32(Core::System& system, std::span args) { - Result ret{}; - - Handle trmem_handle{}; - uint32_t address{}; - uint32_t size{}; - MemoryPermission owner_perm{}; - - trmem_handle = Convert(GetArg32(args, 0)); - address = Convert(GetArg32(args, 1)); - size = Convert(GetArg32(args, 2)); - owner_perm = Convert(GetArg32(args, 3)); - - ret = MapTransferMemory64From32(system, trmem_handle, address, size, owner_perm); - + Handle trmem_handle = Convert(GetArg32(args, 0)); + uint32_t address = Convert(GetArg32(args, 1)); + uint32_t size = Convert(GetArg32(args, 2)); + MemoryPermission owner_perm = Convert(GetArg32(args, 3)); + Result ret = MapTransferMemory64From32(system, trmem_handle, address, size, owner_perm); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_UnmapTransferMemory64From32(Core::System& system, std::span args) { - Result ret{}; - - Handle trmem_handle{}; - uint32_t address{}; - uint32_t size{}; - - trmem_handle = Convert(GetArg32(args, 0)); - address = Convert(GetArg32(args, 1)); - size = Convert(GetArg32(args, 2)); - - ret = UnmapTransferMemory64From32(system, trmem_handle, address, size); - + Handle trmem_handle = Convert(GetArg32(args, 0)); + uint32_t address = Convert(GetArg32(args, 1)); + uint32_t size = Convert(GetArg32(args, 2)); + Result ret = UnmapTransferMemory64From32(system, trmem_handle, address, size); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_CreateInterruptEvent64From32(Core::System& system, std::span args) { - Result ret{}; - + int32_t interrupt_id = Convert(GetArg32(args, 1)); + InterruptType interrupt_type = Convert(GetArg32(args, 2)); Handle out_read_handle{}; - int32_t interrupt_id{}; - InterruptType interrupt_type{}; - - interrupt_id = Convert(GetArg32(args, 1)); - interrupt_type = Convert(GetArg32(args, 2)); - - ret = CreateInterruptEvent64From32(system, std::addressof(out_read_handle), interrupt_id, interrupt_type); - + Result ret = CreateInterruptEvent64From32(system, std::addressof(out_read_handle), interrupt_id, interrupt_type); SetArg32(args, 0, Convert(ret)); SetArg32(args, 1, Convert(out_read_handle)); } static void SvcWrap_QueryPhysicalAddress64From32(Core::System& system, std::span args) { - Result ret{}; - + uint32_t address = Convert(GetArg32(args, 1)); ilp32::PhysicalMemoryInfo out_info{}; - uint32_t address{}; - - address = Convert(GetArg32(args, 1)); - - ret = QueryPhysicalAddress64From32(system, std::addressof(out_info), address); - + Result ret = QueryPhysicalAddress64From32(system, std::addressof(out_info), address); SetArg32(args, 0, Convert(ret)); auto out_info_scatter = Convert>(out_info); SetArg32(args, 1, out_info_scatter[0]); @@ -1279,467 +769,274 @@ static void SvcWrap_QueryPhysicalAddress64From32(Core::System& system, std::span } static void SvcWrap_QueryIoMapping64From32(Core::System& system, std::span args) { - Result ret{}; - - uint64_t out_address{}; - uint64_t out_size{}; - uint64_t physical_address{}; - uint32_t size{}; - std::array physical_address_gather{}; physical_address_gather[0] = GetArg32(args, 2); physical_address_gather[1] = GetArg32(args, 3); - physical_address = Convert(physical_address_gather); - size = Convert(GetArg32(args, 0)); - - ret = QueryIoMapping64From32(system, std::addressof(out_address), std::addressof(out_size), physical_address, size); - + uint64_t physical_address = Convert(physical_address_gather); + uint32_t size = Convert(GetArg32(args, 0)); + uint64_t out_address{}; + uint64_t out_size{}; + Result ret = QueryIoMapping64From32(system, std::addressof(out_address), std::addressof(out_size), physical_address, size); SetArg32(args, 0, Convert(ret)); SetArg32(args, 1, Convert(out_address)); SetArg32(args, 2, Convert(out_size)); } static void SvcWrap_CreateDeviceAddressSpace64From32(Core::System& system, std::span args) { - Result ret{}; - - Handle out_handle{}; - uint64_t das_address{}; - uint64_t das_size{}; - std::array das_address_gather{}; das_address_gather[0] = GetArg32(args, 2); das_address_gather[1] = GetArg32(args, 3); - das_address = Convert(das_address_gather); + uint64_t das_address = Convert(das_address_gather); std::array das_size_gather{}; das_size_gather[0] = GetArg32(args, 0); das_size_gather[1] = GetArg32(args, 1); - das_size = Convert(das_size_gather); - - ret = CreateDeviceAddressSpace64From32(system, std::addressof(out_handle), das_address, das_size); - + uint64_t das_size = Convert(das_size_gather); + Handle out_handle{}; + Result ret = CreateDeviceAddressSpace64From32(system, std::addressof(out_handle), das_address, das_size); SetArg32(args, 0, Convert(ret)); SetArg32(args, 1, Convert(out_handle)); } static void SvcWrap_AttachDeviceAddressSpace64From32(Core::System& system, std::span args) { - Result ret{}; - - DeviceName device_name{}; - Handle das_handle{}; - - device_name = Convert(GetArg32(args, 0)); - das_handle = Convert(GetArg32(args, 1)); - - ret = AttachDeviceAddressSpace64From32(system, device_name, das_handle); - + DeviceName device_name = Convert(GetArg32(args, 0)); + Handle das_handle = Convert(GetArg32(args, 1)); + Result ret = AttachDeviceAddressSpace64From32(system, device_name, das_handle); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_DetachDeviceAddressSpace64From32(Core::System& system, std::span args) { - Result ret{}; - - DeviceName device_name{}; - Handle das_handle{}; - - device_name = Convert(GetArg32(args, 0)); - das_handle = Convert(GetArg32(args, 1)); - - ret = DetachDeviceAddressSpace64From32(system, device_name, das_handle); - + DeviceName device_name = Convert(GetArg32(args, 0)); + Handle das_handle = Convert(GetArg32(args, 1)); + Result ret = DetachDeviceAddressSpace64From32(system, device_name, das_handle); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_MapDeviceAddressSpaceByForce64From32(Core::System& system, std::span args) { - Result ret{}; - - Handle das_handle{}; - Handle process_handle{}; - uint64_t process_address{}; - uint32_t size{}; - uint64_t device_address{}; - uint32_t option{}; - - das_handle = Convert(GetArg32(args, 0)); - process_handle = Convert(GetArg32(args, 1)); + Handle das_handle = Convert(GetArg32(args, 0)); + Handle process_handle = Convert(GetArg32(args, 1)); std::array process_address_gather{}; process_address_gather[0] = GetArg32(args, 2); process_address_gather[1] = GetArg32(args, 3); - process_address = Convert(process_address_gather); - size = Convert(GetArg32(args, 4)); + uint64_t process_address = Convert(process_address_gather); + uint32_t size = Convert(GetArg32(args, 4)); std::array device_address_gather{}; device_address_gather[0] = GetArg32(args, 5); device_address_gather[1] = GetArg32(args, 6); - device_address = Convert(device_address_gather); - option = Convert(GetArg32(args, 7)); - - ret = MapDeviceAddressSpaceByForce64From32(system, das_handle, process_handle, process_address, size, device_address, option); - + uint64_t device_address = Convert(device_address_gather); + uint32_t option = Convert(GetArg32(args, 7)); + Result ret = MapDeviceAddressSpaceByForce64From32(system, das_handle, process_handle, process_address, size, device_address, option); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_MapDeviceAddressSpaceAligned64From32(Core::System& system, std::span args) { - Result ret{}; - - Handle das_handle{}; - Handle process_handle{}; - uint64_t process_address{}; - uint32_t size{}; - uint64_t device_address{}; - uint32_t option{}; - - das_handle = Convert(GetArg32(args, 0)); - process_handle = Convert(GetArg32(args, 1)); + Handle das_handle = Convert(GetArg32(args, 0)); + Handle process_handle = Convert(GetArg32(args, 1)); std::array process_address_gather{}; process_address_gather[0] = GetArg32(args, 2); process_address_gather[1] = GetArg32(args, 3); - process_address = Convert(process_address_gather); - size = Convert(GetArg32(args, 4)); + uint64_t process_address = Convert(process_address_gather); + uint32_t size = Convert(GetArg32(args, 4)); std::array device_address_gather{}; device_address_gather[0] = GetArg32(args, 5); device_address_gather[1] = GetArg32(args, 6); - device_address = Convert(device_address_gather); - option = Convert(GetArg32(args, 7)); - - ret = MapDeviceAddressSpaceAligned64From32(system, das_handle, process_handle, process_address, size, device_address, option); - + uint64_t device_address = Convert(device_address_gather); + uint32_t option = Convert(GetArg32(args, 7)); + Result ret = MapDeviceAddressSpaceAligned64From32(system, das_handle, process_handle, process_address, size, device_address, option); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_UnmapDeviceAddressSpace64From32(Core::System& system, std::span args) { - Result ret{}; - - Handle das_handle{}; - Handle process_handle{}; - uint64_t process_address{}; - uint32_t size{}; - uint64_t device_address{}; - - das_handle = Convert(GetArg32(args, 0)); - process_handle = Convert(GetArg32(args, 1)); + Handle das_handle = Convert(GetArg32(args, 0)); + Handle process_handle = Convert(GetArg32(args, 1)); std::array process_address_gather{}; process_address_gather[0] = GetArg32(args, 2); process_address_gather[1] = GetArg32(args, 3); - process_address = Convert(process_address_gather); - size = Convert(GetArg32(args, 4)); + uint64_t process_address = Convert(process_address_gather); + uint32_t size = Convert(GetArg32(args, 4)); std::array device_address_gather{}; device_address_gather[0] = GetArg32(args, 5); device_address_gather[1] = GetArg32(args, 6); - device_address = Convert(device_address_gather); - - ret = UnmapDeviceAddressSpace64From32(system, das_handle, process_handle, process_address, size, device_address); - + uint64_t device_address = Convert(device_address_gather); + Result ret = UnmapDeviceAddressSpace64From32(system, das_handle, process_handle, process_address, size, device_address); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_InvalidateProcessDataCache64From32(Core::System& system, std::span args) { - Result ret{}; - - Handle process_handle{}; - uint64_t address{}; - uint64_t size{}; - - process_handle = Convert(GetArg32(args, 0)); + Handle process_handle = Convert(GetArg32(args, 0)); std::array address_gather{}; address_gather[0] = GetArg32(args, 2); address_gather[1] = GetArg32(args, 3); - address = Convert(address_gather); + uint64_t address = Convert(address_gather); std::array size_gather{}; size_gather[0] = GetArg32(args, 1); size_gather[1] = GetArg32(args, 4); - size = Convert(size_gather); - - ret = InvalidateProcessDataCache64From32(system, process_handle, address, size); - + uint64_t size = Convert(size_gather); + Result ret = InvalidateProcessDataCache64From32(system, process_handle, address, size); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_StoreProcessDataCache64From32(Core::System& system, std::span args) { - Result ret{}; - - Handle process_handle{}; - uint64_t address{}; - uint64_t size{}; - - process_handle = Convert(GetArg32(args, 0)); + Handle process_handle = Convert(GetArg32(args, 0)); std::array address_gather{}; address_gather[0] = GetArg32(args, 2); address_gather[1] = GetArg32(args, 3); - address = Convert(address_gather); + uint64_t address = Convert(address_gather); std::array size_gather{}; size_gather[0] = GetArg32(args, 1); size_gather[1] = GetArg32(args, 4); - size = Convert(size_gather); - - ret = StoreProcessDataCache64From32(system, process_handle, address, size); - + uint64_t size = Convert(size_gather); + Result ret = StoreProcessDataCache64From32(system, process_handle, address, size); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_FlushProcessDataCache64From32(Core::System& system, std::span args) { - Result ret{}; - - Handle process_handle{}; - uint64_t address{}; - uint64_t size{}; - - process_handle = Convert(GetArg32(args, 0)); + Handle process_handle = Convert(GetArg32(args, 0)); std::array address_gather{}; address_gather[0] = GetArg32(args, 2); address_gather[1] = GetArg32(args, 3); - address = Convert(address_gather); + uint64_t address = Convert(address_gather); std::array size_gather{}; size_gather[0] = GetArg32(args, 1); size_gather[1] = GetArg32(args, 4); - size = Convert(size_gather); - - ret = FlushProcessDataCache64From32(system, process_handle, address, size); - + uint64_t size = Convert(size_gather); + Result ret = FlushProcessDataCache64From32(system, process_handle, address, size); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_DebugActiveProcess64From32(Core::System& system, std::span args) { - Result ret{}; - - Handle out_handle{}; - uint64_t process_id{}; - std::array process_id_gather{}; process_id_gather[0] = GetArg32(args, 2); process_id_gather[1] = GetArg32(args, 3); - process_id = Convert(process_id_gather); - - ret = DebugActiveProcess64From32(system, std::addressof(out_handle), process_id); - + uint64_t process_id = Convert(process_id_gather); + Handle out_handle{}; + Result ret = DebugActiveProcess64From32(system, std::addressof(out_handle), process_id); SetArg32(args, 0, Convert(ret)); SetArg32(args, 1, Convert(out_handle)); } static void SvcWrap_BreakDebugProcess64From32(Core::System& system, std::span args) { - Result ret{}; - - Handle debug_handle{}; - - debug_handle = Convert(GetArg32(args, 0)); - - ret = BreakDebugProcess64From32(system, debug_handle); - + Handle debug_handle = Convert(GetArg32(args, 0)); + Result ret = BreakDebugProcess64From32(system, debug_handle); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_TerminateDebugProcess64From32(Core::System& system, std::span args) { - Result ret{}; - - Handle debug_handle{}; - - debug_handle = Convert(GetArg32(args, 0)); - - ret = TerminateDebugProcess64From32(system, debug_handle); - + Handle debug_handle = Convert(GetArg32(args, 0)); + Result ret = TerminateDebugProcess64From32(system, debug_handle); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_GetDebugEvent64From32(Core::System& system, std::span args) { - Result ret{}; - - uint32_t out_info{}; - Handle debug_handle{}; - - out_info = Convert(GetArg32(args, 0)); - debug_handle = Convert(GetArg32(args, 1)); - - ret = GetDebugEvent64From32(system, out_info, debug_handle); - + uint32_t out_info = Convert(GetArg32(args, 0)); + Handle debug_handle = Convert(GetArg32(args, 1)); + Result ret = GetDebugEvent64From32(system, out_info, debug_handle); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_ContinueDebugEvent64From32(Core::System& system, std::span args) { - Result ret{}; - - Handle debug_handle{}; - uint32_t flags{}; - uint32_t thread_ids{}; - int32_t num_thread_ids{}; - - debug_handle = Convert(GetArg32(args, 0)); - flags = Convert(GetArg32(args, 1)); - thread_ids = Convert(GetArg32(args, 2)); - num_thread_ids = Convert(GetArg32(args, 3)); - - ret = ContinueDebugEvent64From32(system, debug_handle, flags, thread_ids, num_thread_ids); - + Handle debug_handle = Convert(GetArg32(args, 0)); + uint32_t flags = Convert(GetArg32(args, 1)); + uint32_t thread_ids = Convert(GetArg32(args, 2)); + int32_t num_thread_ids = Convert(GetArg32(args, 3)); + Result ret = ContinueDebugEvent64From32(system, debug_handle, flags, thread_ids, num_thread_ids); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_GetProcessList64From32(Core::System& system, std::span args) { - Result ret{}; - + uint32_t out_process_ids = Convert(GetArg32(args, 1)); + int32_t max_out_count = Convert(GetArg32(args, 2)); int32_t out_num_processes{}; - uint32_t out_process_ids{}; - int32_t max_out_count{}; - - out_process_ids = Convert(GetArg32(args, 1)); - max_out_count = Convert(GetArg32(args, 2)); - - ret = GetProcessList64From32(system, std::addressof(out_num_processes), out_process_ids, max_out_count); - + Result ret = GetProcessList64From32(system, std::addressof(out_num_processes), out_process_ids, max_out_count); SetArg32(args, 0, Convert(ret)); SetArg32(args, 1, Convert(out_num_processes)); } static void SvcWrap_GetThreadList64From32(Core::System& system, std::span args) { - Result ret{}; - + uint32_t out_thread_ids = Convert(GetArg32(args, 1)); + int32_t max_out_count = Convert(GetArg32(args, 2)); + Handle debug_handle = Convert(GetArg32(args, 3)); int32_t out_num_threads{}; - uint32_t out_thread_ids{}; - int32_t max_out_count{}; - Handle debug_handle{}; - - out_thread_ids = Convert(GetArg32(args, 1)); - max_out_count = Convert(GetArg32(args, 2)); - debug_handle = Convert(GetArg32(args, 3)); - - ret = GetThreadList64From32(system, std::addressof(out_num_threads), out_thread_ids, max_out_count, debug_handle); - + Result ret = GetThreadList64From32(system, std::addressof(out_num_threads), out_thread_ids, max_out_count, debug_handle); SetArg32(args, 0, Convert(ret)); SetArg32(args, 1, Convert(out_num_threads)); } static void SvcWrap_GetDebugThreadContext64From32(Core::System& system, std::span args) { - Result ret{}; - - uint32_t out_context{}; - Handle debug_handle{}; - uint64_t thread_id{}; - uint32_t context_flags{}; - - out_context = Convert(GetArg32(args, 0)); - debug_handle = Convert(GetArg32(args, 1)); + uint32_t out_context = Convert(GetArg32(args, 0)); + Handle debug_handle = Convert(GetArg32(args, 1)); std::array thread_id_gather{}; thread_id_gather[0] = GetArg32(args, 2); thread_id_gather[1] = GetArg32(args, 3); - thread_id = Convert(thread_id_gather); - context_flags = Convert(GetArg32(args, 4)); - - ret = GetDebugThreadContext64From32(system, out_context, debug_handle, thread_id, context_flags); - + uint64_t thread_id = Convert(thread_id_gather); + uint32_t context_flags = Convert(GetArg32(args, 4)); + Result ret = GetDebugThreadContext64From32(system, out_context, debug_handle, thread_id, context_flags); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_SetDebugThreadContext64From32(Core::System& system, std::span args) { - Result ret{}; - - Handle debug_handle{}; - uint64_t thread_id{}; - uint32_t context{}; - uint32_t context_flags{}; - - debug_handle = Convert(GetArg32(args, 0)); + Handle debug_handle = Convert(GetArg32(args, 0)); std::array thread_id_gather{}; thread_id_gather[0] = GetArg32(args, 2); thread_id_gather[1] = GetArg32(args, 3); - thread_id = Convert(thread_id_gather); - context = Convert(GetArg32(args, 1)); - context_flags = Convert(GetArg32(args, 4)); - - ret = SetDebugThreadContext64From32(system, debug_handle, thread_id, context, context_flags); - + uint64_t thread_id = Convert(thread_id_gather); + uint32_t context = Convert(GetArg32(args, 1)); + uint32_t context_flags = Convert(GetArg32(args, 4)); + Result ret = SetDebugThreadContext64From32(system, debug_handle, thread_id, context, context_flags); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_QueryDebugProcessMemory64From32(Core::System& system, std::span args) { - Result ret{}; - + uint32_t out_memory_info = Convert(GetArg32(args, 0)); + Handle process_handle = Convert(GetArg32(args, 2)); + uint32_t address = Convert(GetArg32(args, 3)); PageInfo out_page_info{}; - uint32_t out_memory_info{}; - Handle process_handle{}; - uint32_t address{}; - - out_memory_info = Convert(GetArg32(args, 0)); - process_handle = Convert(GetArg32(args, 2)); - address = Convert(GetArg32(args, 3)); - - ret = QueryDebugProcessMemory64From32(system, out_memory_info, std::addressof(out_page_info), process_handle, address); - + Result ret = QueryDebugProcessMemory64From32(system, out_memory_info, std::addressof(out_page_info), process_handle, address); SetArg32(args, 0, Convert(ret)); SetArg32(args, 1, Convert(out_page_info)); } static void SvcWrap_ReadDebugProcessMemory64From32(Core::System& system, std::span args) { - Result ret{}; - - uint32_t buffer{}; - Handle debug_handle{}; - uint32_t address{}; - uint32_t size{}; - - buffer = Convert(GetArg32(args, 0)); - debug_handle = Convert(GetArg32(args, 1)); - address = Convert(GetArg32(args, 2)); - size = Convert(GetArg32(args, 3)); - - ret = ReadDebugProcessMemory64From32(system, buffer, debug_handle, address, size); - + uint32_t buffer = Convert(GetArg32(args, 0)); + Handle debug_handle = Convert(GetArg32(args, 1)); + uint32_t address = Convert(GetArg32(args, 2)); + uint32_t size = Convert(GetArg32(args, 3)); + Result ret = ReadDebugProcessMemory64From32(system, buffer, debug_handle, address, size); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_WriteDebugProcessMemory64From32(Core::System& system, std::span args) { - Result ret{}; - - Handle debug_handle{}; - uint32_t buffer{}; - uint32_t address{}; - uint32_t size{}; - - debug_handle = Convert(GetArg32(args, 0)); - buffer = Convert(GetArg32(args, 1)); - address = Convert(GetArg32(args, 2)); - size = Convert(GetArg32(args, 3)); - - ret = WriteDebugProcessMemory64From32(system, debug_handle, buffer, address, size); - + Handle debug_handle = Convert(GetArg32(args, 0)); + uint32_t buffer = Convert(GetArg32(args, 1)); + uint32_t address = Convert(GetArg32(args, 2)); + uint32_t size = Convert(GetArg32(args, 3)); + Result ret = WriteDebugProcessMemory64From32(system, debug_handle, buffer, address, size); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_SetHardwareBreakPoint64From32(Core::System& system, std::span args) { - Result ret{}; - - HardwareBreakPointRegisterName name{}; - uint64_t flags{}; - uint64_t value{}; - - name = Convert(GetArg32(args, 0)); + HardwareBreakPointRegisterName name = Convert(GetArg32(args, 0)); std::array flags_gather{}; flags_gather[0] = GetArg32(args, 2); flags_gather[1] = GetArg32(args, 3); - flags = Convert(flags_gather); + uint64_t flags = Convert(flags_gather); std::array value_gather{}; value_gather[0] = GetArg32(args, 1); value_gather[1] = GetArg32(args, 4); - value = Convert(value_gather); - - ret = SetHardwareBreakPoint64From32(system, name, flags, value); - + uint64_t value = Convert(value_gather); + Result ret = SetHardwareBreakPoint64From32(system, name, flags, value); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_GetDebugThreadParam64From32(Core::System& system, std::span args) { - Result ret{}; - - uint64_t out_64{}; - uint32_t out_32{}; - Handle debug_handle{}; - uint64_t thread_id{}; - DebugThreadParam param{}; - - debug_handle = Convert(GetArg32(args, 2)); + Handle debug_handle = Convert(GetArg32(args, 2)); std::array thread_id_gather{}; thread_id_gather[0] = GetArg32(args, 0); thread_id_gather[1] = GetArg32(args, 1); - thread_id = Convert(thread_id_gather); - param = Convert(GetArg32(args, 3)); - - ret = GetDebugThreadParam64From32(system, std::addressof(out_64), std::addressof(out_32), debug_handle, thread_id, param); - + uint64_t thread_id = Convert(thread_id_gather); + DebugThreadParam param = Convert(GetArg32(args, 3)); + uint64_t out_64{}; + uint32_t out_32{}; + Result ret = GetDebugThreadParam64From32(system, std::addressof(out_64), std::addressof(out_32), debug_handle, thread_id, param); SetArg32(args, 0, Convert(ret)); auto out_64_scatter = Convert>(out_64); SetArg32(args, 1, out_64_scatter[0]); @@ -1748,22 +1045,14 @@ static void SvcWrap_GetDebugThreadParam64From32(Core::System& system, std::span< } static void SvcWrap_GetSystemInfo64From32(Core::System& system, std::span args) { - Result ret{}; - - uint64_t out{}; - SystemInfoType info_type{}; - Handle handle{}; - uint64_t info_subtype{}; - - info_type = Convert(GetArg32(args, 1)); - handle = Convert(GetArg32(args, 2)); + SystemInfoType info_type = Convert(GetArg32(args, 1)); + Handle handle = Convert(GetArg32(args, 2)); std::array info_subtype_gather{}; info_subtype_gather[0] = GetArg32(args, 0); info_subtype_gather[1] = GetArg32(args, 3); - info_subtype = Convert(info_subtype_gather); - - ret = GetSystemInfo64From32(system, std::addressof(out), info_type, handle, info_subtype); - + uint64_t info_subtype = Convert(info_subtype_gather); + uint64_t out{}; + Result ret = GetSystemInfo64From32(system, std::addressof(out), info_type, handle, info_subtype); SetArg32(args, 0, Convert(ret)); auto out_scatter = Convert>(out); SetArg32(args, 1, out_scatter[0]); @@ -1771,259 +1060,155 @@ static void SvcWrap_GetSystemInfo64From32(Core::System& system, std::span args) { - Result ret{}; - + int32_t max_sessions = Convert(GetArg32(args, 2)); + bool is_light = Convert(GetArg32(args, 3)); + uint32_t name = Convert(GetArg32(args, 0)); Handle out_server_handle{}; Handle out_client_handle{}; - int32_t max_sessions{}; - bool is_light{}; - uint32_t name{}; - - max_sessions = Convert(GetArg32(args, 2)); - is_light = Convert(GetArg32(args, 3)); - name = Convert(GetArg32(args, 0)); - - ret = CreatePort64From32(system, std::addressof(out_server_handle), std::addressof(out_client_handle), max_sessions, is_light, name); - + Result ret = CreatePort64From32(system, std::addressof(out_server_handle), std::addressof(out_client_handle), max_sessions, is_light, name); SetArg32(args, 0, Convert(ret)); SetArg32(args, 1, Convert(out_server_handle)); SetArg32(args, 2, Convert(out_client_handle)); } static void SvcWrap_ManageNamedPort64From32(Core::System& system, std::span args) { - Result ret{}; - + uint32_t name = Convert(GetArg32(args, 1)); + int32_t max_sessions = Convert(GetArg32(args, 2)); Handle out_server_handle{}; - uint32_t name{}; - int32_t max_sessions{}; - - name = Convert(GetArg32(args, 1)); - max_sessions = Convert(GetArg32(args, 2)); - - ret = ManageNamedPort64From32(system, std::addressof(out_server_handle), name, max_sessions); - + Result ret = ManageNamedPort64From32(system, std::addressof(out_server_handle), name, max_sessions); SetArg32(args, 0, Convert(ret)); SetArg32(args, 1, Convert(out_server_handle)); } static void SvcWrap_ConnectToPort64From32(Core::System& system, std::span args) { - Result ret{}; - + Handle port = Convert(GetArg32(args, 1)); Handle out_handle{}; - Handle port{}; - - port = Convert(GetArg32(args, 1)); - - ret = ConnectToPort64From32(system, std::addressof(out_handle), port); - + Result ret = ConnectToPort64From32(system, std::addressof(out_handle), port); SetArg32(args, 0, Convert(ret)); SetArg32(args, 1, Convert(out_handle)); } static void SvcWrap_SetProcessMemoryPermission64From32(Core::System& system, std::span args) { - Result ret{}; - - Handle process_handle{}; - uint64_t address{}; - uint64_t size{}; - MemoryPermission perm{}; - - process_handle = Convert(GetArg32(args, 0)); + Handle process_handle = Convert(GetArg32(args, 0)); std::array address_gather{}; address_gather[0] = GetArg32(args, 2); address_gather[1] = GetArg32(args, 3); - address = Convert(address_gather); + uint64_t address = Convert(address_gather); std::array size_gather{}; size_gather[0] = GetArg32(args, 1); size_gather[1] = GetArg32(args, 4); - size = Convert(size_gather); - perm = Convert(GetArg32(args, 5)); - - ret = SetProcessMemoryPermission64From32(system, process_handle, address, size, perm); - + uint64_t size = Convert(size_gather); + MemoryPermission perm = Convert(GetArg32(args, 5)); + Result ret = SetProcessMemoryPermission64From32(system, process_handle, address, size, perm); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_MapProcessMemory64From32(Core::System& system, std::span args) { - Result ret{}; - - uint32_t dst_address{}; - Handle process_handle{}; - uint64_t src_address{}; - uint32_t size{}; - - dst_address = Convert(GetArg32(args, 0)); - process_handle = Convert(GetArg32(args, 1)); + uint32_t dst_address = Convert(GetArg32(args, 0)); + Handle process_handle = Convert(GetArg32(args, 1)); std::array src_address_gather{}; src_address_gather[0] = GetArg32(args, 2); src_address_gather[1] = GetArg32(args, 3); - src_address = Convert(src_address_gather); - size = Convert(GetArg32(args, 4)); - - ret = MapProcessMemory64From32(system, dst_address, process_handle, src_address, size); - + uint64_t src_address = Convert(src_address_gather); + uint32_t size = Convert(GetArg32(args, 4)); + Result ret = MapProcessMemory64From32(system, dst_address, process_handle, src_address, size); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_UnmapProcessMemory64From32(Core::System& system, std::span args) { - Result ret{}; - - uint32_t dst_address{}; - Handle process_handle{}; - uint64_t src_address{}; - uint32_t size{}; - - dst_address = Convert(GetArg32(args, 0)); - process_handle = Convert(GetArg32(args, 1)); + uint32_t dst_address = Convert(GetArg32(args, 0)); + Handle process_handle = Convert(GetArg32(args, 1)); std::array src_address_gather{}; src_address_gather[0] = GetArg32(args, 2); src_address_gather[1] = GetArg32(args, 3); - src_address = Convert(src_address_gather); - size = Convert(GetArg32(args, 4)); - - ret = UnmapProcessMemory64From32(system, dst_address, process_handle, src_address, size); - + uint64_t src_address = Convert(src_address_gather); + uint32_t size = Convert(GetArg32(args, 4)); + Result ret = UnmapProcessMemory64From32(system, dst_address, process_handle, src_address, size); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_QueryProcessMemory64From32(Core::System& system, std::span args) { - Result ret{}; - - PageInfo out_page_info{}; - uint32_t out_memory_info{}; - Handle process_handle{}; - uint64_t address{}; - - out_memory_info = Convert(GetArg32(args, 0)); - process_handle = Convert(GetArg32(args, 2)); + uint32_t out_memory_info = Convert(GetArg32(args, 0)); + Handle process_handle = Convert(GetArg32(args, 2)); std::array address_gather{}; address_gather[0] = GetArg32(args, 1); address_gather[1] = GetArg32(args, 3); - address = Convert(address_gather); - - ret = QueryProcessMemory64From32(system, out_memory_info, std::addressof(out_page_info), process_handle, address); - + uint64_t address = Convert(address_gather); + PageInfo out_page_info{}; + Result ret = QueryProcessMemory64From32(system, out_memory_info, std::addressof(out_page_info), process_handle, address); SetArg32(args, 0, Convert(ret)); SetArg32(args, 1, Convert(out_page_info)); } static void SvcWrap_MapProcessCodeMemory64From32(Core::System& system, std::span args) { - Result ret{}; - - Handle process_handle{}; - uint64_t dst_address{}; - uint64_t src_address{}; - uint64_t size{}; - - process_handle = Convert(GetArg32(args, 0)); + Handle process_handle = Convert(GetArg32(args, 0)); std::array dst_address_gather{}; dst_address_gather[0] = GetArg32(args, 2); dst_address_gather[1] = GetArg32(args, 3); - dst_address = Convert(dst_address_gather); + uint64_t dst_address = Convert(dst_address_gather); std::array src_address_gather{}; src_address_gather[0] = GetArg32(args, 1); src_address_gather[1] = GetArg32(args, 4); - src_address = Convert(src_address_gather); + uint64_t src_address = Convert(src_address_gather); std::array size_gather{}; size_gather[0] = GetArg32(args, 5); size_gather[1] = GetArg32(args, 6); - size = Convert(size_gather); - - ret = MapProcessCodeMemory64From32(system, process_handle, dst_address, src_address, size); - + uint64_t size = Convert(size_gather); + Result ret = MapProcessCodeMemory64From32(system, process_handle, dst_address, src_address, size); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_UnmapProcessCodeMemory64From32(Core::System& system, std::span args) { - Result ret{}; - - Handle process_handle{}; - uint64_t dst_address{}; - uint64_t src_address{}; - uint64_t size{}; - - process_handle = Convert(GetArg32(args, 0)); + Handle process_handle = Convert(GetArg32(args, 0)); std::array dst_address_gather{}; dst_address_gather[0] = GetArg32(args, 2); dst_address_gather[1] = GetArg32(args, 3); - dst_address = Convert(dst_address_gather); + uint64_t dst_address = Convert(dst_address_gather); std::array src_address_gather{}; src_address_gather[0] = GetArg32(args, 1); src_address_gather[1] = GetArg32(args, 4); - src_address = Convert(src_address_gather); + uint64_t src_address = Convert(src_address_gather); std::array size_gather{}; size_gather[0] = GetArg32(args, 5); size_gather[1] = GetArg32(args, 6); - size = Convert(size_gather); - - ret = UnmapProcessCodeMemory64From32(system, process_handle, dst_address, src_address, size); - + uint64_t size = Convert(size_gather); + Result ret = UnmapProcessCodeMemory64From32(system, process_handle, dst_address, src_address, size); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_CreateProcess64From32(Core::System& system, std::span args) { - Result ret{}; - + uint32_t parameters = Convert(GetArg32(args, 1)); + uint32_t caps = Convert(GetArg32(args, 2)); + int32_t num_caps = Convert(GetArg32(args, 3)); Handle out_handle{}; - uint32_t parameters{}; - uint32_t caps{}; - int32_t num_caps{}; - - parameters = Convert(GetArg32(args, 1)); - caps = Convert(GetArg32(args, 2)); - num_caps = Convert(GetArg32(args, 3)); - - ret = CreateProcess64From32(system, std::addressof(out_handle), parameters, caps, num_caps); - + Result ret = CreateProcess64From32(system, std::addressof(out_handle), parameters, caps, num_caps); SetArg32(args, 0, Convert(ret)); SetArg32(args, 1, Convert(out_handle)); } static void SvcWrap_StartProcess64From32(Core::System& system, std::span args) { - Result ret{}; - - Handle process_handle{}; - int32_t priority{}; - int32_t core_id{}; - uint64_t main_thread_stack_size{}; - - process_handle = Convert(GetArg32(args, 0)); - priority = Convert(GetArg32(args, 1)); - core_id = Convert(GetArg32(args, 2)); + Handle process_handle = Convert(GetArg32(args, 0)); + int32_t priority = Convert(GetArg32(args, 1)); + int32_t core_id = Convert(GetArg32(args, 2)); std::array main_thread_stack_size_gather{}; main_thread_stack_size_gather[0] = GetArg32(args, 3); main_thread_stack_size_gather[1] = GetArg32(args, 4); - main_thread_stack_size = Convert(main_thread_stack_size_gather); - - ret = StartProcess64From32(system, process_handle, priority, core_id, main_thread_stack_size); - + uint64_t main_thread_stack_size = Convert(main_thread_stack_size_gather); + Result ret = StartProcess64From32(system, process_handle, priority, core_id, main_thread_stack_size); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_TerminateProcess64From32(Core::System& system, std::span args) { - Result ret{}; - - Handle process_handle{}; - - process_handle = Convert(GetArg32(args, 0)); - - ret = TerminateProcess64From32(system, process_handle); - + Handle process_handle = Convert(GetArg32(args, 0)); + Result ret = TerminateProcess64From32(system, process_handle); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_GetProcessInfo64From32(Core::System& system, std::span args) { - Result ret{}; - + Handle process_handle = Convert(GetArg32(args, 1)); + ProcessInfoType info_type = Convert(GetArg32(args, 2)); int64_t out_info{}; - Handle process_handle{}; - ProcessInfoType info_type{}; - - process_handle = Convert(GetArg32(args, 1)); - info_type = Convert(GetArg32(args, 2)); - - ret = GetProcessInfo64From32(system, std::addressof(out_info), process_handle, info_type); - + Result ret = GetProcessInfo64From32(system, std::addressof(out_info), process_handle, info_type); SetArg32(args, 0, Convert(ret)); auto out_info_scatter = Convert>(out_info); SetArg32(args, 1, out_info_scatter[0]); @@ -2031,155 +1216,83 @@ static void SvcWrap_GetProcessInfo64From32(Core::System& system, std::span args) { - Result ret{}; - Handle out_handle{}; - - ret = CreateResourceLimit64From32(system, std::addressof(out_handle)); - + Result ret = CreateResourceLimit64From32(system, std::addressof(out_handle)); SetArg32(args, 0, Convert(ret)); SetArg32(args, 1, Convert(out_handle)); } static void SvcWrap_SetResourceLimitLimitValue64From32(Core::System& system, std::span args) { - Result ret{}; - - Handle resource_limit_handle{}; - LimitableResource which{}; - int64_t limit_value{}; - - resource_limit_handle = Convert(GetArg32(args, 0)); - which = Convert(GetArg32(args, 1)); + Handle resource_limit_handle = Convert(GetArg32(args, 0)); + LimitableResource which = Convert(GetArg32(args, 1)); std::array limit_value_gather{}; limit_value_gather[0] = GetArg32(args, 2); limit_value_gather[1] = GetArg32(args, 3); - limit_value = Convert(limit_value_gather); - - ret = SetResourceLimitLimitValue64From32(system, resource_limit_handle, which, limit_value); - + int64_t limit_value = Convert(limit_value_gather); + Result ret = SetResourceLimitLimitValue64From32(system, resource_limit_handle, which, limit_value); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_MapInsecureMemory64From32(Core::System& system, std::span args) { - Result ret{}; - - uint32_t address{}; - uint32_t size{}; - - address = Convert(GetArg32(args, 0)); - size = Convert(GetArg32(args, 1)); - - ret = MapInsecureMemory64From32(system, address, size); - + uint32_t address = Convert(GetArg32(args, 0)); + uint32_t size = Convert(GetArg32(args, 1)); + Result ret = MapInsecureMemory64From32(system, address, size); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_UnmapInsecureMemory64From32(Core::System& system, std::span args) { - Result ret{}; - - uint32_t address{}; - uint32_t size{}; - - address = Convert(GetArg32(args, 0)); - size = Convert(GetArg32(args, 1)); - - ret = UnmapInsecureMemory64From32(system, address, size); - + uint32_t address = Convert(GetArg32(args, 0)); + uint32_t size = Convert(GetArg32(args, 1)); + Result ret = UnmapInsecureMemory64From32(system, address, size); SetArg32(args, 0, Convert(ret)); } static void SvcWrap_SetHeapSize64(Core::System& system, std::span args) { - Result ret{}; - + uint64_t size = Convert(GetArg64(args, 1)); uint64_t out_address{}; - uint64_t size{}; - - size = Convert(GetArg64(args, 1)); - - ret = SetHeapSize64(system, std::addressof(out_address), size); - + Result ret = SetHeapSize64(system, std::addressof(out_address), size); SetArg64(args, 0, Convert(ret)); SetArg64(args, 1, Convert(out_address)); } static void SvcWrap_SetMemoryPermission64(Core::System& system, std::span args) { - Result ret{}; - - uint64_t address{}; - uint64_t size{}; - MemoryPermission perm{}; - - address = Convert(GetArg64(args, 0)); - size = Convert(GetArg64(args, 1)); - perm = Convert(GetArg64(args, 2)); - - ret = SetMemoryPermission64(system, address, size, perm); - + uint64_t address = Convert(GetArg64(args, 0)); + uint64_t size = Convert(GetArg64(args, 1)); + MemoryPermission perm = Convert(GetArg64(args, 2)); + Result ret = SetMemoryPermission64(system, address, size, perm); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_SetMemoryAttribute64(Core::System& system, std::span args) { - Result ret{}; - - uint64_t address{}; - uint64_t size{}; - uint32_t mask{}; - uint32_t attr{}; - - address = Convert(GetArg64(args, 0)); - size = Convert(GetArg64(args, 1)); - mask = Convert(GetArg64(args, 2)); - attr = Convert(GetArg64(args, 3)); - - ret = SetMemoryAttribute64(system, address, size, mask, attr); - + uint64_t address = Convert(GetArg64(args, 0)); + uint64_t size = Convert(GetArg64(args, 1)); + uint32_t mask = Convert(GetArg64(args, 2)); + uint32_t attr = Convert(GetArg64(args, 3)); + Result ret = SetMemoryAttribute64(system, address, size, mask, attr); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_MapMemory64(Core::System& system, std::span args) { - Result ret{}; - - uint64_t dst_address{}; - uint64_t src_address{}; - uint64_t size{}; - - dst_address = Convert(GetArg64(args, 0)); - src_address = Convert(GetArg64(args, 1)); - size = Convert(GetArg64(args, 2)); - - ret = MapMemory64(system, dst_address, src_address, size); - + uint64_t dst_address = Convert(GetArg64(args, 0)); + uint64_t src_address = Convert(GetArg64(args, 1)); + uint64_t size = Convert(GetArg64(args, 2)); + Result ret = MapMemory64(system, dst_address, src_address, size); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_UnmapMemory64(Core::System& system, std::span args) { - Result ret{}; - - uint64_t dst_address{}; - uint64_t src_address{}; - uint64_t size{}; - - dst_address = Convert(GetArg64(args, 0)); - src_address = Convert(GetArg64(args, 1)); - size = Convert(GetArg64(args, 2)); - - ret = UnmapMemory64(system, dst_address, src_address, size); - + uint64_t dst_address = Convert(GetArg64(args, 0)); + uint64_t src_address = Convert(GetArg64(args, 1)); + uint64_t size = Convert(GetArg64(args, 2)); + Result ret = UnmapMemory64(system, dst_address, src_address, size); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_QueryMemory64(Core::System& system, std::span args) { - Result ret{}; - + uint64_t out_memory_info = Convert(GetArg64(args, 0)); + uint64_t address = Convert(GetArg64(args, 2)); PageInfo out_page_info{}; - uint64_t out_memory_info{}; - uint64_t address{}; - - out_memory_info = Convert(GetArg64(args, 0)); - address = Convert(GetArg64(args, 2)); - - ret = QueryMemory64(system, out_memory_info, std::addressof(out_page_info), address); - + Result ret = QueryMemory64(system, out_memory_info, std::addressof(out_page_info), address); SetArg64(args, 0, Convert(ret)); SetArg64(args, 1, Convert(out_page_info)); } @@ -2189,36 +1302,20 @@ static void SvcWrap_ExitProcess64(Core::System& system, std::span a } static void SvcWrap_CreateThread64(Core::System& system, std::span args) { - Result ret{}; - + uint64_t func = Convert(GetArg64(args, 1)); + uint64_t arg = Convert(GetArg64(args, 2)); + uint64_t stack_bottom = Convert(GetArg64(args, 3)); + int32_t priority = Convert(GetArg64(args, 4)); + int32_t core_id = Convert(GetArg64(args, 5)); Handle out_handle{}; - uint64_t func{}; - uint64_t arg{}; - uint64_t stack_bottom{}; - int32_t priority{}; - int32_t core_id{}; - - func = Convert(GetArg64(args, 1)); - arg = Convert(GetArg64(args, 2)); - stack_bottom = Convert(GetArg64(args, 3)); - priority = Convert(GetArg64(args, 4)); - core_id = Convert(GetArg64(args, 5)); - - ret = CreateThread64(system, std::addressof(out_handle), func, arg, stack_bottom, priority, core_id); - + Result ret = CreateThread64(system, std::addressof(out_handle), func, arg, stack_bottom, priority, core_id); SetArg64(args, 0, Convert(ret)); SetArg64(args, 1, Convert(out_handle)); } static void SvcWrap_StartThread64(Core::System& system, std::span args) { - Result ret{}; - - Handle thread_handle{}; - - thread_handle = Convert(GetArg64(args, 0)); - - ret = StartThread64(system, thread_handle); - + Handle thread_handle = Convert(GetArg64(args, 0)); + Result ret = StartThread64(system, thread_handle); SetArg64(args, 0, Convert(ret)); } @@ -2227,411 +1324,222 @@ static void SvcWrap_ExitThread64(Core::System& system, std::span ar } static void SvcWrap_SleepThread64(Core::System& system, std::span args) { - int64_t ns{}; - - ns = Convert(GetArg64(args, 0)); - + int64_t ns = Convert(GetArg64(args, 0)); SleepThread64(system, ns); } static void SvcWrap_GetThreadPriority64(Core::System& system, std::span args) { - Result ret{}; - + Handle thread_handle = Convert(GetArg64(args, 1)); int32_t out_priority{}; - Handle thread_handle{}; - - thread_handle = Convert(GetArg64(args, 1)); - - ret = GetThreadPriority64(system, std::addressof(out_priority), thread_handle); - + Result ret = GetThreadPriority64(system, std::addressof(out_priority), thread_handle); SetArg64(args, 0, Convert(ret)); SetArg64(args, 1, Convert(out_priority)); } static void SvcWrap_SetThreadPriority64(Core::System& system, std::span args) { - Result ret{}; - - Handle thread_handle{}; - int32_t priority{}; - - thread_handle = Convert(GetArg64(args, 0)); - priority = Convert(GetArg64(args, 1)); - - ret = SetThreadPriority64(system, thread_handle, priority); - + Handle thread_handle = Convert(GetArg64(args, 0)); + int32_t priority = Convert(GetArg64(args, 1)); + Result ret = SetThreadPriority64(system, thread_handle, priority); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_GetThreadCoreMask64(Core::System& system, std::span args) { - Result ret{}; - + Handle thread_handle = Convert(GetArg64(args, 2)); int32_t out_core_id{}; uint64_t out_affinity_mask{}; - Handle thread_handle{}; - - thread_handle = Convert(GetArg64(args, 2)); - - ret = GetThreadCoreMask64(system, std::addressof(out_core_id), std::addressof(out_affinity_mask), thread_handle); - + Result ret = GetThreadCoreMask64(system, std::addressof(out_core_id), std::addressof(out_affinity_mask), thread_handle); SetArg64(args, 0, Convert(ret)); SetArg64(args, 1, Convert(out_core_id)); SetArg64(args, 2, Convert(out_affinity_mask)); } static void SvcWrap_SetThreadCoreMask64(Core::System& system, std::span args) { - Result ret{}; - - Handle thread_handle{}; - int32_t core_id{}; - uint64_t affinity_mask{}; - - thread_handle = Convert(GetArg64(args, 0)); - core_id = Convert(GetArg64(args, 1)); - affinity_mask = Convert(GetArg64(args, 2)); - - ret = SetThreadCoreMask64(system, thread_handle, core_id, affinity_mask); - + Handle thread_handle = Convert(GetArg64(args, 0)); + int32_t core_id = Convert(GetArg64(args, 1)); + uint64_t affinity_mask = Convert(GetArg64(args, 2)); + Result ret = SetThreadCoreMask64(system, thread_handle, core_id, affinity_mask); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_GetCurrentProcessorNumber64(Core::System& system, std::span args) { - int32_t ret{}; - - ret = GetCurrentProcessorNumber64(system); - + int32_t ret = GetCurrentProcessorNumber64(system); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_SignalEvent64(Core::System& system, std::span args) { - Result ret{}; - - Handle event_handle{}; - - event_handle = Convert(GetArg64(args, 0)); - - ret = SignalEvent64(system, event_handle); - + Handle event_handle = Convert(GetArg64(args, 0)); + Result ret = SignalEvent64(system, event_handle); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_ClearEvent64(Core::System& system, std::span args) { - Result ret{}; - - Handle event_handle{}; - - event_handle = Convert(GetArg64(args, 0)); - - ret = ClearEvent64(system, event_handle); - + Handle event_handle = Convert(GetArg64(args, 0)); + Result ret = ClearEvent64(system, event_handle); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_MapSharedMemory64(Core::System& system, std::span args) { - Result ret{}; - - Handle shmem_handle{}; - uint64_t address{}; - uint64_t size{}; - MemoryPermission map_perm{}; - - shmem_handle = Convert(GetArg64(args, 0)); - address = Convert(GetArg64(args, 1)); - size = Convert(GetArg64(args, 2)); - map_perm = Convert(GetArg64(args, 3)); - - ret = MapSharedMemory64(system, shmem_handle, address, size, map_perm); - + Handle shmem_handle = Convert(GetArg64(args, 0)); + uint64_t address = Convert(GetArg64(args, 1)); + uint64_t size = Convert(GetArg64(args, 2)); + MemoryPermission map_perm = Convert(GetArg64(args, 3)); + Result ret = MapSharedMemory64(system, shmem_handle, address, size, map_perm); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_UnmapSharedMemory64(Core::System& system, std::span args) { - Result ret{}; - - Handle shmem_handle{}; - uint64_t address{}; - uint64_t size{}; - - shmem_handle = Convert(GetArg64(args, 0)); - address = Convert(GetArg64(args, 1)); - size = Convert(GetArg64(args, 2)); - - ret = UnmapSharedMemory64(system, shmem_handle, address, size); - + Handle shmem_handle = Convert(GetArg64(args, 0)); + uint64_t address = Convert(GetArg64(args, 1)); + uint64_t size = Convert(GetArg64(args, 2)); + Result ret = UnmapSharedMemory64(system, shmem_handle, address, size); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_CreateTransferMemory64(Core::System& system, std::span args) { - Result ret{}; - + uint64_t address = Convert(GetArg64(args, 1)); + uint64_t size = Convert(GetArg64(args, 2)); + MemoryPermission map_perm = Convert(GetArg64(args, 3)); Handle out_handle{}; - uint64_t address{}; - uint64_t size{}; - MemoryPermission map_perm{}; - - address = Convert(GetArg64(args, 1)); - size = Convert(GetArg64(args, 2)); - map_perm = Convert(GetArg64(args, 3)); - - ret = CreateTransferMemory64(system, std::addressof(out_handle), address, size, map_perm); - + Result ret = CreateTransferMemory64(system, std::addressof(out_handle), address, size, map_perm); SetArg64(args, 0, Convert(ret)); SetArg64(args, 1, Convert(out_handle)); } static void SvcWrap_CloseHandle64(Core::System& system, std::span args) { - Result ret{}; - - Handle handle{}; - - handle = Convert(GetArg64(args, 0)); - - ret = CloseHandle64(system, handle); - + Handle handle = Convert(GetArg64(args, 0)); + Result ret = CloseHandle64(system, handle); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_ResetSignal64(Core::System& system, std::span args) { - Result ret{}; - - Handle handle{}; - - handle = Convert(GetArg64(args, 0)); - - ret = ResetSignal64(system, handle); - + Handle handle = Convert(GetArg64(args, 0)); + Result ret = ResetSignal64(system, handle); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_WaitSynchronization64(Core::System& system, std::span args) { - Result ret{}; - + uint64_t handles = Convert(GetArg64(args, 1)); + int32_t num_handles = Convert(GetArg64(args, 2)); + int64_t timeout_ns = Convert(GetArg64(args, 3)); int32_t out_index{}; - uint64_t handles{}; - int32_t num_handles{}; - int64_t timeout_ns{}; - - handles = Convert(GetArg64(args, 1)); - num_handles = Convert(GetArg64(args, 2)); - timeout_ns = Convert(GetArg64(args, 3)); - - ret = WaitSynchronization64(system, std::addressof(out_index), handles, num_handles, timeout_ns); - + Result ret = WaitSynchronization64(system, std::addressof(out_index), handles, num_handles, timeout_ns); SetArg64(args, 0, Convert(ret)); SetArg64(args, 1, Convert(out_index)); } static void SvcWrap_CancelSynchronization64(Core::System& system, std::span args) { - Result ret{}; - - Handle handle{}; - - handle = Convert(GetArg64(args, 0)); - - ret = CancelSynchronization64(system, handle); - + Handle handle = Convert(GetArg64(args, 0)); + Result ret = CancelSynchronization64(system, handle); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_ArbitrateLock64(Core::System& system, std::span args) { - Result ret{}; - - Handle thread_handle{}; - uint64_t address{}; - uint32_t tag{}; - - thread_handle = Convert(GetArg64(args, 0)); - address = Convert(GetArg64(args, 1)); - tag = Convert(GetArg64(args, 2)); - - ret = ArbitrateLock64(system, thread_handle, address, tag); - + Handle thread_handle = Convert(GetArg64(args, 0)); + uint64_t address = Convert(GetArg64(args, 1)); + uint32_t tag = Convert(GetArg64(args, 2)); + Result ret = ArbitrateLock64(system, thread_handle, address, tag); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_ArbitrateUnlock64(Core::System& system, std::span args) { - Result ret{}; - - uint64_t address{}; - - address = Convert(GetArg64(args, 0)); - - ret = ArbitrateUnlock64(system, address); - + uint64_t address = Convert(GetArg64(args, 0)); + Result ret = ArbitrateUnlock64(system, address); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_WaitProcessWideKeyAtomic64(Core::System& system, std::span args) { - Result ret{}; - - uint64_t address{}; - uint64_t cv_key{}; - uint32_t tag{}; - int64_t timeout_ns{}; - - address = Convert(GetArg64(args, 0)); - cv_key = Convert(GetArg64(args, 1)); - tag = Convert(GetArg64(args, 2)); - timeout_ns = Convert(GetArg64(args, 3)); - - ret = WaitProcessWideKeyAtomic64(system, address, cv_key, tag, timeout_ns); - + uint64_t address = Convert(GetArg64(args, 0)); + uint64_t cv_key = Convert(GetArg64(args, 1)); + uint32_t tag = Convert(GetArg64(args, 2)); + int64_t timeout_ns = Convert(GetArg64(args, 3)); + Result ret = WaitProcessWideKeyAtomic64(system, address, cv_key, tag, timeout_ns); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_SignalProcessWideKey64(Core::System& system, std::span args) { - uint64_t cv_key{}; - int32_t count{}; - - cv_key = Convert(GetArg64(args, 0)); - count = Convert(GetArg64(args, 1)); - + uint64_t cv_key = Convert(GetArg64(args, 0)); + int32_t count = Convert(GetArg64(args, 1)); SignalProcessWideKey64(system, cv_key, count); } static void SvcWrap_GetSystemTick64(Core::System& system, std::span args) { - int64_t ret{}; - - ret = GetSystemTick64(system); - + int64_t ret = GetSystemTick64(system); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_ConnectToNamedPort64(Core::System& system, std::span args) { - Result ret{}; - + uint64_t name = Convert(GetArg64(args, 1)); Handle out_handle{}; - uint64_t name{}; - - name = Convert(GetArg64(args, 1)); - - ret = ConnectToNamedPort64(system, std::addressof(out_handle), name); - + Result ret = ConnectToNamedPort64(system, std::addressof(out_handle), name); SetArg64(args, 0, Convert(ret)); SetArg64(args, 1, Convert(out_handle)); } static void SvcWrap_SendSyncRequest64(Core::System& system, std::span args) { - Result ret{}; - - Handle session_handle{}; - - session_handle = Convert(GetArg64(args, 0)); - - ret = SendSyncRequest64(system, session_handle); - + Handle session_handle = Convert(GetArg64(args, 0)); + Result ret = SendSyncRequest64(system, session_handle); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_SendSyncRequestWithUserBuffer64(Core::System& system, std::span args) { - Result ret{}; - - uint64_t message_buffer{}; - uint64_t message_buffer_size{}; - Handle session_handle{}; - - message_buffer = Convert(GetArg64(args, 0)); - message_buffer_size = Convert(GetArg64(args, 1)); - session_handle = Convert(GetArg64(args, 2)); - - ret = SendSyncRequestWithUserBuffer64(system, message_buffer, message_buffer_size, session_handle); - + uint64_t message_buffer = Convert(GetArg64(args, 0)); + uint64_t message_buffer_size = Convert(GetArg64(args, 1)); + Handle session_handle = Convert(GetArg64(args, 2)); + Result ret = SendSyncRequestWithUserBuffer64(system, message_buffer, message_buffer_size, session_handle); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_SendAsyncRequestWithUserBuffer64(Core::System& system, std::span args) { - Result ret{}; - + uint64_t message_buffer = Convert(GetArg64(args, 1)); + uint64_t message_buffer_size = Convert(GetArg64(args, 2)); + Handle session_handle = Convert(GetArg64(args, 3)); Handle out_event_handle{}; - uint64_t message_buffer{}; - uint64_t message_buffer_size{}; - Handle session_handle{}; - - message_buffer = Convert(GetArg64(args, 1)); - message_buffer_size = Convert(GetArg64(args, 2)); - session_handle = Convert(GetArg64(args, 3)); - - ret = SendAsyncRequestWithUserBuffer64(system, std::addressof(out_event_handle), message_buffer, message_buffer_size, session_handle); - + Result ret = SendAsyncRequestWithUserBuffer64(system, std::addressof(out_event_handle), message_buffer, message_buffer_size, session_handle); SetArg64(args, 0, Convert(ret)); SetArg64(args, 1, Convert(out_event_handle)); } static void SvcWrap_GetProcessId64(Core::System& system, std::span args) { - Result ret{}; - + Handle process_handle = Convert(GetArg64(args, 1)); uint64_t out_process_id{}; - Handle process_handle{}; - - process_handle = Convert(GetArg64(args, 1)); - - ret = GetProcessId64(system, std::addressof(out_process_id), process_handle); - + Result ret = GetProcessId64(system, std::addressof(out_process_id), process_handle); SetArg64(args, 0, Convert(ret)); SetArg64(args, 1, Convert(out_process_id)); } static void SvcWrap_GetThreadId64(Core::System& system, std::span args) { - Result ret{}; - + Handle thread_handle = Convert(GetArg64(args, 1)); uint64_t out_thread_id{}; - Handle thread_handle{}; - - thread_handle = Convert(GetArg64(args, 1)); - - ret = GetThreadId64(system, std::addressof(out_thread_id), thread_handle); - + Result ret = GetThreadId64(system, std::addressof(out_thread_id), thread_handle); SetArg64(args, 0, Convert(ret)); SetArg64(args, 1, Convert(out_thread_id)); } static void SvcWrap_Break64(Core::System& system, std::span args) { - BreakReason break_reason{}; - uint64_t arg{}; - uint64_t size{}; - - break_reason = Convert(GetArg64(args, 0)); - arg = Convert(GetArg64(args, 1)); - size = Convert(GetArg64(args, 2)); - + BreakReason break_reason = Convert(GetArg64(args, 0)); + uint64_t arg = Convert(GetArg64(args, 1)); + uint64_t size = Convert(GetArg64(args, 2)); Break64(system, break_reason, arg, size); } static void SvcWrap_OutputDebugString64(Core::System& system, std::span args) { - Result ret{}; - - uint64_t debug_str{}; - uint64_t len{}; - - debug_str = Convert(GetArg64(args, 0)); - len = Convert(GetArg64(args, 1)); - - ret = OutputDebugString64(system, debug_str, len); - + uint64_t debug_str = Convert(GetArg64(args, 0)); + uint64_t len = Convert(GetArg64(args, 1)); + Result ret = OutputDebugString64(system, debug_str, len); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_ReturnFromException64(Core::System& system, std::span args) { - Result result{}; - - result = Convert(GetArg64(args, 0)); - + Result result = Convert(GetArg64(args, 0)); ReturnFromException64(system, result); } static void SvcWrap_GetInfo64(Core::System& system, std::span args) { - Result ret{}; - + InfoType info_type = Convert(GetArg64(args, 1)); + Handle handle = Convert(GetArg64(args, 2)); + uint64_t info_subtype = Convert(GetArg64(args, 3)); uint64_t out{}; - InfoType info_type{}; - Handle handle{}; - uint64_t info_subtype{}; - - info_type = Convert(GetArg64(args, 1)); - handle = Convert(GetArg64(args, 2)); - info_subtype = Convert(GetArg64(args, 3)); - - ret = GetInfo64(system, std::addressof(out), info_type, handle, info_subtype); - + Result ret = GetInfo64(system, std::addressof(out), info_type, handle, info_subtype); SetArg64(args, 0, Convert(ret)); SetArg64(args, 1, Convert(out)); } @@ -2641,60 +1549,32 @@ static void SvcWrap_FlushEntireDataCache64(Core::System& system, std::span args) { - Result ret{}; - - uint64_t address{}; - uint64_t size{}; - - address = Convert(GetArg64(args, 0)); - size = Convert(GetArg64(args, 1)); - - ret = FlushDataCache64(system, address, size); - + uint64_t address = Convert(GetArg64(args, 0)); + uint64_t size = Convert(GetArg64(args, 1)); + Result ret = FlushDataCache64(system, address, size); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_MapPhysicalMemory64(Core::System& system, std::span args) { - Result ret{}; - - uint64_t address{}; - uint64_t size{}; - - address = Convert(GetArg64(args, 0)); - size = Convert(GetArg64(args, 1)); - - ret = MapPhysicalMemory64(system, address, size); - + uint64_t address = Convert(GetArg64(args, 0)); + uint64_t size = Convert(GetArg64(args, 1)); + Result ret = MapPhysicalMemory64(system, address, size); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_UnmapPhysicalMemory64(Core::System& system, std::span args) { - Result ret{}; - - uint64_t address{}; - uint64_t size{}; - - address = Convert(GetArg64(args, 0)); - size = Convert(GetArg64(args, 1)); - - ret = UnmapPhysicalMemory64(system, address, size); - + uint64_t address = Convert(GetArg64(args, 0)); + uint64_t size = Convert(GetArg64(args, 1)); + Result ret = UnmapPhysicalMemory64(system, address, size); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_GetDebugFutureThreadInfo64(Core::System& system, std::span args) { - Result ret{}; - + Handle debug_handle = Convert(GetArg64(args, 2)); + int64_t ns = Convert(GetArg64(args, 3)); lp64::LastThreadContext out_context{}; uint64_t out_thread_id{}; - Handle debug_handle{}; - int64_t ns{}; - - debug_handle = Convert(GetArg64(args, 2)); - ns = Convert(GetArg64(args, 3)); - - ret = GetDebugFutureThreadInfo64(system, std::addressof(out_context), std::addressof(out_thread_id), debug_handle, ns); - + Result ret = GetDebugFutureThreadInfo64(system, std::addressof(out_context), std::addressof(out_thread_id), debug_handle, ns); SetArg64(args, 0, Convert(ret)); auto out_context_scatter = Convert>(out_context); SetArg64(args, 1, out_context_scatter[0]); @@ -2705,14 +1585,10 @@ static void SvcWrap_GetDebugFutureThreadInfo64(Core::System& system, std::span args) { - Result ret{}; - lp64::LastThreadContext out_context{}; uint64_t out_tls_address{}; uint32_t out_flags{}; - - ret = GetLastThreadInfo64(system, std::addressof(out_context), std::addressof(out_tls_address), std::addressof(out_flags)); - + Result ret = GetLastThreadInfo64(system, std::addressof(out_context), std::addressof(out_tls_address), std::addressof(out_flags)); SetArg64(args, 0, Convert(ret)); auto out_context_scatter = Convert>(out_context); SetArg64(args, 1, out_context_scatter[0]); @@ -2724,98 +1600,52 @@ static void SvcWrap_GetLastThreadInfo64(Core::System& system, std::span args) { - Result ret{}; - + Handle resource_limit_handle = Convert(GetArg64(args, 1)); + LimitableResource which = Convert(GetArg64(args, 2)); int64_t out_limit_value{}; - Handle resource_limit_handle{}; - LimitableResource which{}; - - resource_limit_handle = Convert(GetArg64(args, 1)); - which = Convert(GetArg64(args, 2)); - - ret = GetResourceLimitLimitValue64(system, std::addressof(out_limit_value), resource_limit_handle, which); - + Result ret = GetResourceLimitLimitValue64(system, std::addressof(out_limit_value), resource_limit_handle, which); SetArg64(args, 0, Convert(ret)); SetArg64(args, 1, Convert(out_limit_value)); } static void SvcWrap_GetResourceLimitCurrentValue64(Core::System& system, std::span args) { - Result ret{}; - + Handle resource_limit_handle = Convert(GetArg64(args, 1)); + LimitableResource which = Convert(GetArg64(args, 2)); int64_t out_current_value{}; - Handle resource_limit_handle{}; - LimitableResource which{}; - - resource_limit_handle = Convert(GetArg64(args, 1)); - which = Convert(GetArg64(args, 2)); - - ret = GetResourceLimitCurrentValue64(system, std::addressof(out_current_value), resource_limit_handle, which); - + Result ret = GetResourceLimitCurrentValue64(system, std::addressof(out_current_value), resource_limit_handle, which); SetArg64(args, 0, Convert(ret)); SetArg64(args, 1, Convert(out_current_value)); } static void SvcWrap_SetThreadActivity64(Core::System& system, std::span args) { - Result ret{}; - - Handle thread_handle{}; - ThreadActivity thread_activity{}; - - thread_handle = Convert(GetArg64(args, 0)); - thread_activity = Convert(GetArg64(args, 1)); - - ret = SetThreadActivity64(system, thread_handle, thread_activity); - + Handle thread_handle = Convert(GetArg64(args, 0)); + ThreadActivity thread_activity = Convert(GetArg64(args, 1)); + Result ret = SetThreadActivity64(system, thread_handle, thread_activity); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_GetThreadContext364(Core::System& system, std::span args) { - Result ret{}; - - uint64_t out_context{}; - Handle thread_handle{}; - - out_context = Convert(GetArg64(args, 0)); - thread_handle = Convert(GetArg64(args, 1)); - - ret = GetThreadContext364(system, out_context, thread_handle); - + uint64_t out_context = Convert(GetArg64(args, 0)); + Handle thread_handle = Convert(GetArg64(args, 1)); + Result ret = GetThreadContext364(system, out_context, thread_handle); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_WaitForAddress64(Core::System& system, std::span args) { - Result ret{}; - - uint64_t address{}; - ArbitrationType arb_type{}; - int32_t value{}; - int64_t timeout_ns{}; - - address = Convert(GetArg64(args, 0)); - arb_type = Convert(GetArg64(args, 1)); - value = Convert(GetArg64(args, 2)); - timeout_ns = Convert(GetArg64(args, 3)); - - ret = WaitForAddress64(system, address, arb_type, value, timeout_ns); - + uint64_t address = Convert(GetArg64(args, 0)); + ArbitrationType arb_type = Convert(GetArg64(args, 1)); + int32_t value = Convert(GetArg64(args, 2)); + int64_t timeout_ns = Convert(GetArg64(args, 3)); + Result ret = WaitForAddress64(system, address, arb_type, value, timeout_ns); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_SignalToAddress64(Core::System& system, std::span args) { - Result ret{}; - - uint64_t address{}; - SignalType signal_type{}; - int32_t value{}; - int32_t count{}; - - address = Convert(GetArg64(args, 0)); - signal_type = Convert(GetArg64(args, 1)); - value = Convert(GetArg64(args, 2)); - count = Convert(GetArg64(args, 3)); - - ret = SignalToAddress64(system, address, signal_type, value, count); - + uint64_t address = Convert(GetArg64(args, 0)); + SignalType signal_type = Convert(GetArg64(args, 1)); + int32_t value = Convert(GetArg64(args, 2)); + int32_t count = Convert(GetArg64(args, 3)); + Result ret = SignalToAddress64(system, address, signal_type, value, count); SetArg64(args, 0, Convert(ret)); } @@ -2824,275 +1654,152 @@ static void SvcWrap_SynchronizePreemptionState64(Core::System& system, std::span } static void SvcWrap_GetResourceLimitPeakValue64(Core::System& system, std::span args) { - Result ret{}; - + Handle resource_limit_handle = Convert(GetArg64(args, 1)); + LimitableResource which = Convert(GetArg64(args, 2)); int64_t out_peak_value{}; - Handle resource_limit_handle{}; - LimitableResource which{}; - - resource_limit_handle = Convert(GetArg64(args, 1)); - which = Convert(GetArg64(args, 2)); - - ret = GetResourceLimitPeakValue64(system, std::addressof(out_peak_value), resource_limit_handle, which); - + Result ret = GetResourceLimitPeakValue64(system, std::addressof(out_peak_value), resource_limit_handle, which); SetArg64(args, 0, Convert(ret)); SetArg64(args, 1, Convert(out_peak_value)); } static void SvcWrap_CreateIoPool64(Core::System& system, std::span args) { - Result ret{}; - + IoPoolType which = Convert(GetArg64(args, 1)); Handle out_handle{}; - IoPoolType which{}; - - which = Convert(GetArg64(args, 1)); - - ret = CreateIoPool64(system, std::addressof(out_handle), which); - + Result ret = CreateIoPool64(system, std::addressof(out_handle), which); SetArg64(args, 0, Convert(ret)); SetArg64(args, 1, Convert(out_handle)); } static void SvcWrap_CreateIoRegion64(Core::System& system, std::span args) { - Result ret{}; - + Handle io_pool = Convert(GetArg64(args, 1)); + uint64_t physical_address = Convert(GetArg64(args, 2)); + uint64_t size = Convert(GetArg64(args, 3)); + MemoryMapping mapping = Convert(GetArg64(args, 4)); + MemoryPermission perm = Convert(GetArg64(args, 5)); Handle out_handle{}; - Handle io_pool{}; - uint64_t physical_address{}; - uint64_t size{}; - MemoryMapping mapping{}; - MemoryPermission perm{}; - - io_pool = Convert(GetArg64(args, 1)); - physical_address = Convert(GetArg64(args, 2)); - size = Convert(GetArg64(args, 3)); - mapping = Convert(GetArg64(args, 4)); - perm = Convert(GetArg64(args, 5)); - - ret = CreateIoRegion64(system, std::addressof(out_handle), io_pool, physical_address, size, mapping, perm); - + Result ret = CreateIoRegion64(system, std::addressof(out_handle), io_pool, physical_address, size, mapping, perm); SetArg64(args, 0, Convert(ret)); SetArg64(args, 1, Convert(out_handle)); } static void SvcWrap_KernelDebug64(Core::System& system, std::span args) { - KernelDebugType kern_debug_type{}; - uint64_t arg0{}; - uint64_t arg1{}; - uint64_t arg2{}; - - kern_debug_type = Convert(GetArg64(args, 0)); - arg0 = Convert(GetArg64(args, 1)); - arg1 = Convert(GetArg64(args, 2)); - arg2 = Convert(GetArg64(args, 3)); - + KernelDebugType kern_debug_type = Convert(GetArg64(args, 0)); + uint64_t arg0 = Convert(GetArg64(args, 1)); + uint64_t arg1 = Convert(GetArg64(args, 2)); + uint64_t arg2 = Convert(GetArg64(args, 3)); KernelDebug64(system, kern_debug_type, arg0, arg1, arg2); } static void SvcWrap_ChangeKernelTraceState64(Core::System& system, std::span args) { - KernelTraceState kern_trace_state{}; - - kern_trace_state = Convert(GetArg64(args, 0)); - + KernelTraceState kern_trace_state = Convert(GetArg64(args, 0)); ChangeKernelTraceState64(system, kern_trace_state); } static void SvcWrap_CreateSession64(Core::System& system, std::span args) { - Result ret{}; - + bool is_light = Convert(GetArg64(args, 2)); + uint64_t name = Convert(GetArg64(args, 3)); Handle out_server_session_handle{}; Handle out_client_session_handle{}; - bool is_light{}; - uint64_t name{}; - - is_light = Convert(GetArg64(args, 2)); - name = Convert(GetArg64(args, 3)); - - ret = CreateSession64(system, std::addressof(out_server_session_handle), std::addressof(out_client_session_handle), is_light, name); - + Result ret = CreateSession64(system, std::addressof(out_server_session_handle), std::addressof(out_client_session_handle), is_light, name); SetArg64(args, 0, Convert(ret)); SetArg64(args, 1, Convert(out_server_session_handle)); SetArg64(args, 2, Convert(out_client_session_handle)); } static void SvcWrap_AcceptSession64(Core::System& system, std::span args) { - Result ret{}; - + Handle port = Convert(GetArg64(args, 1)); Handle out_handle{}; - Handle port{}; - - port = Convert(GetArg64(args, 1)); - - ret = AcceptSession64(system, std::addressof(out_handle), port); - + Result ret = AcceptSession64(system, std::addressof(out_handle), port); SetArg64(args, 0, Convert(ret)); SetArg64(args, 1, Convert(out_handle)); } static void SvcWrap_ReplyAndReceive64(Core::System& system, std::span args) { - Result ret{}; - + uint64_t handles = Convert(GetArg64(args, 1)); + int32_t num_handles = Convert(GetArg64(args, 2)); + Handle reply_target = Convert(GetArg64(args, 3)); + int64_t timeout_ns = Convert(GetArg64(args, 4)); int32_t out_index{}; - uint64_t handles{}; - int32_t num_handles{}; - Handle reply_target{}; - int64_t timeout_ns{}; - - handles = Convert(GetArg64(args, 1)); - num_handles = Convert(GetArg64(args, 2)); - reply_target = Convert(GetArg64(args, 3)); - timeout_ns = Convert(GetArg64(args, 4)); - - ret = ReplyAndReceive64(system, std::addressof(out_index), handles, num_handles, reply_target, timeout_ns); - + Result ret = ReplyAndReceive64(system, std::addressof(out_index), handles, num_handles, reply_target, timeout_ns); SetArg64(args, 0, Convert(ret)); SetArg64(args, 1, Convert(out_index)); } static void SvcWrap_ReplyAndReceiveWithUserBuffer64(Core::System& system, std::span args) { - Result ret{}; - + uint64_t message_buffer = Convert(GetArg64(args, 1)); + uint64_t message_buffer_size = Convert(GetArg64(args, 2)); + uint64_t handles = Convert(GetArg64(args, 3)); + int32_t num_handles = Convert(GetArg64(args, 4)); + Handle reply_target = Convert(GetArg64(args, 5)); + int64_t timeout_ns = Convert(GetArg64(args, 6)); int32_t out_index{}; - uint64_t message_buffer{}; - uint64_t message_buffer_size{}; - uint64_t handles{}; - int32_t num_handles{}; - Handle reply_target{}; - int64_t timeout_ns{}; - - message_buffer = Convert(GetArg64(args, 1)); - message_buffer_size = Convert(GetArg64(args, 2)); - handles = Convert(GetArg64(args, 3)); - num_handles = Convert(GetArg64(args, 4)); - reply_target = Convert(GetArg64(args, 5)); - timeout_ns = Convert(GetArg64(args, 6)); - - ret = ReplyAndReceiveWithUserBuffer64(system, std::addressof(out_index), message_buffer, message_buffer_size, handles, num_handles, reply_target, timeout_ns); - + Result ret = ReplyAndReceiveWithUserBuffer64(system, std::addressof(out_index), message_buffer, message_buffer_size, handles, num_handles, reply_target, timeout_ns); SetArg64(args, 0, Convert(ret)); SetArg64(args, 1, Convert(out_index)); } static void SvcWrap_CreateEvent64(Core::System& system, std::span args) { - Result ret{}; - Handle out_write_handle{}; Handle out_read_handle{}; - - ret = CreateEvent64(system, std::addressof(out_write_handle), std::addressof(out_read_handle)); - + Result ret = CreateEvent64(system, std::addressof(out_write_handle), std::addressof(out_read_handle)); SetArg64(args, 0, Convert(ret)); SetArg64(args, 1, Convert(out_write_handle)); SetArg64(args, 2, Convert(out_read_handle)); } static void SvcWrap_MapIoRegion64(Core::System& system, std::span args) { - Result ret{}; - - Handle io_region{}; - uint64_t address{}; - uint64_t size{}; - MemoryPermission perm{}; - - io_region = Convert(GetArg64(args, 0)); - address = Convert(GetArg64(args, 1)); - size = Convert(GetArg64(args, 2)); - perm = Convert(GetArg64(args, 3)); - - ret = MapIoRegion64(system, io_region, address, size, perm); - + Handle io_region = Convert(GetArg64(args, 0)); + uint64_t address = Convert(GetArg64(args, 1)); + uint64_t size = Convert(GetArg64(args, 2)); + MemoryPermission perm = Convert(GetArg64(args, 3)); + Result ret = MapIoRegion64(system, io_region, address, size, perm); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_UnmapIoRegion64(Core::System& system, std::span args) { - Result ret{}; - - Handle io_region{}; - uint64_t address{}; - uint64_t size{}; - - io_region = Convert(GetArg64(args, 0)); - address = Convert(GetArg64(args, 1)); - size = Convert(GetArg64(args, 2)); - - ret = UnmapIoRegion64(system, io_region, address, size); - + Handle io_region = Convert(GetArg64(args, 0)); + uint64_t address = Convert(GetArg64(args, 1)); + uint64_t size = Convert(GetArg64(args, 2)); + Result ret = UnmapIoRegion64(system, io_region, address, size); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_MapPhysicalMemoryUnsafe64(Core::System& system, std::span args) { - Result ret{}; - - uint64_t address{}; - uint64_t size{}; - - address = Convert(GetArg64(args, 0)); - size = Convert(GetArg64(args, 1)); - - ret = MapPhysicalMemoryUnsafe64(system, address, size); - + uint64_t address = Convert(GetArg64(args, 0)); + uint64_t size = Convert(GetArg64(args, 1)); + Result ret = MapPhysicalMemoryUnsafe64(system, address, size); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_UnmapPhysicalMemoryUnsafe64(Core::System& system, std::span args) { - Result ret{}; - - uint64_t address{}; - uint64_t size{}; - - address = Convert(GetArg64(args, 0)); - size = Convert(GetArg64(args, 1)); - - ret = UnmapPhysicalMemoryUnsafe64(system, address, size); - + uint64_t address = Convert(GetArg64(args, 0)); + uint64_t size = Convert(GetArg64(args, 1)); + Result ret = UnmapPhysicalMemoryUnsafe64(system, address, size); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_SetUnsafeLimit64(Core::System& system, std::span args) { - Result ret{}; - - uint64_t limit{}; - - limit = Convert(GetArg64(args, 0)); - - ret = SetUnsafeLimit64(system, limit); - + uint64_t limit = Convert(GetArg64(args, 0)); + Result ret = SetUnsafeLimit64(system, limit); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_CreateCodeMemory64(Core::System& system, std::span args) { - Result ret{}; - + uint64_t address = Convert(GetArg64(args, 1)); + uint64_t size = Convert(GetArg64(args, 2)); Handle out_handle{}; - uint64_t address{}; - uint64_t size{}; - - address = Convert(GetArg64(args, 1)); - size = Convert(GetArg64(args, 2)); - - ret = CreateCodeMemory64(system, std::addressof(out_handle), address, size); - + Result ret = CreateCodeMemory64(system, std::addressof(out_handle), address, size); SetArg64(args, 0, Convert(ret)); SetArg64(args, 1, Convert(out_handle)); } static void SvcWrap_ControlCodeMemory64(Core::System& system, std::span args) { - Result ret{}; - - Handle code_memory_handle{}; - CodeMemoryOperation operation{}; - uint64_t address{}; - uint64_t size{}; - MemoryPermission perm{}; - - code_memory_handle = Convert(GetArg64(args, 0)); - operation = Convert(GetArg64(args, 1)); - address = Convert(GetArg64(args, 2)); - size = Convert(GetArg64(args, 3)); - perm = Convert(GetArg64(args, 4)); - - ret = ControlCodeMemory64(system, code_memory_handle, operation, address, size, perm); - + Handle code_memory_handle = Convert(GetArg64(args, 0)); + CodeMemoryOperation operation = Convert(GetArg64(args, 1)); + uint64_t address = Convert(GetArg64(args, 2)); + uint64_t size = Convert(GetArg64(args, 3)); + MemoryPermission perm = Convert(GetArg64(args, 4)); + Result ret = ControlCodeMemory64(system, code_memory_handle, operation, address, size, perm); SetArg64(args, 0, Convert(ret)); } @@ -3101,115 +1808,62 @@ static void SvcWrap_SleepSystem64(Core::System& system, std::span a } static void SvcWrap_ReadWriteRegister64(Core::System& system, std::span args) { - Result ret{}; - + uint64_t address = Convert(GetArg64(args, 1)); + uint32_t mask = Convert(GetArg64(args, 2)); + uint32_t value = Convert(GetArg64(args, 3)); uint32_t out_value{}; - uint64_t address{}; - uint32_t mask{}; - uint32_t value{}; - - address = Convert(GetArg64(args, 1)); - mask = Convert(GetArg64(args, 2)); - value = Convert(GetArg64(args, 3)); - - ret = ReadWriteRegister64(system, std::addressof(out_value), address, mask, value); - + Result ret = ReadWriteRegister64(system, std::addressof(out_value), address, mask, value); SetArg64(args, 0, Convert(ret)); SetArg64(args, 1, Convert(out_value)); } static void SvcWrap_SetProcessActivity64(Core::System& system, std::span args) { - Result ret{}; - - Handle process_handle{}; - ProcessActivity process_activity{}; - - process_handle = Convert(GetArg64(args, 0)); - process_activity = Convert(GetArg64(args, 1)); - - ret = SetProcessActivity64(system, process_handle, process_activity); - + Handle process_handle = Convert(GetArg64(args, 0)); + ProcessActivity process_activity = Convert(GetArg64(args, 1)); + Result ret = SetProcessActivity64(system, process_handle, process_activity); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_CreateSharedMemory64(Core::System& system, std::span args) { - Result ret{}; - + uint64_t size = Convert(GetArg64(args, 1)); + MemoryPermission owner_perm = Convert(GetArg64(args, 2)); + MemoryPermission remote_perm = Convert(GetArg64(args, 3)); Handle out_handle{}; - uint64_t size{}; - MemoryPermission owner_perm{}; - MemoryPermission remote_perm{}; - - size = Convert(GetArg64(args, 1)); - owner_perm = Convert(GetArg64(args, 2)); - remote_perm = Convert(GetArg64(args, 3)); - - ret = CreateSharedMemory64(system, std::addressof(out_handle), size, owner_perm, remote_perm); - + Result ret = CreateSharedMemory64(system, std::addressof(out_handle), size, owner_perm, remote_perm); SetArg64(args, 0, Convert(ret)); SetArg64(args, 1, Convert(out_handle)); } static void SvcWrap_MapTransferMemory64(Core::System& system, std::span args) { - Result ret{}; - - Handle trmem_handle{}; - uint64_t address{}; - uint64_t size{}; - MemoryPermission owner_perm{}; - - trmem_handle = Convert(GetArg64(args, 0)); - address = Convert(GetArg64(args, 1)); - size = Convert(GetArg64(args, 2)); - owner_perm = Convert(GetArg64(args, 3)); - - ret = MapTransferMemory64(system, trmem_handle, address, size, owner_perm); - + Handle trmem_handle = Convert(GetArg64(args, 0)); + uint64_t address = Convert(GetArg64(args, 1)); + uint64_t size = Convert(GetArg64(args, 2)); + MemoryPermission owner_perm = Convert(GetArg64(args, 3)); + Result ret = MapTransferMemory64(system, trmem_handle, address, size, owner_perm); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_UnmapTransferMemory64(Core::System& system, std::span args) { - Result ret{}; - - Handle trmem_handle{}; - uint64_t address{}; - uint64_t size{}; - - trmem_handle = Convert(GetArg64(args, 0)); - address = Convert(GetArg64(args, 1)); - size = Convert(GetArg64(args, 2)); - - ret = UnmapTransferMemory64(system, trmem_handle, address, size); - + Handle trmem_handle = Convert(GetArg64(args, 0)); + uint64_t address = Convert(GetArg64(args, 1)); + uint64_t size = Convert(GetArg64(args, 2)); + Result ret = UnmapTransferMemory64(system, trmem_handle, address, size); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_CreateInterruptEvent64(Core::System& system, std::span args) { - Result ret{}; - + int32_t interrupt_id = Convert(GetArg64(args, 1)); + InterruptType interrupt_type = Convert(GetArg64(args, 2)); Handle out_read_handle{}; - int32_t interrupt_id{}; - InterruptType interrupt_type{}; - - interrupt_id = Convert(GetArg64(args, 1)); - interrupt_type = Convert(GetArg64(args, 2)); - - ret = CreateInterruptEvent64(system, std::addressof(out_read_handle), interrupt_id, interrupt_type); - + Result ret = CreateInterruptEvent64(system, std::addressof(out_read_handle), interrupt_id, interrupt_type); SetArg64(args, 0, Convert(ret)); SetArg64(args, 1, Convert(out_read_handle)); } static void SvcWrap_QueryPhysicalAddress64(Core::System& system, std::span args) { - Result ret{}; - + uint64_t address = Convert(GetArg64(args, 1)); lp64::PhysicalMemoryInfo out_info{}; - uint64_t address{}; - - address = Convert(GetArg64(args, 1)); - - ret = QueryPhysicalAddress64(system, std::addressof(out_info), address); - + Result ret = QueryPhysicalAddress64(system, std::addressof(out_info), address); SetArg64(args, 0, Convert(ret)); auto out_info_scatter = Convert>(out_info); SetArg64(args, 1, out_info_scatter[0]); @@ -3218,952 +1872,498 @@ static void SvcWrap_QueryPhysicalAddress64(Core::System& system, std::span args) { - Result ret{}; - + uint64_t physical_address = Convert(GetArg64(args, 2)); + uint64_t size = Convert(GetArg64(args, 3)); uint64_t out_address{}; uint64_t out_size{}; - uint64_t physical_address{}; - uint64_t size{}; - - physical_address = Convert(GetArg64(args, 2)); - size = Convert(GetArg64(args, 3)); - - ret = QueryIoMapping64(system, std::addressof(out_address), std::addressof(out_size), physical_address, size); - + Result ret = QueryIoMapping64(system, std::addressof(out_address), std::addressof(out_size), physical_address, size); SetArg64(args, 0, Convert(ret)); SetArg64(args, 1, Convert(out_address)); SetArg64(args, 2, Convert(out_size)); } static void SvcWrap_CreateDeviceAddressSpace64(Core::System& system, std::span args) { - Result ret{}; - + uint64_t das_address = Convert(GetArg64(args, 1)); + uint64_t das_size = Convert(GetArg64(args, 2)); Handle out_handle{}; - uint64_t das_address{}; - uint64_t das_size{}; - - das_address = Convert(GetArg64(args, 1)); - das_size = Convert(GetArg64(args, 2)); - - ret = CreateDeviceAddressSpace64(system, std::addressof(out_handle), das_address, das_size); - + Result ret = CreateDeviceAddressSpace64(system, std::addressof(out_handle), das_address, das_size); SetArg64(args, 0, Convert(ret)); SetArg64(args, 1, Convert(out_handle)); } static void SvcWrap_AttachDeviceAddressSpace64(Core::System& system, std::span args) { - Result ret{}; - - DeviceName device_name{}; - Handle das_handle{}; - - device_name = Convert(GetArg64(args, 0)); - das_handle = Convert(GetArg64(args, 1)); - - ret = AttachDeviceAddressSpace64(system, device_name, das_handle); - + DeviceName device_name = Convert(GetArg64(args, 0)); + Handle das_handle = Convert(GetArg64(args, 1)); + Result ret = AttachDeviceAddressSpace64(system, device_name, das_handle); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_DetachDeviceAddressSpace64(Core::System& system, std::span args) { - Result ret{}; - - DeviceName device_name{}; - Handle das_handle{}; - - device_name = Convert(GetArg64(args, 0)); - das_handle = Convert(GetArg64(args, 1)); - - ret = DetachDeviceAddressSpace64(system, device_name, das_handle); - + DeviceName device_name = Convert(GetArg64(args, 0)); + Handle das_handle = Convert(GetArg64(args, 1)); + Result ret = DetachDeviceAddressSpace64(system, device_name, das_handle); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_MapDeviceAddressSpaceByForce64(Core::System& system, std::span args) { - Result ret{}; - - Handle das_handle{}; - Handle process_handle{}; - uint64_t process_address{}; - uint64_t size{}; - uint64_t device_address{}; - uint32_t option{}; - - das_handle = Convert(GetArg64(args, 0)); - process_handle = Convert(GetArg64(args, 1)); - process_address = Convert(GetArg64(args, 2)); - size = Convert(GetArg64(args, 3)); - device_address = Convert(GetArg64(args, 4)); - option = Convert(GetArg64(args, 5)); - - ret = MapDeviceAddressSpaceByForce64(system, das_handle, process_handle, process_address, size, device_address, option); - + Handle das_handle = Convert(GetArg64(args, 0)); + Handle process_handle = Convert(GetArg64(args, 1)); + uint64_t process_address = Convert(GetArg64(args, 2)); + uint64_t size = Convert(GetArg64(args, 3)); + uint64_t device_address = Convert(GetArg64(args, 4)); + uint32_t option = Convert(GetArg64(args, 5)); + Result ret = MapDeviceAddressSpaceByForce64(system, das_handle, process_handle, process_address, size, device_address, option); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_MapDeviceAddressSpaceAligned64(Core::System& system, std::span args) { - Result ret{}; - - Handle das_handle{}; - Handle process_handle{}; - uint64_t process_address{}; - uint64_t size{}; - uint64_t device_address{}; - uint32_t option{}; - - das_handle = Convert(GetArg64(args, 0)); - process_handle = Convert(GetArg64(args, 1)); - process_address = Convert(GetArg64(args, 2)); - size = Convert(GetArg64(args, 3)); - device_address = Convert(GetArg64(args, 4)); - option = Convert(GetArg64(args, 5)); - - ret = MapDeviceAddressSpaceAligned64(system, das_handle, process_handle, process_address, size, device_address, option); - + Handle das_handle = Convert(GetArg64(args, 0)); + Handle process_handle = Convert(GetArg64(args, 1)); + uint64_t process_address = Convert(GetArg64(args, 2)); + uint64_t size = Convert(GetArg64(args, 3)); + uint64_t device_address = Convert(GetArg64(args, 4)); + uint32_t option = Convert(GetArg64(args, 5)); + Result ret = MapDeviceAddressSpaceAligned64(system, das_handle, process_handle, process_address, size, device_address, option); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_UnmapDeviceAddressSpace64(Core::System& system, std::span args) { - Result ret{}; - - Handle das_handle{}; - Handle process_handle{}; - uint64_t process_address{}; - uint64_t size{}; - uint64_t device_address{}; - - das_handle = Convert(GetArg64(args, 0)); - process_handle = Convert(GetArg64(args, 1)); - process_address = Convert(GetArg64(args, 2)); - size = Convert(GetArg64(args, 3)); - device_address = Convert(GetArg64(args, 4)); - - ret = UnmapDeviceAddressSpace64(system, das_handle, process_handle, process_address, size, device_address); - + Handle das_handle = Convert(GetArg64(args, 0)); + Handle process_handle = Convert(GetArg64(args, 1)); + uint64_t process_address = Convert(GetArg64(args, 2)); + uint64_t size = Convert(GetArg64(args, 3)); + uint64_t device_address = Convert(GetArg64(args, 4)); + Result ret = UnmapDeviceAddressSpace64(system, das_handle, process_handle, process_address, size, device_address); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_InvalidateProcessDataCache64(Core::System& system, std::span args) { - Result ret{}; - - Handle process_handle{}; - uint64_t address{}; - uint64_t size{}; - - process_handle = Convert(GetArg64(args, 0)); - address = Convert(GetArg64(args, 1)); - size = Convert(GetArg64(args, 2)); - - ret = InvalidateProcessDataCache64(system, process_handle, address, size); - + Handle process_handle = Convert(GetArg64(args, 0)); + uint64_t address = Convert(GetArg64(args, 1)); + uint64_t size = Convert(GetArg64(args, 2)); + Result ret = InvalidateProcessDataCache64(system, process_handle, address, size); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_StoreProcessDataCache64(Core::System& system, std::span args) { - Result ret{}; - - Handle process_handle{}; - uint64_t address{}; - uint64_t size{}; - - process_handle = Convert(GetArg64(args, 0)); - address = Convert(GetArg64(args, 1)); - size = Convert(GetArg64(args, 2)); - - ret = StoreProcessDataCache64(system, process_handle, address, size); - + Handle process_handle = Convert(GetArg64(args, 0)); + uint64_t address = Convert(GetArg64(args, 1)); + uint64_t size = Convert(GetArg64(args, 2)); + Result ret = StoreProcessDataCache64(system, process_handle, address, size); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_FlushProcessDataCache64(Core::System& system, std::span args) { - Result ret{}; - - Handle process_handle{}; - uint64_t address{}; - uint64_t size{}; - - process_handle = Convert(GetArg64(args, 0)); - address = Convert(GetArg64(args, 1)); - size = Convert(GetArg64(args, 2)); - - ret = FlushProcessDataCache64(system, process_handle, address, size); - + Handle process_handle = Convert(GetArg64(args, 0)); + uint64_t address = Convert(GetArg64(args, 1)); + uint64_t size = Convert(GetArg64(args, 2)); + Result ret = FlushProcessDataCache64(system, process_handle, address, size); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_DebugActiveProcess64(Core::System& system, std::span args) { - Result ret{}; - + uint64_t process_id = Convert(GetArg64(args, 1)); Handle out_handle{}; - uint64_t process_id{}; - - process_id = Convert(GetArg64(args, 1)); - - ret = DebugActiveProcess64(system, std::addressof(out_handle), process_id); - + Result ret = DebugActiveProcess64(system, std::addressof(out_handle), process_id); SetArg64(args, 0, Convert(ret)); SetArg64(args, 1, Convert(out_handle)); } static void SvcWrap_BreakDebugProcess64(Core::System& system, std::span args) { - Result ret{}; - - Handle debug_handle{}; - - debug_handle = Convert(GetArg64(args, 0)); - - ret = BreakDebugProcess64(system, debug_handle); - + Handle debug_handle = Convert(GetArg64(args, 0)); + Result ret = BreakDebugProcess64(system, debug_handle); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_TerminateDebugProcess64(Core::System& system, std::span args) { - Result ret{}; - - Handle debug_handle{}; - - debug_handle = Convert(GetArg64(args, 0)); - - ret = TerminateDebugProcess64(system, debug_handle); - + Handle debug_handle = Convert(GetArg64(args, 0)); + Result ret = TerminateDebugProcess64(system, debug_handle); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_GetDebugEvent64(Core::System& system, std::span args) { - Result ret{}; - - uint64_t out_info{}; - Handle debug_handle{}; - - out_info = Convert(GetArg64(args, 0)); - debug_handle = Convert(GetArg64(args, 1)); - - ret = GetDebugEvent64(system, out_info, debug_handle); - + uint64_t out_info = Convert(GetArg64(args, 0)); + Handle debug_handle = Convert(GetArg64(args, 1)); + Result ret = GetDebugEvent64(system, out_info, debug_handle); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_ContinueDebugEvent64(Core::System& system, std::span args) { - Result ret{}; - - Handle debug_handle{}; - uint32_t flags{}; - uint64_t thread_ids{}; - int32_t num_thread_ids{}; - - debug_handle = Convert(GetArg64(args, 0)); - flags = Convert(GetArg64(args, 1)); - thread_ids = Convert(GetArg64(args, 2)); - num_thread_ids = Convert(GetArg64(args, 3)); - - ret = ContinueDebugEvent64(system, debug_handle, flags, thread_ids, num_thread_ids); - + Handle debug_handle = Convert(GetArg64(args, 0)); + uint32_t flags = Convert(GetArg64(args, 1)); + uint64_t thread_ids = Convert(GetArg64(args, 2)); + int32_t num_thread_ids = Convert(GetArg64(args, 3)); + Result ret = ContinueDebugEvent64(system, debug_handle, flags, thread_ids, num_thread_ids); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_GetProcessList64(Core::System& system, std::span args) { - Result ret{}; - + uint64_t out_process_ids = Convert(GetArg64(args, 1)); + int32_t max_out_count = Convert(GetArg64(args, 2)); int32_t out_num_processes{}; - uint64_t out_process_ids{}; - int32_t max_out_count{}; - - out_process_ids = Convert(GetArg64(args, 1)); - max_out_count = Convert(GetArg64(args, 2)); - - ret = GetProcessList64(system, std::addressof(out_num_processes), out_process_ids, max_out_count); - + Result ret = GetProcessList64(system, std::addressof(out_num_processes), out_process_ids, max_out_count); SetArg64(args, 0, Convert(ret)); SetArg64(args, 1, Convert(out_num_processes)); } static void SvcWrap_GetThreadList64(Core::System& system, std::span args) { - Result ret{}; - + uint64_t out_thread_ids = Convert(GetArg64(args, 1)); + int32_t max_out_count = Convert(GetArg64(args, 2)); + Handle debug_handle = Convert(GetArg64(args, 3)); int32_t out_num_threads{}; - uint64_t out_thread_ids{}; - int32_t max_out_count{}; - Handle debug_handle{}; - - out_thread_ids = Convert(GetArg64(args, 1)); - max_out_count = Convert(GetArg64(args, 2)); - debug_handle = Convert(GetArg64(args, 3)); - - ret = GetThreadList64(system, std::addressof(out_num_threads), out_thread_ids, max_out_count, debug_handle); - + Result ret = GetThreadList64(system, std::addressof(out_num_threads), out_thread_ids, max_out_count, debug_handle); SetArg64(args, 0, Convert(ret)); SetArg64(args, 1, Convert(out_num_threads)); } static void SvcWrap_GetDebugThreadContext64(Core::System& system, std::span args) { - Result ret{}; - - uint64_t out_context{}; - Handle debug_handle{}; - uint64_t thread_id{}; - uint32_t context_flags{}; - - out_context = Convert(GetArg64(args, 0)); - debug_handle = Convert(GetArg64(args, 1)); - thread_id = Convert(GetArg64(args, 2)); - context_flags = Convert(GetArg64(args, 3)); - - ret = GetDebugThreadContext64(system, out_context, debug_handle, thread_id, context_flags); - + uint64_t out_context = Convert(GetArg64(args, 0)); + Handle debug_handle = Convert(GetArg64(args, 1)); + uint64_t thread_id = Convert(GetArg64(args, 2)); + uint32_t context_flags = Convert(GetArg64(args, 3)); + Result ret = GetDebugThreadContext64(system, out_context, debug_handle, thread_id, context_flags); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_SetDebugThreadContext64(Core::System& system, std::span args) { - Result ret{}; - - Handle debug_handle{}; - uint64_t thread_id{}; - uint64_t context{}; - uint32_t context_flags{}; - - debug_handle = Convert(GetArg64(args, 0)); - thread_id = Convert(GetArg64(args, 1)); - context = Convert(GetArg64(args, 2)); - context_flags = Convert(GetArg64(args, 3)); - - ret = SetDebugThreadContext64(system, debug_handle, thread_id, context, context_flags); - + Handle debug_handle = Convert(GetArg64(args, 0)); + uint64_t thread_id = Convert(GetArg64(args, 1)); + uint64_t context = Convert(GetArg64(args, 2)); + uint32_t context_flags = Convert(GetArg64(args, 3)); + Result ret = SetDebugThreadContext64(system, debug_handle, thread_id, context, context_flags); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_QueryDebugProcessMemory64(Core::System& system, std::span args) { - Result ret{}; - + uint64_t out_memory_info = Convert(GetArg64(args, 0)); + Handle process_handle = Convert(GetArg64(args, 2)); + uint64_t address = Convert(GetArg64(args, 3)); PageInfo out_page_info{}; - uint64_t out_memory_info{}; - Handle process_handle{}; - uint64_t address{}; - - out_memory_info = Convert(GetArg64(args, 0)); - process_handle = Convert(GetArg64(args, 2)); - address = Convert(GetArg64(args, 3)); - - ret = QueryDebugProcessMemory64(system, out_memory_info, std::addressof(out_page_info), process_handle, address); - + Result ret = QueryDebugProcessMemory64(system, out_memory_info, std::addressof(out_page_info), process_handle, address); SetArg64(args, 0, Convert(ret)); SetArg64(args, 1, Convert(out_page_info)); } static void SvcWrap_ReadDebugProcessMemory64(Core::System& system, std::span args) { - Result ret{}; - - uint64_t buffer{}; - Handle debug_handle{}; - uint64_t address{}; - uint64_t size{}; - - buffer = Convert(GetArg64(args, 0)); - debug_handle = Convert(GetArg64(args, 1)); - address = Convert(GetArg64(args, 2)); - size = Convert(GetArg64(args, 3)); - - ret = ReadDebugProcessMemory64(system, buffer, debug_handle, address, size); - + uint64_t buffer = Convert(GetArg64(args, 0)); + Handle debug_handle = Convert(GetArg64(args, 1)); + uint64_t address = Convert(GetArg64(args, 2)); + uint64_t size = Convert(GetArg64(args, 3)); + Result ret = ReadDebugProcessMemory64(system, buffer, debug_handle, address, size); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_WriteDebugProcessMemory64(Core::System& system, std::span args) { - Result ret{}; - - Handle debug_handle{}; - uint64_t buffer{}; - uint64_t address{}; - uint64_t size{}; - - debug_handle = Convert(GetArg64(args, 0)); - buffer = Convert(GetArg64(args, 1)); - address = Convert(GetArg64(args, 2)); - size = Convert(GetArg64(args, 3)); - - ret = WriteDebugProcessMemory64(system, debug_handle, buffer, address, size); - + Handle debug_handle = Convert(GetArg64(args, 0)); + uint64_t buffer = Convert(GetArg64(args, 1)); + uint64_t address = Convert(GetArg64(args, 2)); + uint64_t size = Convert(GetArg64(args, 3)); + Result ret = WriteDebugProcessMemory64(system, debug_handle, buffer, address, size); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_SetHardwareBreakPoint64(Core::System& system, std::span args) { - Result ret{}; - - HardwareBreakPointRegisterName name{}; - uint64_t flags{}; - uint64_t value{}; - - name = Convert(GetArg64(args, 0)); - flags = Convert(GetArg64(args, 1)); - value = Convert(GetArg64(args, 2)); - - ret = SetHardwareBreakPoint64(system, name, flags, value); - + HardwareBreakPointRegisterName name = Convert(GetArg64(args, 0)); + uint64_t flags = Convert(GetArg64(args, 1)); + uint64_t value = Convert(GetArg64(args, 2)); + Result ret = SetHardwareBreakPoint64(system, name, flags, value); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_GetDebugThreadParam64(Core::System& system, std::span args) { - Result ret{}; - + Handle debug_handle = Convert(GetArg64(args, 2)); + uint64_t thread_id = Convert(GetArg64(args, 3)); + DebugThreadParam param = Convert(GetArg64(args, 4)); uint64_t out_64{}; uint32_t out_32{}; - Handle debug_handle{}; - uint64_t thread_id{}; - DebugThreadParam param{}; - - debug_handle = Convert(GetArg64(args, 2)); - thread_id = Convert(GetArg64(args, 3)); - param = Convert(GetArg64(args, 4)); - - ret = GetDebugThreadParam64(system, std::addressof(out_64), std::addressof(out_32), debug_handle, thread_id, param); - + Result ret = GetDebugThreadParam64(system, std::addressof(out_64), std::addressof(out_32), debug_handle, thread_id, param); SetArg64(args, 0, Convert(ret)); SetArg64(args, 1, Convert(out_64)); SetArg64(args, 2, Convert(out_32)); } static void SvcWrap_GetSystemInfo64(Core::System& system, std::span args) { - Result ret{}; - + SystemInfoType info_type = Convert(GetArg64(args, 1)); + Handle handle = Convert(GetArg64(args, 2)); + uint64_t info_subtype = Convert(GetArg64(args, 3)); uint64_t out{}; - SystemInfoType info_type{}; - Handle handle{}; - uint64_t info_subtype{}; - - info_type = Convert(GetArg64(args, 1)); - handle = Convert(GetArg64(args, 2)); - info_subtype = Convert(GetArg64(args, 3)); - - ret = GetSystemInfo64(system, std::addressof(out), info_type, handle, info_subtype); - + Result ret = GetSystemInfo64(system, std::addressof(out), info_type, handle, info_subtype); SetArg64(args, 0, Convert(ret)); SetArg64(args, 1, Convert(out)); } static void SvcWrap_CreatePort64(Core::System& system, std::span args) { - Result ret{}; - + int32_t max_sessions = Convert(GetArg64(args, 2)); + bool is_light = Convert(GetArg64(args, 3)); + uint64_t name = Convert(GetArg64(args, 4)); Handle out_server_handle{}; Handle out_client_handle{}; - int32_t max_sessions{}; - bool is_light{}; - uint64_t name{}; - - max_sessions = Convert(GetArg64(args, 2)); - is_light = Convert(GetArg64(args, 3)); - name = Convert(GetArg64(args, 4)); - - ret = CreatePort64(system, std::addressof(out_server_handle), std::addressof(out_client_handle), max_sessions, is_light, name); - + Result ret = CreatePort64(system, std::addressof(out_server_handle), std::addressof(out_client_handle), max_sessions, is_light, name); SetArg64(args, 0, Convert(ret)); SetArg64(args, 1, Convert(out_server_handle)); SetArg64(args, 2, Convert(out_client_handle)); } static void SvcWrap_ManageNamedPort64(Core::System& system, std::span args) { - Result ret{}; - + uint64_t name = Convert(GetArg64(args, 1)); + int32_t max_sessions = Convert(GetArg64(args, 2)); Handle out_server_handle{}; - uint64_t name{}; - int32_t max_sessions{}; - - name = Convert(GetArg64(args, 1)); - max_sessions = Convert(GetArg64(args, 2)); - - ret = ManageNamedPort64(system, std::addressof(out_server_handle), name, max_sessions); - + Result ret = ManageNamedPort64(system, std::addressof(out_server_handle), name, max_sessions); SetArg64(args, 0, Convert(ret)); SetArg64(args, 1, Convert(out_server_handle)); } static void SvcWrap_ConnectToPort64(Core::System& system, std::span args) { - Result ret{}; - + Handle port = Convert(GetArg64(args, 1)); Handle out_handle{}; - Handle port{}; - - port = Convert(GetArg64(args, 1)); - - ret = ConnectToPort64(system, std::addressof(out_handle), port); - + Result ret = ConnectToPort64(system, std::addressof(out_handle), port); SetArg64(args, 0, Convert(ret)); SetArg64(args, 1, Convert(out_handle)); } static void SvcWrap_SetProcessMemoryPermission64(Core::System& system, std::span args) { - Result ret{}; - - Handle process_handle{}; - uint64_t address{}; - uint64_t size{}; - MemoryPermission perm{}; - - process_handle = Convert(GetArg64(args, 0)); - address = Convert(GetArg64(args, 1)); - size = Convert(GetArg64(args, 2)); - perm = Convert(GetArg64(args, 3)); - - ret = SetProcessMemoryPermission64(system, process_handle, address, size, perm); - + Handle process_handle = Convert(GetArg64(args, 0)); + uint64_t address = Convert(GetArg64(args, 1)); + uint64_t size = Convert(GetArg64(args, 2)); + MemoryPermission perm = Convert(GetArg64(args, 3)); + Result ret = SetProcessMemoryPermission64(system, process_handle, address, size, perm); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_MapProcessMemory64(Core::System& system, std::span args) { - Result ret{}; - - uint64_t dst_address{}; - Handle process_handle{}; - uint64_t src_address{}; - uint64_t size{}; - - dst_address = Convert(GetArg64(args, 0)); - process_handle = Convert(GetArg64(args, 1)); - src_address = Convert(GetArg64(args, 2)); - size = Convert(GetArg64(args, 3)); - - ret = MapProcessMemory64(system, dst_address, process_handle, src_address, size); - + uint64_t dst_address = Convert(GetArg64(args, 0)); + Handle process_handle = Convert(GetArg64(args, 1)); + uint64_t src_address = Convert(GetArg64(args, 2)); + uint64_t size = Convert(GetArg64(args, 3)); + Result ret = MapProcessMemory64(system, dst_address, process_handle, src_address, size); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_UnmapProcessMemory64(Core::System& system, std::span args) { - Result ret{}; - - uint64_t dst_address{}; - Handle process_handle{}; - uint64_t src_address{}; - uint64_t size{}; - - dst_address = Convert(GetArg64(args, 0)); - process_handle = Convert(GetArg64(args, 1)); - src_address = Convert(GetArg64(args, 2)); - size = Convert(GetArg64(args, 3)); - - ret = UnmapProcessMemory64(system, dst_address, process_handle, src_address, size); - + uint64_t dst_address = Convert(GetArg64(args, 0)); + Handle process_handle = Convert(GetArg64(args, 1)); + uint64_t src_address = Convert(GetArg64(args, 2)); + uint64_t size = Convert(GetArg64(args, 3)); + Result ret = UnmapProcessMemory64(system, dst_address, process_handle, src_address, size); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_QueryProcessMemory64(Core::System& system, std::span args) { - Result ret{}; - + uint64_t out_memory_info = Convert(GetArg64(args, 0)); + Handle process_handle = Convert(GetArg64(args, 2)); + uint64_t address = Convert(GetArg64(args, 3)); PageInfo out_page_info{}; - uint64_t out_memory_info{}; - Handle process_handle{}; - uint64_t address{}; - - out_memory_info = Convert(GetArg64(args, 0)); - process_handle = Convert(GetArg64(args, 2)); - address = Convert(GetArg64(args, 3)); - - ret = QueryProcessMemory64(system, out_memory_info, std::addressof(out_page_info), process_handle, address); - + Result ret = QueryProcessMemory64(system, out_memory_info, std::addressof(out_page_info), process_handle, address); SetArg64(args, 0, Convert(ret)); SetArg64(args, 1, Convert(out_page_info)); } static void SvcWrap_MapProcessCodeMemory64(Core::System& system, std::span args) { - Result ret{}; - - Handle process_handle{}; - uint64_t dst_address{}; - uint64_t src_address{}; - uint64_t size{}; - - process_handle = Convert(GetArg64(args, 0)); - dst_address = Convert(GetArg64(args, 1)); - src_address = Convert(GetArg64(args, 2)); - size = Convert(GetArg64(args, 3)); - - ret = MapProcessCodeMemory64(system, process_handle, dst_address, src_address, size); - + Handle process_handle = Convert(GetArg64(args, 0)); + uint64_t dst_address = Convert(GetArg64(args, 1)); + uint64_t src_address = Convert(GetArg64(args, 2)); + uint64_t size = Convert(GetArg64(args, 3)); + Result ret = MapProcessCodeMemory64(system, process_handle, dst_address, src_address, size); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_UnmapProcessCodeMemory64(Core::System& system, std::span args) { - Result ret{}; - - Handle process_handle{}; - uint64_t dst_address{}; - uint64_t src_address{}; - uint64_t size{}; - - process_handle = Convert(GetArg64(args, 0)); - dst_address = Convert(GetArg64(args, 1)); - src_address = Convert(GetArg64(args, 2)); - size = Convert(GetArg64(args, 3)); - - ret = UnmapProcessCodeMemory64(system, process_handle, dst_address, src_address, size); - + Handle process_handle = Convert(GetArg64(args, 0)); + uint64_t dst_address = Convert(GetArg64(args, 1)); + uint64_t src_address = Convert(GetArg64(args, 2)); + uint64_t size = Convert(GetArg64(args, 3)); + Result ret = UnmapProcessCodeMemory64(system, process_handle, dst_address, src_address, size); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_CreateProcess64(Core::System& system, std::span args) { - Result ret{}; - + uint64_t parameters = Convert(GetArg64(args, 1)); + uint64_t caps = Convert(GetArg64(args, 2)); + int32_t num_caps = Convert(GetArg64(args, 3)); Handle out_handle{}; - uint64_t parameters{}; - uint64_t caps{}; - int32_t num_caps{}; - - parameters = Convert(GetArg64(args, 1)); - caps = Convert(GetArg64(args, 2)); - num_caps = Convert(GetArg64(args, 3)); - - ret = CreateProcess64(system, std::addressof(out_handle), parameters, caps, num_caps); - + Result ret = CreateProcess64(system, std::addressof(out_handle), parameters, caps, num_caps); SetArg64(args, 0, Convert(ret)); SetArg64(args, 1, Convert(out_handle)); } static void SvcWrap_StartProcess64(Core::System& system, std::span args) { - Result ret{}; - - Handle process_handle{}; - int32_t priority{}; - int32_t core_id{}; - uint64_t main_thread_stack_size{}; - - process_handle = Convert(GetArg64(args, 0)); - priority = Convert(GetArg64(args, 1)); - core_id = Convert(GetArg64(args, 2)); - main_thread_stack_size = Convert(GetArg64(args, 3)); - - ret = StartProcess64(system, process_handle, priority, core_id, main_thread_stack_size); - + Handle process_handle = Convert(GetArg64(args, 0)); + int32_t priority = Convert(GetArg64(args, 1)); + int32_t core_id = Convert(GetArg64(args, 2)); + uint64_t main_thread_stack_size = Convert(GetArg64(args, 3)); + Result ret = StartProcess64(system, process_handle, priority, core_id, main_thread_stack_size); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_TerminateProcess64(Core::System& system, std::span args) { - Result ret{}; - - Handle process_handle{}; - - process_handle = Convert(GetArg64(args, 0)); - - ret = TerminateProcess64(system, process_handle); - + Handle process_handle = Convert(GetArg64(args, 0)); + Result ret = TerminateProcess64(system, process_handle); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_GetProcessInfo64(Core::System& system, std::span args) { - Result ret{}; - + Handle process_handle = Convert(GetArg64(args, 1)); + ProcessInfoType info_type = Convert(GetArg64(args, 2)); int64_t out_info{}; - Handle process_handle{}; - ProcessInfoType info_type{}; - - process_handle = Convert(GetArg64(args, 1)); - info_type = Convert(GetArg64(args, 2)); - - ret = GetProcessInfo64(system, std::addressof(out_info), process_handle, info_type); - + Result ret = GetProcessInfo64(system, std::addressof(out_info), process_handle, info_type); SetArg64(args, 0, Convert(ret)); SetArg64(args, 1, Convert(out_info)); } static void SvcWrap_CreateResourceLimit64(Core::System& system, std::span args) { - Result ret{}; - Handle out_handle{}; - - ret = CreateResourceLimit64(system, std::addressof(out_handle)); - + Result ret = CreateResourceLimit64(system, std::addressof(out_handle)); SetArg64(args, 0, Convert(ret)); SetArg64(args, 1, Convert(out_handle)); } static void SvcWrap_SetResourceLimitLimitValue64(Core::System& system, std::span args) { - Result ret{}; - - Handle resource_limit_handle{}; - LimitableResource which{}; - int64_t limit_value{}; - - resource_limit_handle = Convert(GetArg64(args, 0)); - which = Convert(GetArg64(args, 1)); - limit_value = Convert(GetArg64(args, 2)); - - ret = SetResourceLimitLimitValue64(system, resource_limit_handle, which, limit_value); - + Handle resource_limit_handle = Convert(GetArg64(args, 0)); + LimitableResource which = Convert(GetArg64(args, 1)); + int64_t limit_value = Convert(GetArg64(args, 2)); + Result ret = SetResourceLimitLimitValue64(system, resource_limit_handle, which, limit_value); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_MapInsecureMemory64(Core::System& system, std::span args) { - Result ret{}; - - uint64_t address{}; - uint64_t size{}; - - address = Convert(GetArg64(args, 0)); - size = Convert(GetArg64(args, 1)); - - ret = MapInsecureMemory64(system, address, size); - + uint64_t address = Convert(GetArg64(args, 0)); + uint64_t size = Convert(GetArg64(args, 1)); + Result ret = MapInsecureMemory64(system, address, size); SetArg64(args, 0, Convert(ret)); } static void SvcWrap_UnmapInsecureMemory64(Core::System& system, std::span args) { - Result ret{}; - - uint64_t address{}; - uint64_t size{}; - - address = Convert(GetArg64(args, 0)); - size = Convert(GetArg64(args, 1)); - - ret = UnmapInsecureMemory64(system, address, size); - + uint64_t address = Convert(GetArg64(args, 0)); + uint64_t size = Convert(GetArg64(args, 1)); + Result ret = UnmapInsecureMemory64(system, address, size); SetArg64(args, 0, Convert(ret)); } static void Call32(Core::System& system, u32 imm, std::span args) { - switch (static_cast(imm)) { - case SvcId::SetHeapSize: - return SvcWrap_SetHeapSize64From32(system, args); - case SvcId::SetMemoryPermission: - return SvcWrap_SetMemoryPermission64From32(system, args); - case SvcId::SetMemoryAttribute: - return SvcWrap_SetMemoryAttribute64From32(system, args); - case SvcId::MapMemory: - return SvcWrap_MapMemory64From32(system, args); - case SvcId::UnmapMemory: - return SvcWrap_UnmapMemory64From32(system, args); - case SvcId::QueryMemory: - return SvcWrap_QueryMemory64From32(system, args); - case SvcId::ExitProcess: - return SvcWrap_ExitProcess64From32(system, args); - case SvcId::CreateThread: - return SvcWrap_CreateThread64From32(system, args); - case SvcId::StartThread: - return SvcWrap_StartThread64From32(system, args); - case SvcId::ExitThread: - return SvcWrap_ExitThread64From32(system, args); - case SvcId::SleepThread: - return SvcWrap_SleepThread64From32(system, args); - case SvcId::GetThreadPriority: - return SvcWrap_GetThreadPriority64From32(system, args); - case SvcId::SetThreadPriority: - return SvcWrap_SetThreadPriority64From32(system, args); - case SvcId::GetThreadCoreMask: - return SvcWrap_GetThreadCoreMask64From32(system, args); - case SvcId::SetThreadCoreMask: - return SvcWrap_SetThreadCoreMask64From32(system, args); - case SvcId::GetCurrentProcessorNumber: - return SvcWrap_GetCurrentProcessorNumber64From32(system, args); - case SvcId::SignalEvent: - return SvcWrap_SignalEvent64From32(system, args); - case SvcId::ClearEvent: - return SvcWrap_ClearEvent64From32(system, args); - case SvcId::MapSharedMemory: - return SvcWrap_MapSharedMemory64From32(system, args); - case SvcId::UnmapSharedMemory: - return SvcWrap_UnmapSharedMemory64From32(system, args); - case SvcId::CreateTransferMemory: - return SvcWrap_CreateTransferMemory64From32(system, args); - case SvcId::CloseHandle: - return SvcWrap_CloseHandle64From32(system, args); - case SvcId::ResetSignal: - return SvcWrap_ResetSignal64From32(system, args); - case SvcId::WaitSynchronization: - return SvcWrap_WaitSynchronization64From32(system, args); - case SvcId::CancelSynchronization: - return SvcWrap_CancelSynchronization64From32(system, args); - case SvcId::ArbitrateLock: - return SvcWrap_ArbitrateLock64From32(system, args); - case SvcId::ArbitrateUnlock: - return SvcWrap_ArbitrateUnlock64From32(system, args); - case SvcId::WaitProcessWideKeyAtomic: - return SvcWrap_WaitProcessWideKeyAtomic64From32(system, args); - case SvcId::SignalProcessWideKey: - return SvcWrap_SignalProcessWideKey64From32(system, args); - case SvcId::GetSystemTick: - return SvcWrap_GetSystemTick64From32(system, args); - case SvcId::ConnectToNamedPort: - return SvcWrap_ConnectToNamedPort64From32(system, args); - case SvcId::SendSyncRequestLight: - return SvcWrap_SendSyncRequestLight64From32(system, args); - case SvcId::SendSyncRequest: - return SvcWrap_SendSyncRequest64From32(system, args); - case SvcId::SendSyncRequestWithUserBuffer: - return SvcWrap_SendSyncRequestWithUserBuffer64From32(system, args); - case SvcId::SendAsyncRequestWithUserBuffer: - return SvcWrap_SendAsyncRequestWithUserBuffer64From32(system, args); - case SvcId::GetProcessId: - return SvcWrap_GetProcessId64From32(system, args); - case SvcId::GetThreadId: - return SvcWrap_GetThreadId64From32(system, args); - case SvcId::Break: - return SvcWrap_Break64From32(system, args); - case SvcId::OutputDebugString: - return SvcWrap_OutputDebugString64From32(system, args); - case SvcId::ReturnFromException: - return SvcWrap_ReturnFromException64From32(system, args); - case SvcId::GetInfo: - return SvcWrap_GetInfo64From32(system, args); - case SvcId::FlushEntireDataCache: - return SvcWrap_FlushEntireDataCache64From32(system, args); - case SvcId::FlushDataCache: - return SvcWrap_FlushDataCache64From32(system, args); - case SvcId::MapPhysicalMemory: - return SvcWrap_MapPhysicalMemory64From32(system, args); - case SvcId::UnmapPhysicalMemory: - return SvcWrap_UnmapPhysicalMemory64From32(system, args); - case SvcId::GetDebugFutureThreadInfo: - return SvcWrap_GetDebugFutureThreadInfo64From32(system, args); - case SvcId::GetLastThreadInfo: - return SvcWrap_GetLastThreadInfo64From32(system, args); - case SvcId::GetResourceLimitLimitValue: - return SvcWrap_GetResourceLimitLimitValue64From32(system, args); - case SvcId::GetResourceLimitCurrentValue: - return SvcWrap_GetResourceLimitCurrentValue64From32(system, args); - case SvcId::SetThreadActivity: - return SvcWrap_SetThreadActivity64From32(system, args); - case SvcId::GetThreadContext3: - return SvcWrap_GetThreadContext364From32(system, args); - case SvcId::WaitForAddress: - return SvcWrap_WaitForAddress64From32(system, args); - case SvcId::SignalToAddress: - return SvcWrap_SignalToAddress64From32(system, args); - case SvcId::SynchronizePreemptionState: - return SvcWrap_SynchronizePreemptionState64From32(system, args); - case SvcId::GetResourceLimitPeakValue: - return SvcWrap_GetResourceLimitPeakValue64From32(system, args); - case SvcId::CreateIoPool: - return SvcWrap_CreateIoPool64From32(system, args); - case SvcId::CreateIoRegion: - return SvcWrap_CreateIoRegion64From32(system, args); - case SvcId::KernelDebug: - return SvcWrap_KernelDebug64From32(system, args); - case SvcId::ChangeKernelTraceState: - return SvcWrap_ChangeKernelTraceState64From32(system, args); - case SvcId::CreateSession: - return SvcWrap_CreateSession64From32(system, args); - case SvcId::AcceptSession: - return SvcWrap_AcceptSession64From32(system, args); - case SvcId::ReplyAndReceiveLight: - return SvcWrap_ReplyAndReceiveLight64From32(system, args); - case SvcId::ReplyAndReceive: - return SvcWrap_ReplyAndReceive64From32(system, args); - case SvcId::ReplyAndReceiveWithUserBuffer: - return SvcWrap_ReplyAndReceiveWithUserBuffer64From32(system, args); - case SvcId::CreateEvent: - return SvcWrap_CreateEvent64From32(system, args); - case SvcId::MapIoRegion: - return SvcWrap_MapIoRegion64From32(system, args); - case SvcId::UnmapIoRegion: - return SvcWrap_UnmapIoRegion64From32(system, args); - case SvcId::MapPhysicalMemoryUnsafe: - return SvcWrap_MapPhysicalMemoryUnsafe64From32(system, args); - case SvcId::UnmapPhysicalMemoryUnsafe: - return SvcWrap_UnmapPhysicalMemoryUnsafe64From32(system, args); - case SvcId::SetUnsafeLimit: - return SvcWrap_SetUnsafeLimit64From32(system, args); - case SvcId::CreateCodeMemory: - return SvcWrap_CreateCodeMemory64From32(system, args); - case SvcId::ControlCodeMemory: - return SvcWrap_ControlCodeMemory64From32(system, args); - case SvcId::SleepSystem: - return SvcWrap_SleepSystem64From32(system, args); - case SvcId::ReadWriteRegister: - return SvcWrap_ReadWriteRegister64From32(system, args); - case SvcId::SetProcessActivity: - return SvcWrap_SetProcessActivity64From32(system, args); - case SvcId::CreateSharedMemory: - return SvcWrap_CreateSharedMemory64From32(system, args); - case SvcId::MapTransferMemory: - return SvcWrap_MapTransferMemory64From32(system, args); - case SvcId::UnmapTransferMemory: - return SvcWrap_UnmapTransferMemory64From32(system, args); - case SvcId::CreateInterruptEvent: - return SvcWrap_CreateInterruptEvent64From32(system, args); - case SvcId::QueryPhysicalAddress: - return SvcWrap_QueryPhysicalAddress64From32(system, args); - case SvcId::QueryIoMapping: - return SvcWrap_QueryIoMapping64From32(system, args); - case SvcId::CreateDeviceAddressSpace: - return SvcWrap_CreateDeviceAddressSpace64From32(system, args); - case SvcId::AttachDeviceAddressSpace: - return SvcWrap_AttachDeviceAddressSpace64From32(system, args); - case SvcId::DetachDeviceAddressSpace: - return SvcWrap_DetachDeviceAddressSpace64From32(system, args); - case SvcId::MapDeviceAddressSpaceByForce: - return SvcWrap_MapDeviceAddressSpaceByForce64From32(system, args); - case SvcId::MapDeviceAddressSpaceAligned: - return SvcWrap_MapDeviceAddressSpaceAligned64From32(system, args); - case SvcId::UnmapDeviceAddressSpace: - return SvcWrap_UnmapDeviceAddressSpace64From32(system, args); - case SvcId::InvalidateProcessDataCache: - return SvcWrap_InvalidateProcessDataCache64From32(system, args); - case SvcId::StoreProcessDataCache: - return SvcWrap_StoreProcessDataCache64From32(system, args); - case SvcId::FlushProcessDataCache: - return SvcWrap_FlushProcessDataCache64From32(system, args); - case SvcId::DebugActiveProcess: - return SvcWrap_DebugActiveProcess64From32(system, args); - case SvcId::BreakDebugProcess: - return SvcWrap_BreakDebugProcess64From32(system, args); - case SvcId::TerminateDebugProcess: - return SvcWrap_TerminateDebugProcess64From32(system, args); - case SvcId::GetDebugEvent: - return SvcWrap_GetDebugEvent64From32(system, args); - case SvcId::ContinueDebugEvent: - return SvcWrap_ContinueDebugEvent64From32(system, args); - case SvcId::GetProcessList: - return SvcWrap_GetProcessList64From32(system, args); - case SvcId::GetThreadList: - return SvcWrap_GetThreadList64From32(system, args); - case SvcId::GetDebugThreadContext: - return SvcWrap_GetDebugThreadContext64From32(system, args); - case SvcId::SetDebugThreadContext: - return SvcWrap_SetDebugThreadContext64From32(system, args); - case SvcId::QueryDebugProcessMemory: - return SvcWrap_QueryDebugProcessMemory64From32(system, args); - case SvcId::ReadDebugProcessMemory: - return SvcWrap_ReadDebugProcessMemory64From32(system, args); - case SvcId::WriteDebugProcessMemory: - return SvcWrap_WriteDebugProcessMemory64From32(system, args); - case SvcId::SetHardwareBreakPoint: - return SvcWrap_SetHardwareBreakPoint64From32(system, args); - case SvcId::GetDebugThreadParam: - return SvcWrap_GetDebugThreadParam64From32(system, args); - case SvcId::GetSystemInfo: - return SvcWrap_GetSystemInfo64From32(system, args); - case SvcId::CreatePort: - return SvcWrap_CreatePort64From32(system, args); - case SvcId::ManageNamedPort: - return SvcWrap_ManageNamedPort64From32(system, args); - case SvcId::ConnectToPort: - return SvcWrap_ConnectToPort64From32(system, args); - case SvcId::SetProcessMemoryPermission: - return SvcWrap_SetProcessMemoryPermission64From32(system, args); - case SvcId::MapProcessMemory: - return SvcWrap_MapProcessMemory64From32(system, args); - case SvcId::UnmapProcessMemory: - return SvcWrap_UnmapProcessMemory64From32(system, args); - case SvcId::QueryProcessMemory: - return SvcWrap_QueryProcessMemory64From32(system, args); - case SvcId::MapProcessCodeMemory: - return SvcWrap_MapProcessCodeMemory64From32(system, args); - case SvcId::UnmapProcessCodeMemory: - return SvcWrap_UnmapProcessCodeMemory64From32(system, args); - case SvcId::CreateProcess: - return SvcWrap_CreateProcess64From32(system, args); - case SvcId::StartProcess: - return SvcWrap_StartProcess64From32(system, args); - case SvcId::TerminateProcess: - return SvcWrap_TerminateProcess64From32(system, args); - case SvcId::GetProcessInfo: - return SvcWrap_GetProcessInfo64From32(system, args); - case SvcId::CreateResourceLimit: - return SvcWrap_CreateResourceLimit64From32(system, args); - case SvcId::SetResourceLimitLimitValue: - return SvcWrap_SetResourceLimitLimitValue64From32(system, args); - case SvcId::CallSecureMonitor: - return SvcWrap_CallSecureMonitor64From32(system, args); - case SvcId::MapInsecureMemory: - return SvcWrap_MapInsecureMemory64From32(system, args); - case SvcId::UnmapInsecureMemory: - return SvcWrap_UnmapInsecureMemory64From32(system, args); + switch (SvcId(imm)) { + case SvcId::SetHeapSize: return SvcWrap_SetHeapSize64From32(system, args); + case SvcId::SetMemoryPermission: return SvcWrap_SetMemoryPermission64From32(system, args); + case SvcId::SetMemoryAttribute: return SvcWrap_SetMemoryAttribute64From32(system, args); + case SvcId::MapMemory: return SvcWrap_MapMemory64From32(system, args); + case SvcId::UnmapMemory: return SvcWrap_UnmapMemory64From32(system, args); + case SvcId::QueryMemory: return SvcWrap_QueryMemory64From32(system, args); + case SvcId::ExitProcess: return SvcWrap_ExitProcess64From32(system, args); + case SvcId::CreateThread: return SvcWrap_CreateThread64From32(system, args); + case SvcId::StartThread: return SvcWrap_StartThread64From32(system, args); + case SvcId::ExitThread: return SvcWrap_ExitThread64From32(system, args); + case SvcId::SleepThread: return SvcWrap_SleepThread64From32(system, args); + case SvcId::GetThreadPriority: return SvcWrap_GetThreadPriority64From32(system, args); + case SvcId::SetThreadPriority: return SvcWrap_SetThreadPriority64From32(system, args); + case SvcId::GetThreadCoreMask: return SvcWrap_GetThreadCoreMask64From32(system, args); + case SvcId::SetThreadCoreMask: return SvcWrap_SetThreadCoreMask64From32(system, args); + case SvcId::GetCurrentProcessorNumber: return SvcWrap_GetCurrentProcessorNumber64From32(system, args); + case SvcId::SignalEvent: return SvcWrap_SignalEvent64From32(system, args); + case SvcId::ClearEvent: return SvcWrap_ClearEvent64From32(system, args); + case SvcId::MapSharedMemory: return SvcWrap_MapSharedMemory64From32(system, args); + case SvcId::UnmapSharedMemory: return SvcWrap_UnmapSharedMemory64From32(system, args); + case SvcId::CreateTransferMemory: return SvcWrap_CreateTransferMemory64From32(system, args); + case SvcId::CloseHandle: return SvcWrap_CloseHandle64From32(system, args); + case SvcId::ResetSignal: return SvcWrap_ResetSignal64From32(system, args); + case SvcId::WaitSynchronization: return SvcWrap_WaitSynchronization64From32(system, args); + case SvcId::CancelSynchronization: return SvcWrap_CancelSynchronization64From32(system, args); + case SvcId::ArbitrateLock: return SvcWrap_ArbitrateLock64From32(system, args); + case SvcId::ArbitrateUnlock: return SvcWrap_ArbitrateUnlock64From32(system, args); + case SvcId::WaitProcessWideKeyAtomic: return SvcWrap_WaitProcessWideKeyAtomic64From32(system, args); + case SvcId::SignalProcessWideKey: return SvcWrap_SignalProcessWideKey64From32(system, args); + case SvcId::GetSystemTick: return SvcWrap_GetSystemTick64From32(system, args); + case SvcId::ConnectToNamedPort: return SvcWrap_ConnectToNamedPort64From32(system, args); + case SvcId::SendSyncRequestLight: return SvcWrap_SendSyncRequestLight64From32(system, args); + case SvcId::SendSyncRequest: return SvcWrap_SendSyncRequest64From32(system, args); + case SvcId::SendSyncRequestWithUserBuffer: return SvcWrap_SendSyncRequestWithUserBuffer64From32(system, args); + case SvcId::SendAsyncRequestWithUserBuffer: return SvcWrap_SendAsyncRequestWithUserBuffer64From32(system, args); + case SvcId::GetProcessId: return SvcWrap_GetProcessId64From32(system, args); + case SvcId::GetThreadId: return SvcWrap_GetThreadId64From32(system, args); + case SvcId::Break: return SvcWrap_Break64From32(system, args); + case SvcId::OutputDebugString: return SvcWrap_OutputDebugString64From32(system, args); + case SvcId::ReturnFromException: return SvcWrap_ReturnFromException64From32(system, args); + case SvcId::GetInfo: return SvcWrap_GetInfo64From32(system, args); + case SvcId::FlushEntireDataCache: return SvcWrap_FlushEntireDataCache64From32(system, args); + case SvcId::FlushDataCache: return SvcWrap_FlushDataCache64From32(system, args); + case SvcId::MapPhysicalMemory: return SvcWrap_MapPhysicalMemory64From32(system, args); + case SvcId::UnmapPhysicalMemory: return SvcWrap_UnmapPhysicalMemory64From32(system, args); + case SvcId::GetDebugFutureThreadInfo: return SvcWrap_GetDebugFutureThreadInfo64From32(system, args); + case SvcId::GetLastThreadInfo: return SvcWrap_GetLastThreadInfo64From32(system, args); + case SvcId::GetResourceLimitLimitValue: return SvcWrap_GetResourceLimitLimitValue64From32(system, args); + case SvcId::GetResourceLimitCurrentValue: return SvcWrap_GetResourceLimitCurrentValue64From32(system, args); + case SvcId::SetThreadActivity: return SvcWrap_SetThreadActivity64From32(system, args); + case SvcId::GetThreadContext3: return SvcWrap_GetThreadContext364From32(system, args); + case SvcId::WaitForAddress: return SvcWrap_WaitForAddress64From32(system, args); + case SvcId::SignalToAddress: return SvcWrap_SignalToAddress64From32(system, args); + case SvcId::SynchronizePreemptionState: return SvcWrap_SynchronizePreemptionState64From32(system, args); + case SvcId::GetResourceLimitPeakValue: return SvcWrap_GetResourceLimitPeakValue64From32(system, args); + case SvcId::CreateIoPool: return SvcWrap_CreateIoPool64From32(system, args); + case SvcId::CreateIoRegion: return SvcWrap_CreateIoRegion64From32(system, args); + case SvcId::KernelDebug: return SvcWrap_KernelDebug64From32(system, args); + case SvcId::ChangeKernelTraceState: return SvcWrap_ChangeKernelTraceState64From32(system, args); + case SvcId::CreateSession: return SvcWrap_CreateSession64From32(system, args); + case SvcId::AcceptSession: return SvcWrap_AcceptSession64From32(system, args); + case SvcId::ReplyAndReceiveLight: return SvcWrap_ReplyAndReceiveLight64From32(system, args); + case SvcId::ReplyAndReceive: return SvcWrap_ReplyAndReceive64From32(system, args); + case SvcId::ReplyAndReceiveWithUserBuffer: return SvcWrap_ReplyAndReceiveWithUserBuffer64From32(system, args); + case SvcId::CreateEvent: return SvcWrap_CreateEvent64From32(system, args); + case SvcId::MapIoRegion: return SvcWrap_MapIoRegion64From32(system, args); + case SvcId::UnmapIoRegion: return SvcWrap_UnmapIoRegion64From32(system, args); + case SvcId::MapPhysicalMemoryUnsafe: return SvcWrap_MapPhysicalMemoryUnsafe64From32(system, args); + case SvcId::UnmapPhysicalMemoryUnsafe: return SvcWrap_UnmapPhysicalMemoryUnsafe64From32(system, args); + case SvcId::SetUnsafeLimit: return SvcWrap_SetUnsafeLimit64From32(system, args); + case SvcId::CreateCodeMemory: return SvcWrap_CreateCodeMemory64From32(system, args); + case SvcId::ControlCodeMemory: return SvcWrap_ControlCodeMemory64From32(system, args); + case SvcId::SleepSystem: return SvcWrap_SleepSystem64From32(system, args); + case SvcId::ReadWriteRegister: return SvcWrap_ReadWriteRegister64From32(system, args); + case SvcId::SetProcessActivity: return SvcWrap_SetProcessActivity64From32(system, args); + case SvcId::CreateSharedMemory: return SvcWrap_CreateSharedMemory64From32(system, args); + case SvcId::MapTransferMemory: return SvcWrap_MapTransferMemory64From32(system, args); + case SvcId::UnmapTransferMemory: return SvcWrap_UnmapTransferMemory64From32(system, args); + case SvcId::CreateInterruptEvent: return SvcWrap_CreateInterruptEvent64From32(system, args); + case SvcId::QueryPhysicalAddress: return SvcWrap_QueryPhysicalAddress64From32(system, args); + case SvcId::QueryIoMapping: return SvcWrap_QueryIoMapping64From32(system, args); + case SvcId::CreateDeviceAddressSpace: return SvcWrap_CreateDeviceAddressSpace64From32(system, args); + case SvcId::AttachDeviceAddressSpace: return SvcWrap_AttachDeviceAddressSpace64From32(system, args); + case SvcId::DetachDeviceAddressSpace: return SvcWrap_DetachDeviceAddressSpace64From32(system, args); + case SvcId::MapDeviceAddressSpaceByForce: return SvcWrap_MapDeviceAddressSpaceByForce64From32(system, args); + case SvcId::MapDeviceAddressSpaceAligned: return SvcWrap_MapDeviceAddressSpaceAligned64From32(system, args); + case SvcId::UnmapDeviceAddressSpace: return SvcWrap_UnmapDeviceAddressSpace64From32(system, args); + case SvcId::InvalidateProcessDataCache: return SvcWrap_InvalidateProcessDataCache64From32(system, args); + case SvcId::StoreProcessDataCache: return SvcWrap_StoreProcessDataCache64From32(system, args); + case SvcId::FlushProcessDataCache: return SvcWrap_FlushProcessDataCache64From32(system, args); + case SvcId::DebugActiveProcess: return SvcWrap_DebugActiveProcess64From32(system, args); + case SvcId::BreakDebugProcess: return SvcWrap_BreakDebugProcess64From32(system, args); + case SvcId::TerminateDebugProcess: return SvcWrap_TerminateDebugProcess64From32(system, args); + case SvcId::GetDebugEvent: return SvcWrap_GetDebugEvent64From32(system, args); + case SvcId::ContinueDebugEvent: return SvcWrap_ContinueDebugEvent64From32(system, args); + case SvcId::GetProcessList: return SvcWrap_GetProcessList64From32(system, args); + case SvcId::GetThreadList: return SvcWrap_GetThreadList64From32(system, args); + case SvcId::GetDebugThreadContext: return SvcWrap_GetDebugThreadContext64From32(system, args); + case SvcId::SetDebugThreadContext: return SvcWrap_SetDebugThreadContext64From32(system, args); + case SvcId::QueryDebugProcessMemory: return SvcWrap_QueryDebugProcessMemory64From32(system, args); + case SvcId::ReadDebugProcessMemory: return SvcWrap_ReadDebugProcessMemory64From32(system, args); + case SvcId::WriteDebugProcessMemory: return SvcWrap_WriteDebugProcessMemory64From32(system, args); + case SvcId::SetHardwareBreakPoint: return SvcWrap_SetHardwareBreakPoint64From32(system, args); + case SvcId::GetDebugThreadParam: return SvcWrap_GetDebugThreadParam64From32(system, args); + case SvcId::GetSystemInfo: return SvcWrap_GetSystemInfo64From32(system, args); + case SvcId::CreatePort: return SvcWrap_CreatePort64From32(system, args); + case SvcId::ManageNamedPort: return SvcWrap_ManageNamedPort64From32(system, args); + case SvcId::ConnectToPort: return SvcWrap_ConnectToPort64From32(system, args); + case SvcId::SetProcessMemoryPermission: return SvcWrap_SetProcessMemoryPermission64From32(system, args); + case SvcId::MapProcessMemory: return SvcWrap_MapProcessMemory64From32(system, args); + case SvcId::UnmapProcessMemory: return SvcWrap_UnmapProcessMemory64From32(system, args); + case SvcId::QueryProcessMemory: return SvcWrap_QueryProcessMemory64From32(system, args); + case SvcId::MapProcessCodeMemory: return SvcWrap_MapProcessCodeMemory64From32(system, args); + case SvcId::UnmapProcessCodeMemory: return SvcWrap_UnmapProcessCodeMemory64From32(system, args); + case SvcId::CreateProcess: return SvcWrap_CreateProcess64From32(system, args); + case SvcId::StartProcess: return SvcWrap_StartProcess64From32(system, args); + case SvcId::TerminateProcess: return SvcWrap_TerminateProcess64From32(system, args); + case SvcId::GetProcessInfo: return SvcWrap_GetProcessInfo64From32(system, args); + case SvcId::CreateResourceLimit: return SvcWrap_CreateResourceLimit64From32(system, args); + case SvcId::SetResourceLimitLimitValue: return SvcWrap_SetResourceLimitLimitValue64From32(system, args); + case SvcId::CallSecureMonitor: return SvcWrap_CallSecureMonitor64From32(system, args); + case SvcId::MapInsecureMemory: return SvcWrap_MapInsecureMemory64From32(system, args); + case SvcId::UnmapInsecureMemory: return SvcWrap_UnmapInsecureMemory64From32(system, args); default: LOG_CRITICAL(Kernel_SVC, "Unknown SVC {:x}!", imm); break; @@ -4171,273 +2371,147 @@ static void Call32(Core::System& system, u32 imm, std::span args) { } static void Call64(Core::System& system, u32 imm, std::span args) { - switch (static_cast(imm)) { - case SvcId::SetHeapSize: - return SvcWrap_SetHeapSize64(system, args); - case SvcId::SetMemoryPermission: - return SvcWrap_SetMemoryPermission64(system, args); - case SvcId::SetMemoryAttribute: - return SvcWrap_SetMemoryAttribute64(system, args); - case SvcId::MapMemory: - return SvcWrap_MapMemory64(system, args); - case SvcId::UnmapMemory: - return SvcWrap_UnmapMemory64(system, args); - case SvcId::QueryMemory: - return SvcWrap_QueryMemory64(system, args); - case SvcId::ExitProcess: - return SvcWrap_ExitProcess64(system, args); - case SvcId::CreateThread: - return SvcWrap_CreateThread64(system, args); - case SvcId::StartThread: - return SvcWrap_StartThread64(system, args); - case SvcId::ExitThread: - return SvcWrap_ExitThread64(system, args); - case SvcId::SleepThread: - return SvcWrap_SleepThread64(system, args); - case SvcId::GetThreadPriority: - return SvcWrap_GetThreadPriority64(system, args); - case SvcId::SetThreadPriority: - return SvcWrap_SetThreadPriority64(system, args); - case SvcId::GetThreadCoreMask: - return SvcWrap_GetThreadCoreMask64(system, args); - case SvcId::SetThreadCoreMask: - return SvcWrap_SetThreadCoreMask64(system, args); - case SvcId::GetCurrentProcessorNumber: - return SvcWrap_GetCurrentProcessorNumber64(system, args); - case SvcId::SignalEvent: - return SvcWrap_SignalEvent64(system, args); - case SvcId::ClearEvent: - return SvcWrap_ClearEvent64(system, args); - case SvcId::MapSharedMemory: - return SvcWrap_MapSharedMemory64(system, args); - case SvcId::UnmapSharedMemory: - return SvcWrap_UnmapSharedMemory64(system, args); - case SvcId::CreateTransferMemory: - return SvcWrap_CreateTransferMemory64(system, args); - case SvcId::CloseHandle: - return SvcWrap_CloseHandle64(system, args); - case SvcId::ResetSignal: - return SvcWrap_ResetSignal64(system, args); - case SvcId::WaitSynchronization: - return SvcWrap_WaitSynchronization64(system, args); - case SvcId::CancelSynchronization: - return SvcWrap_CancelSynchronization64(system, args); - case SvcId::ArbitrateLock: - return SvcWrap_ArbitrateLock64(system, args); - case SvcId::ArbitrateUnlock: - return SvcWrap_ArbitrateUnlock64(system, args); - case SvcId::WaitProcessWideKeyAtomic: - return SvcWrap_WaitProcessWideKeyAtomic64(system, args); - case SvcId::SignalProcessWideKey: - return SvcWrap_SignalProcessWideKey64(system, args); - case SvcId::GetSystemTick: - return SvcWrap_GetSystemTick64(system, args); - case SvcId::ConnectToNamedPort: - return SvcWrap_ConnectToNamedPort64(system, args); - case SvcId::SendSyncRequestLight: - return SvcWrap_SendSyncRequestLight64(system, args); - case SvcId::SendSyncRequest: - return SvcWrap_SendSyncRequest64(system, args); - case SvcId::SendSyncRequestWithUserBuffer: - return SvcWrap_SendSyncRequestWithUserBuffer64(system, args); - case SvcId::SendAsyncRequestWithUserBuffer: - return SvcWrap_SendAsyncRequestWithUserBuffer64(system, args); - case SvcId::GetProcessId: - return SvcWrap_GetProcessId64(system, args); - case SvcId::GetThreadId: - return SvcWrap_GetThreadId64(system, args); - case SvcId::Break: - return SvcWrap_Break64(system, args); - case SvcId::OutputDebugString: - return SvcWrap_OutputDebugString64(system, args); - case SvcId::ReturnFromException: - return SvcWrap_ReturnFromException64(system, args); - case SvcId::GetInfo: - return SvcWrap_GetInfo64(system, args); - case SvcId::FlushEntireDataCache: - return SvcWrap_FlushEntireDataCache64(system, args); - case SvcId::FlushDataCache: - return SvcWrap_FlushDataCache64(system, args); - case SvcId::MapPhysicalMemory: - return SvcWrap_MapPhysicalMemory64(system, args); - case SvcId::UnmapPhysicalMemory: - return SvcWrap_UnmapPhysicalMemory64(system, args); - case SvcId::GetDebugFutureThreadInfo: - return SvcWrap_GetDebugFutureThreadInfo64(system, args); - case SvcId::GetLastThreadInfo: - return SvcWrap_GetLastThreadInfo64(system, args); - case SvcId::GetResourceLimitLimitValue: - return SvcWrap_GetResourceLimitLimitValue64(system, args); - case SvcId::GetResourceLimitCurrentValue: - return SvcWrap_GetResourceLimitCurrentValue64(system, args); - case SvcId::SetThreadActivity: - return SvcWrap_SetThreadActivity64(system, args); - case SvcId::GetThreadContext3: - return SvcWrap_GetThreadContext364(system, args); - case SvcId::WaitForAddress: - return SvcWrap_WaitForAddress64(system, args); - case SvcId::SignalToAddress: - return SvcWrap_SignalToAddress64(system, args); - case SvcId::SynchronizePreemptionState: - return SvcWrap_SynchronizePreemptionState64(system, args); - case SvcId::GetResourceLimitPeakValue: - return SvcWrap_GetResourceLimitPeakValue64(system, args); - case SvcId::CreateIoPool: - return SvcWrap_CreateIoPool64(system, args); - case SvcId::CreateIoRegion: - return SvcWrap_CreateIoRegion64(system, args); - case SvcId::KernelDebug: - return SvcWrap_KernelDebug64(system, args); - case SvcId::ChangeKernelTraceState: - return SvcWrap_ChangeKernelTraceState64(system, args); - case SvcId::CreateSession: - return SvcWrap_CreateSession64(system, args); - case SvcId::AcceptSession: - return SvcWrap_AcceptSession64(system, args); - case SvcId::ReplyAndReceiveLight: - return SvcWrap_ReplyAndReceiveLight64(system, args); - case SvcId::ReplyAndReceive: - return SvcWrap_ReplyAndReceive64(system, args); - case SvcId::ReplyAndReceiveWithUserBuffer: - return SvcWrap_ReplyAndReceiveWithUserBuffer64(system, args); - case SvcId::CreateEvent: - return SvcWrap_CreateEvent64(system, args); - case SvcId::MapIoRegion: - return SvcWrap_MapIoRegion64(system, args); - case SvcId::UnmapIoRegion: - return SvcWrap_UnmapIoRegion64(system, args); - case SvcId::MapPhysicalMemoryUnsafe: - return SvcWrap_MapPhysicalMemoryUnsafe64(system, args); - case SvcId::UnmapPhysicalMemoryUnsafe: - return SvcWrap_UnmapPhysicalMemoryUnsafe64(system, args); - case SvcId::SetUnsafeLimit: - return SvcWrap_SetUnsafeLimit64(system, args); - case SvcId::CreateCodeMemory: - return SvcWrap_CreateCodeMemory64(system, args); - case SvcId::ControlCodeMemory: - return SvcWrap_ControlCodeMemory64(system, args); - case SvcId::SleepSystem: - return SvcWrap_SleepSystem64(system, args); - case SvcId::ReadWriteRegister: - return SvcWrap_ReadWriteRegister64(system, args); - case SvcId::SetProcessActivity: - return SvcWrap_SetProcessActivity64(system, args); - case SvcId::CreateSharedMemory: - return SvcWrap_CreateSharedMemory64(system, args); - case SvcId::MapTransferMemory: - return SvcWrap_MapTransferMemory64(system, args); - case SvcId::UnmapTransferMemory: - return SvcWrap_UnmapTransferMemory64(system, args); - case SvcId::CreateInterruptEvent: - return SvcWrap_CreateInterruptEvent64(system, args); - case SvcId::QueryPhysicalAddress: - return SvcWrap_QueryPhysicalAddress64(system, args); - case SvcId::QueryIoMapping: - return SvcWrap_QueryIoMapping64(system, args); - case SvcId::CreateDeviceAddressSpace: - return SvcWrap_CreateDeviceAddressSpace64(system, args); - case SvcId::AttachDeviceAddressSpace: - return SvcWrap_AttachDeviceAddressSpace64(system, args); - case SvcId::DetachDeviceAddressSpace: - return SvcWrap_DetachDeviceAddressSpace64(system, args); - case SvcId::MapDeviceAddressSpaceByForce: - return SvcWrap_MapDeviceAddressSpaceByForce64(system, args); - case SvcId::MapDeviceAddressSpaceAligned: - return SvcWrap_MapDeviceAddressSpaceAligned64(system, args); - case SvcId::UnmapDeviceAddressSpace: - return SvcWrap_UnmapDeviceAddressSpace64(system, args); - case SvcId::InvalidateProcessDataCache: - return SvcWrap_InvalidateProcessDataCache64(system, args); - case SvcId::StoreProcessDataCache: - return SvcWrap_StoreProcessDataCache64(system, args); - case SvcId::FlushProcessDataCache: - return SvcWrap_FlushProcessDataCache64(system, args); - case SvcId::DebugActiveProcess: - return SvcWrap_DebugActiveProcess64(system, args); - case SvcId::BreakDebugProcess: - return SvcWrap_BreakDebugProcess64(system, args); - case SvcId::TerminateDebugProcess: - return SvcWrap_TerminateDebugProcess64(system, args); - case SvcId::GetDebugEvent: - return SvcWrap_GetDebugEvent64(system, args); - case SvcId::ContinueDebugEvent: - return SvcWrap_ContinueDebugEvent64(system, args); - case SvcId::GetProcessList: - return SvcWrap_GetProcessList64(system, args); - case SvcId::GetThreadList: - return SvcWrap_GetThreadList64(system, args); - case SvcId::GetDebugThreadContext: - return SvcWrap_GetDebugThreadContext64(system, args); - case SvcId::SetDebugThreadContext: - return SvcWrap_SetDebugThreadContext64(system, args); - case SvcId::QueryDebugProcessMemory: - return SvcWrap_QueryDebugProcessMemory64(system, args); - case SvcId::ReadDebugProcessMemory: - return SvcWrap_ReadDebugProcessMemory64(system, args); - case SvcId::WriteDebugProcessMemory: - return SvcWrap_WriteDebugProcessMemory64(system, args); - case SvcId::SetHardwareBreakPoint: - return SvcWrap_SetHardwareBreakPoint64(system, args); - case SvcId::GetDebugThreadParam: - return SvcWrap_GetDebugThreadParam64(system, args); - case SvcId::GetSystemInfo: - return SvcWrap_GetSystemInfo64(system, args); - case SvcId::CreatePort: - return SvcWrap_CreatePort64(system, args); - case SvcId::ManageNamedPort: - return SvcWrap_ManageNamedPort64(system, args); - case SvcId::ConnectToPort: - return SvcWrap_ConnectToPort64(system, args); - case SvcId::SetProcessMemoryPermission: - return SvcWrap_SetProcessMemoryPermission64(system, args); - case SvcId::MapProcessMemory: - return SvcWrap_MapProcessMemory64(system, args); - case SvcId::UnmapProcessMemory: - return SvcWrap_UnmapProcessMemory64(system, args); - case SvcId::QueryProcessMemory: - return SvcWrap_QueryProcessMemory64(system, args); - case SvcId::MapProcessCodeMemory: - return SvcWrap_MapProcessCodeMemory64(system, args); - case SvcId::UnmapProcessCodeMemory: - return SvcWrap_UnmapProcessCodeMemory64(system, args); - case SvcId::CreateProcess: - return SvcWrap_CreateProcess64(system, args); - case SvcId::StartProcess: - return SvcWrap_StartProcess64(system, args); - case SvcId::TerminateProcess: - return SvcWrap_TerminateProcess64(system, args); - case SvcId::GetProcessInfo: - return SvcWrap_GetProcessInfo64(system, args); - case SvcId::CreateResourceLimit: - return SvcWrap_CreateResourceLimit64(system, args); - case SvcId::SetResourceLimitLimitValue: - return SvcWrap_SetResourceLimitLimitValue64(system, args); - case SvcId::CallSecureMonitor: - return SvcWrap_CallSecureMonitor64(system, args); - case SvcId::MapInsecureMemory: - return SvcWrap_MapInsecureMemory64(system, args); - case SvcId::UnmapInsecureMemory: - return SvcWrap_UnmapInsecureMemory64(system, args); + switch (SvcId(imm)) { + case SvcId::SetHeapSize: return SvcWrap_SetHeapSize64(system, args); + case SvcId::SetMemoryPermission: return SvcWrap_SetMemoryPermission64(system, args); + case SvcId::SetMemoryAttribute: return SvcWrap_SetMemoryAttribute64(system, args); + case SvcId::MapMemory: return SvcWrap_MapMemory64(system, args); + case SvcId::UnmapMemory: return SvcWrap_UnmapMemory64(system, args); + case SvcId::QueryMemory: return SvcWrap_QueryMemory64(system, args); + case SvcId::ExitProcess: return SvcWrap_ExitProcess64(system, args); + case SvcId::CreateThread: return SvcWrap_CreateThread64(system, args); + case SvcId::StartThread: return SvcWrap_StartThread64(system, args); + case SvcId::ExitThread: return SvcWrap_ExitThread64(system, args); + case SvcId::SleepThread: return SvcWrap_SleepThread64(system, args); + case SvcId::GetThreadPriority: return SvcWrap_GetThreadPriority64(system, args); + case SvcId::SetThreadPriority: return SvcWrap_SetThreadPriority64(system, args); + case SvcId::GetThreadCoreMask: return SvcWrap_GetThreadCoreMask64(system, args); + case SvcId::SetThreadCoreMask: return SvcWrap_SetThreadCoreMask64(system, args); + case SvcId::GetCurrentProcessorNumber: return SvcWrap_GetCurrentProcessorNumber64(system, args); + case SvcId::SignalEvent: return SvcWrap_SignalEvent64(system, args); + case SvcId::ClearEvent: return SvcWrap_ClearEvent64(system, args); + case SvcId::MapSharedMemory: return SvcWrap_MapSharedMemory64(system, args); + case SvcId::UnmapSharedMemory: return SvcWrap_UnmapSharedMemory64(system, args); + case SvcId::CreateTransferMemory: return SvcWrap_CreateTransferMemory64(system, args); + case SvcId::CloseHandle: return SvcWrap_CloseHandle64(system, args); + case SvcId::ResetSignal: return SvcWrap_ResetSignal64(system, args); + case SvcId::WaitSynchronization: return SvcWrap_WaitSynchronization64(system, args); + case SvcId::CancelSynchronization: return SvcWrap_CancelSynchronization64(system, args); + case SvcId::ArbitrateLock: return SvcWrap_ArbitrateLock64(system, args); + case SvcId::ArbitrateUnlock: return SvcWrap_ArbitrateUnlock64(system, args); + case SvcId::WaitProcessWideKeyAtomic: return SvcWrap_WaitProcessWideKeyAtomic64(system, args); + case SvcId::SignalProcessWideKey: return SvcWrap_SignalProcessWideKey64(system, args); + case SvcId::GetSystemTick: return SvcWrap_GetSystemTick64(system, args); + case SvcId::ConnectToNamedPort: return SvcWrap_ConnectToNamedPort64(system, args); + case SvcId::SendSyncRequestLight: return SvcWrap_SendSyncRequestLight64(system, args); + case SvcId::SendSyncRequest: return SvcWrap_SendSyncRequest64(system, args); + case SvcId::SendSyncRequestWithUserBuffer: return SvcWrap_SendSyncRequestWithUserBuffer64(system, args); + case SvcId::SendAsyncRequestWithUserBuffer: return SvcWrap_SendAsyncRequestWithUserBuffer64(system, args); + case SvcId::GetProcessId: return SvcWrap_GetProcessId64(system, args); + case SvcId::GetThreadId: return SvcWrap_GetThreadId64(system, args); + case SvcId::Break: return SvcWrap_Break64(system, args); + case SvcId::OutputDebugString: return SvcWrap_OutputDebugString64(system, args); + case SvcId::ReturnFromException: return SvcWrap_ReturnFromException64(system, args); + case SvcId::GetInfo: return SvcWrap_GetInfo64(system, args); + case SvcId::FlushEntireDataCache: return SvcWrap_FlushEntireDataCache64(system, args); + case SvcId::FlushDataCache: return SvcWrap_FlushDataCache64(system, args); + case SvcId::MapPhysicalMemory: return SvcWrap_MapPhysicalMemory64(system, args); + case SvcId::UnmapPhysicalMemory: return SvcWrap_UnmapPhysicalMemory64(system, args); + case SvcId::GetDebugFutureThreadInfo: return SvcWrap_GetDebugFutureThreadInfo64(system, args); + case SvcId::GetLastThreadInfo: return SvcWrap_GetLastThreadInfo64(system, args); + case SvcId::GetResourceLimitLimitValue: return SvcWrap_GetResourceLimitLimitValue64(system, args); + case SvcId::GetResourceLimitCurrentValue: return SvcWrap_GetResourceLimitCurrentValue64(system, args); + case SvcId::SetThreadActivity: return SvcWrap_SetThreadActivity64(system, args); + case SvcId::GetThreadContext3: return SvcWrap_GetThreadContext364(system, args); + case SvcId::WaitForAddress: return SvcWrap_WaitForAddress64(system, args); + case SvcId::SignalToAddress: return SvcWrap_SignalToAddress64(system, args); + case SvcId::SynchronizePreemptionState: return SvcWrap_SynchronizePreemptionState64(system, args); + case SvcId::GetResourceLimitPeakValue: return SvcWrap_GetResourceLimitPeakValue64(system, args); + case SvcId::CreateIoPool: return SvcWrap_CreateIoPool64(system, args); + case SvcId::CreateIoRegion: return SvcWrap_CreateIoRegion64(system, args); + case SvcId::KernelDebug: return SvcWrap_KernelDebug64(system, args); + case SvcId::ChangeKernelTraceState: return SvcWrap_ChangeKernelTraceState64(system, args); + case SvcId::CreateSession: return SvcWrap_CreateSession64(system, args); + case SvcId::AcceptSession: return SvcWrap_AcceptSession64(system, args); + case SvcId::ReplyAndReceiveLight: return SvcWrap_ReplyAndReceiveLight64(system, args); + case SvcId::ReplyAndReceive: return SvcWrap_ReplyAndReceive64(system, args); + case SvcId::ReplyAndReceiveWithUserBuffer: return SvcWrap_ReplyAndReceiveWithUserBuffer64(system, args); + case SvcId::CreateEvent: return SvcWrap_CreateEvent64(system, args); + case SvcId::MapIoRegion: return SvcWrap_MapIoRegion64(system, args); + case SvcId::UnmapIoRegion: return SvcWrap_UnmapIoRegion64(system, args); + case SvcId::MapPhysicalMemoryUnsafe: return SvcWrap_MapPhysicalMemoryUnsafe64(system, args); + case SvcId::UnmapPhysicalMemoryUnsafe: return SvcWrap_UnmapPhysicalMemoryUnsafe64(system, args); + case SvcId::SetUnsafeLimit: return SvcWrap_SetUnsafeLimit64(system, args); + case SvcId::CreateCodeMemory: return SvcWrap_CreateCodeMemory64(system, args); + case SvcId::ControlCodeMemory: return SvcWrap_ControlCodeMemory64(system, args); + case SvcId::SleepSystem: return SvcWrap_SleepSystem64(system, args); + case SvcId::ReadWriteRegister: return SvcWrap_ReadWriteRegister64(system, args); + case SvcId::SetProcessActivity: return SvcWrap_SetProcessActivity64(system, args); + case SvcId::CreateSharedMemory: return SvcWrap_CreateSharedMemory64(system, args); + case SvcId::MapTransferMemory: return SvcWrap_MapTransferMemory64(system, args); + case SvcId::UnmapTransferMemory: return SvcWrap_UnmapTransferMemory64(system, args); + case SvcId::CreateInterruptEvent: return SvcWrap_CreateInterruptEvent64(system, args); + case SvcId::QueryPhysicalAddress: return SvcWrap_QueryPhysicalAddress64(system, args); + case SvcId::QueryIoMapping: return SvcWrap_QueryIoMapping64(system, args); + case SvcId::CreateDeviceAddressSpace: return SvcWrap_CreateDeviceAddressSpace64(system, args); + case SvcId::AttachDeviceAddressSpace: return SvcWrap_AttachDeviceAddressSpace64(system, args); + case SvcId::DetachDeviceAddressSpace: return SvcWrap_DetachDeviceAddressSpace64(system, args); + case SvcId::MapDeviceAddressSpaceByForce: return SvcWrap_MapDeviceAddressSpaceByForce64(system, args); + case SvcId::MapDeviceAddressSpaceAligned: return SvcWrap_MapDeviceAddressSpaceAligned64(system, args); + case SvcId::UnmapDeviceAddressSpace: return SvcWrap_UnmapDeviceAddressSpace64(system, args); + case SvcId::InvalidateProcessDataCache: return SvcWrap_InvalidateProcessDataCache64(system, args); + case SvcId::StoreProcessDataCache: return SvcWrap_StoreProcessDataCache64(system, args); + case SvcId::FlushProcessDataCache: return SvcWrap_FlushProcessDataCache64(system, args); + case SvcId::DebugActiveProcess: return SvcWrap_DebugActiveProcess64(system, args); + case SvcId::BreakDebugProcess: return SvcWrap_BreakDebugProcess64(system, args); + case SvcId::TerminateDebugProcess: return SvcWrap_TerminateDebugProcess64(system, args); + case SvcId::GetDebugEvent: return SvcWrap_GetDebugEvent64(system, args); + case SvcId::ContinueDebugEvent: return SvcWrap_ContinueDebugEvent64(system, args); + case SvcId::GetProcessList: return SvcWrap_GetProcessList64(system, args); + case SvcId::GetThreadList: return SvcWrap_GetThreadList64(system, args); + case SvcId::GetDebugThreadContext: return SvcWrap_GetDebugThreadContext64(system, args); + case SvcId::SetDebugThreadContext: return SvcWrap_SetDebugThreadContext64(system, args); + case SvcId::QueryDebugProcessMemory: return SvcWrap_QueryDebugProcessMemory64(system, args); + case SvcId::ReadDebugProcessMemory: return SvcWrap_ReadDebugProcessMemory64(system, args); + case SvcId::WriteDebugProcessMemory: return SvcWrap_WriteDebugProcessMemory64(system, args); + case SvcId::SetHardwareBreakPoint: return SvcWrap_SetHardwareBreakPoint64(system, args); + case SvcId::GetDebugThreadParam: return SvcWrap_GetDebugThreadParam64(system, args); + case SvcId::GetSystemInfo: return SvcWrap_GetSystemInfo64(system, args); + case SvcId::CreatePort: return SvcWrap_CreatePort64(system, args); + case SvcId::ManageNamedPort: return SvcWrap_ManageNamedPort64(system, args); + case SvcId::ConnectToPort: return SvcWrap_ConnectToPort64(system, args); + case SvcId::SetProcessMemoryPermission: return SvcWrap_SetProcessMemoryPermission64(system, args); + case SvcId::MapProcessMemory: return SvcWrap_MapProcessMemory64(system, args); + case SvcId::UnmapProcessMemory: return SvcWrap_UnmapProcessMemory64(system, args); + case SvcId::QueryProcessMemory: return SvcWrap_QueryProcessMemory64(system, args); + case SvcId::MapProcessCodeMemory: return SvcWrap_MapProcessCodeMemory64(system, args); + case SvcId::UnmapProcessCodeMemory: return SvcWrap_UnmapProcessCodeMemory64(system, args); + case SvcId::CreateProcess: return SvcWrap_CreateProcess64(system, args); + case SvcId::StartProcess: return SvcWrap_StartProcess64(system, args); + case SvcId::TerminateProcess: return SvcWrap_TerminateProcess64(system, args); + case SvcId::GetProcessInfo: return SvcWrap_GetProcessInfo64(system, args); + case SvcId::CreateResourceLimit: return SvcWrap_CreateResourceLimit64(system, args); + case SvcId::SetResourceLimitLimitValue: return SvcWrap_SetResourceLimitLimitValue64(system, args); + case SvcId::CallSecureMonitor: return SvcWrap_CallSecureMonitor64(system, args); + case SvcId::MapInsecureMemory: return SvcWrap_MapInsecureMemory64(system, args); + case SvcId::UnmapInsecureMemory: return SvcWrap_UnmapInsecureMemory64(system, args); default: LOG_CRITICAL(Kernel_SVC, "Unknown SVC {:x}!", imm); break; } } -// clang-format on - void Call(Core::System& system, u32 imm) { auto& kernel = system.Kernel(); auto& process = GetCurrentProcess(kernel); std::array args; kernel.CurrentPhysicalCore().SaveSvcArguments(process, args); - - if (process.Is64Bit()) { + //kernel.EnterSVCProfile(); + if (process.Is64Bit()) Call64(system, imm, args); - } else { + else Call32(system, imm, args); - } - + //kernel.ExitSVCProfile(); kernel.CurrentPhysicalCore().LoadSvcArguments(process, args); } diff --git a/src/core/hle/kernel/svc.h b/src/core/hle/kernel/svc.h index 828f396113..356c1c109a 100644 --- a/src/core/hle/kernel/svc.h +++ b/src/core/hle/kernel/svc.h @@ -1,7 +1,10 @@ +// SPDX-FileCopyrightText: Copyright 2025 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 +// SPDX-License-Identifier: GPL-2.0-or-late // This file is automatically generated using svc_generator.py. +// DO NOT MODIFY IT MANUALLY #pragma once @@ -16,8 +19,6 @@ class System; #include "core/hle/result.h" namespace Kernel::Svc { - -// clang-format off Result SetHeapSize(Core::System& system, uint64_t* out_address, uint64_t size); Result SetMemoryPermission(Core::System& system, uint64_t address, uint64_t size, MemoryPermission perm); Result SetMemoryAttribute(Core::System& system, uint64_t address, uint64_t size, uint32_t mask, uint32_t attr); @@ -506,8 +507,6 @@ enum class SvcId : u32 { MapInsecureMemory = 0x90, UnmapInsecureMemory = 0x91, }; -// clang-format on - // Custom ABI. Result ReplyAndReceiveLight(Core::System& system, Handle handle, uint32_t* args); Result ReplyAndReceiveLight64From32(Core::System& system, Handle handle, uint32_t* args); diff --git a/tools/README.md b/tools/README.md index 061e95bc9c..bd3c042fc6 100644 --- a/tools/README.md +++ b/tools/README.md @@ -8,7 +8,8 @@ Tools for Eden and other subprojects. ## Eden -- `find-unused-strings.pl`: Find unused strings (for Android XML files). +- `generate_converters.py`: Generates converters for given formats of textures (C++ helper). +- `svc_generator.py`: Generates the files `src/core/hle/kernel/svc.cpp` and `src/core/hle/kernel/svc.h` based off prototypes. - `shellcheck.sh`: Ensure POSIX compliance (and syntax sanity) for all tools in this directory and subdirectories. - `llvmpipe-run.sh`: Sets environment variables needed to run any command (or Eden) with llvmpipe. - `optimize-assets.sh`: Optimize PNG assets with OptiPng. diff --git a/src/video_core/engines/sw_blitter/generate_converters.py b/tools/generate_converters.py similarity index 100% rename from src/video_core/engines/sw_blitter/generate_converters.py rename to tools/generate_converters.py diff --git a/src/core/hle/kernel/svc_generator.py b/tools/svc_generator.py old mode 100644 new mode 100755 similarity index 95% rename from src/core/hle/kernel/svc_generator.py rename to tools/svc_generator.py index 786189ab79..ac6136fdcd --- a/src/core/hle/kernel/svc_generator.py +++ b/tools/svc_generator.py @@ -1,3 +1,6 @@ +#!/usr/bin/python3 +# SPDX-FileCopyrightText: Copyright 2025 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 @@ -378,7 +381,7 @@ def emit_gather(sources, name, type_name, reg_size): if len(sources) == 1: s, = sources - line = f"{name} = Convert<{type_name}>({get_fn}(args, {s}));" + line = f"{type_name} {name} = Convert<{type_name}>({get_fn}(args, {s}));" return [line] var_type = f"std::array" @@ -386,10 +389,9 @@ def emit_gather(sources, name, type_name, reg_size): f"{var_type} {name}_gather{{}};" ] for i in range(0, len(sources)): - lines.append( - f"{name}_gather[{i}] = {get_fn}(args, {sources[i]});") + lines.append(f"{name}_gather[{i}] = {get_fn}(args, {sources[i]});") - lines.append(f"{name} = Convert<{type_name}>({name}_gather);") + lines.append(f"{type_name} {name} = Convert<{type_name}>({name}_gather);") return lines @@ -405,14 +407,9 @@ def emit_scatter(destinations, name, reg_size): return [line] var_type = f"std::array<{reg_type}, {len(destinations)}>" - lines = [ - f"auto {name}_scatter = Convert<{var_type}>({name});" - ] - + lines = [f"auto {name}_scatter = Convert<{var_type}>({name});"] for i in range(0, len(destinations)): - lines.append( - f"{set_fn}(args, {destinations[i]}, {name}_scatter[{i}]);") - + lines.append(f"{set_fn}(args, {destinations[i]}, {name}_scatter[{i}]);") return lines @@ -436,25 +433,8 @@ def emit_wrapper(wrapped_fn, suffix, register_info, arguments, byte_size): f"static void SvcWrap_{wrapped_fn}{suffix}(Core::System& system, std::span args) {{" ] - # Get everything ready. - for return_type, _ in return_write: - lines.append(f"{return_type} ret{{}};") - if return_write: - lines.append("") - - for output_type, var_name, _, is_address in output_writes: - output_type = "uint64_t" if is_address else output_type - lines.append(f"{output_type} {var_name}{{}};") - for input_type, var_name, _ in input_reads: - lines.append(f"{input_type} {var_name}{{}};") - - if output_writes or input_reads: - lines.append("") - for input_type, var_name, sources in input_reads: lines += emit_gather(sources, var_name, input_type, byte_size) - if input_reads: - lines.append("") # Build the call. call_arguments = ["system"] @@ -464,16 +444,18 @@ def emit_wrapper(wrapped_fn, suffix, register_info, arguments, byte_size): else: call_arguments.append(arg.var_name) + # Get everything ready. + for output_type, var_name, _, is_address in output_writes: + output_type = "uint64_t" if is_address else output_type + lines.append(f"{output_type} {var_name}{{}};") + line = "" - if return_write: - line += "ret = " + for return_type, _ in return_write: + line += f"{return_type} ret = " line += f"{wrapped_fn}{suffix}({', '.join(call_arguments)});" lines.append(line) - if return_write or output_writes: - lines.append("") - # Write back the return value and outputs. for _, destinations in return_write: lines += emit_scatter(destinations, "ret", byte_size) @@ -485,10 +467,13 @@ def emit_wrapper(wrapped_fn, suffix, register_info, arguments, byte_size): COPYRIGHT = """\ +// SPDX-FileCopyrightText: Copyright 2025 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 +// SPDX-License-Identifier: GPL-2.0-or-late // This file is automatically generated using svc_generator.py. +// DO NOT MODIFY IT MANUALLY """ PROLOGUE_H = """ @@ -505,13 +490,9 @@ class System; #include "core/hle/result.h" namespace Kernel::Svc { - -// clang-format off """ EPILOGUE_H = """ -// clang-format on - // Custom ABI. Result ReplyAndReceiveLight(Core::System& system, Handle handle, uint32_t* args); Result ReplyAndReceiveLight64From32(Core::System& system, Handle handle, uint32_t* args); @@ -553,7 +534,7 @@ PROLOGUE_CPP = """ namespace Kernel::Svc { static uint32_t GetArg32(std::span args, int n) { - return static_cast(args[n]); + return uint32_t(args[n]); } static void SetArg32(std::span args, int n, uint32_t result) { @@ -574,37 +555,27 @@ template requires(std::is_trivial_v && std::is_trivially_copyable_v) static To Convert(const From& from) { To to{}; - - if constexpr (sizeof(To) >= sizeof(From)) { + if constexpr (sizeof(To) >= sizeof(From)) std::memcpy(std::addressof(to), std::addressof(from), sizeof(From)); - } else { + else std::memcpy(std::addressof(to), std::addressof(from), sizeof(To)); - } - return to; } - -// clang-format off """ EPILOGUE_CPP = """ -// clang-format on - void Call(Core::System& system, u32 imm) { auto& kernel = system.Kernel(); auto& process = GetCurrentProcess(kernel); std::array args; kernel.CurrentPhysicalCore().SaveSvcArguments(process, args); - kernel.EnterSVCProfile(); - - if (process.Is64Bit()) { + //kernel.EnterSVCProfile(); + if (process.Is64Bit()) Call64(system, imm, args); - } else { + else Call32(system, imm, args); - } - - kernel.ExitSVCProfile(); + //kernel.ExitSVCProfile(); kernel.CurrentPhysicalCore().LoadSvcArguments(process, args); } @@ -617,12 +588,11 @@ def emit_call(bitness, names, suffix): indent = " " lines = [ f"static void Call{bit_size}(Core::System& system, u32 imm, std::span args) {{", - f"{indent}switch (static_cast(imm)) {{" + f"{indent}switch (SvcId(imm)) {{" ] for _, name in names: - lines.append(f"{indent}case SvcId::{name}:") - lines.append(f"{indent*2}return SvcWrap_{name}{suffix}(system, args);") + lines.append(f"{indent}case SvcId::{name}: return SvcWrap_{name}{suffix}(system, args);") lines.append(f"{indent}default:") lines.append( @@ -692,7 +662,7 @@ def main(): call_64 = emit_call(BIT_64, names, SUFFIX_NAMES[BIT_64]) enum_decls = build_enum_declarations() - with open("svc.h", "w") as f: + with open("src/core/hle/kernel/svc.h", "w") as f: f.write(COPYRIGHT) f.write(PROLOGUE_H) f.write("\n".join(svc_fw_declarations)) @@ -704,7 +674,7 @@ def main(): f.write(enum_decls) f.write(EPILOGUE_H) - with open("svc.cpp", "w") as f: + with open("src/core/hle/kernel/svc.cpp", "w") as f: f.write(COPYRIGHT) f.write(PROLOGUE_CPP) f.write(emit_size_check())