diff options
Diffstat (limited to 'src/core/hle/kernel')
| -rw-r--r-- | src/core/hle/kernel/k_page_table_base.cpp | 18 | ||||
| -rw-r--r-- | src/core/hle/kernel/k_process.cpp | 40 | ||||
| -rw-r--r-- | src/core/hle/kernel/k_process.h | 9 | ||||
| -rw-r--r-- | src/core/hle/kernel/k_process_page_table.h | 4 | ||||
| -rw-r--r-- | src/core/hle/kernel/k_scheduler.cpp | 16 | ||||
| -rw-r--r-- | src/core/hle/kernel/k_thread.cpp | 80 | ||||
| -rw-r--r-- | src/core/hle/kernel/k_thread.h | 29 | ||||
| -rw-r--r-- | src/core/hle/kernel/kernel.cpp | 28 | ||||
| -rw-r--r-- | src/core/hle/kernel/kernel.h | 7 | ||||
| -rw-r--r-- | src/core/hle/kernel/physical_core.cpp | 251 | ||||
| -rw-r--r-- | src/core/hle/kernel/physical_core.h | 57 | ||||
| -rw-r--r-- | src/core/hle/kernel/svc.cpp | 2955 | ||||
| -rw-r--r-- | src/core/hle/kernel/svc.h | 14 | ||||
| -rw-r--r-- | src/core/hle/kernel/svc/svc_exception.cpp | 4 | ||||
| -rw-r--r-- | src/core/hle/kernel/svc/svc_light_ipc.cpp | 31 | ||||
| -rw-r--r-- | src/core/hle/kernel/svc/svc_secure_monitor_call.cpp | 22 | ||||
| -rw-r--r-- | src/core/hle/kernel/svc/svc_thread.cpp | 50 | ||||
| -rw-r--r-- | src/core/hle/kernel/svc_generator.py | 59 |
18 files changed, 1890 insertions, 1784 deletions
diff --git a/src/core/hle/kernel/k_page_table_base.cpp b/src/core/hle/kernel/k_page_table_base.cpp index 6691586ed..4c416d809 100644 --- a/src/core/hle/kernel/k_page_table_base.cpp +++ b/src/core/hle/kernel/k_page_table_base.cpp @@ -69,8 +69,16 @@ public: }; template <typename AddressType> -void InvalidateInstructionCache(Core::System& system, AddressType addr, u64 size) { - system.InvalidateCpuInstructionCacheRange(GetInteger(addr), size); +void InvalidateInstructionCache(KernelCore& kernel, AddressType addr, u64 size) { + // TODO: lock the process list + for (auto& process : kernel.GetProcessList()) { + for (size_t i = 0; i < Core::Hardware::NUM_CPU_CORES; i++) { + auto* interface = process->GetArmInterface(i); + if (interface) { + interface->InvalidateCacheRange(GetInteger(addr), size); + } + } + } } template <typename AddressType> @@ -1261,7 +1269,7 @@ Result KPageTableBase::UnmapCodeMemory(KProcessAddress dst_address, KProcessAddr bool reprotected_pages = false; SCOPE_EXIT({ if (reprotected_pages && any_code_pages) { - InvalidateInstructionCache(m_system, dst_address, size); + InvalidateInstructionCache(m_kernel, dst_address, size); } }); @@ -1997,7 +2005,7 @@ Result KPageTableBase::SetProcessMemoryPermission(KProcessAddress addr, size_t s for (const auto& block : pg) { StoreDataCache(GetHeapVirtualPointer(m_kernel, block.GetAddress()), block.GetSize()); } - InvalidateInstructionCache(m_system, addr, size); + InvalidateInstructionCache(m_kernel, addr, size); } R_SUCCEED(); @@ -3239,7 +3247,7 @@ Result KPageTableBase::WriteDebugMemory(KProcessAddress dst_address, KProcessAdd R_TRY(PerformCopy()); // Invalidate the instruction cache, as this svc allows modifying executable pages. - InvalidateInstructionCache(m_system, dst_address, size); + InvalidateInstructionCache(m_kernel, dst_address, size); R_SUCCEED(); } diff --git a/src/core/hle/kernel/k_process.cpp b/src/core/hle/kernel/k_process.cpp index 6c29eb72c..3a2635e1f 100644 --- a/src/core/hle/kernel/k_process.cpp +++ b/src/core/hle/kernel/k_process.cpp @@ -13,6 +13,12 @@ #include "core/hle/kernel/k_thread_queue.h" #include "core/hle/kernel/k_worker_task_manager.h" +#include "core/arm/dynarmic/arm_dynarmic_32.h" +#include "core/arm/dynarmic/arm_dynarmic_64.h" +#ifdef HAS_NCE +#include "core/arm/nce/arm_nce.h" +#endif + namespace Kernel { namespace { @@ -957,10 +963,8 @@ Result KProcess::Run(s32 priority, size_t stack_size) { R_TRY(m_handle_table.Add(std::addressof(thread_handle), main_thread)); // Set the thread arguments. - main_thread->GetContext32().cpu_registers[0] = 0; - main_thread->GetContext64().cpu_registers[0] = 0; - main_thread->GetContext32().cpu_registers[1] = thread_handle; - main_thread->GetContext64().cpu_registers[1] = thread_handle; + main_thread->GetContext().r[0] = 0; + main_thread->GetContext().r[1] = thread_handle; // Update our state. this->ChangeState((state == State::Created) ? State::Running : State::RunningAttached); @@ -1199,6 +1203,9 @@ Result KProcess::LoadFromMetadata(const FileSys::ProgramMetadata& metadata, std: m_is_hbl = is_hbl; m_ideal_core_id = metadata.GetMainThreadCore(); + // Set up emulation context. + this->InitializeInterfaces(); + // We succeeded. R_SUCCEED(); } @@ -1227,6 +1234,31 @@ void KProcess::LoadModule(CodeSet code_set, KProcessAddress base_addr) { #endif } +void KProcess::InitializeInterfaces() { + this->GetMemory().SetCurrentPageTable(*this); + +#ifdef HAS_NCE + if (this->Is64Bit() && Settings::IsNceEnabled()) { + for (size_t i = 0; i < Core::Hardware::NUM_CPU_CORES; i++) { + m_arm_interfaces[i] = std::make_unique<Core::ArmNce>(m_kernel.System(), true, i); + } + } else +#endif + if (this->Is64Bit()) { + for (size_t i = 0; i < Core::Hardware::NUM_CPU_CORES; i++) { + m_arm_interfaces[i] = std::make_unique<Core::ArmDynarmic64>( + m_kernel.System(), m_kernel.IsMulticore(), this, + static_cast<Core::DynarmicExclusiveMonitor&>(m_kernel.GetExclusiveMonitor()), i); + } + } else { + for (size_t i = 0; i < Core::Hardware::NUM_CPU_CORES; i++) { + m_arm_interfaces[i] = std::make_unique<Core::ArmDynarmic32>( + m_kernel.System(), m_kernel.IsMulticore(), this, + static_cast<Core::DynarmicExclusiveMonitor&>(m_kernel.GetExclusiveMonitor()), i); + } + } +} + bool KProcess::InsertWatchpoint(KProcessAddress addr, u64 size, DebugWatchpointType type) { const auto watch{std::find_if(m_watchpoints.begin(), m_watchpoints.end(), [&](const auto& wp) { return wp.type == DebugWatchpointType::None; diff --git a/src/core/hle/kernel/k_process.h b/src/core/hle/kernel/k_process.h index d8cd0fdde..4b114e39b 100644 --- a/src/core/hle/kernel/k_process.h +++ b/src/core/hle/kernel/k_process.h @@ -5,6 +5,7 @@ #include <map> +#include "core/arm/arm_interface.h" #include "core/file_sys/program_metadata.h" #include "core/hle/kernel/code_set.h" #include "core/hle/kernel/k_address_arbiter.h" @@ -106,6 +107,8 @@ private: bool m_is_suspended{}; bool m_is_immortal{}; bool m_is_handle_table_initialized{}; + std::array<std::unique_ptr<Core::ArmInterface>, Core::Hardware::NUM_CPU_CORES> + m_arm_interfaces{}; std::array<KThread*, Core::Hardware::NUM_CPU_CORES> m_running_threads{}; std::array<u64, Core::Hardware::NUM_CPU_CORES> m_running_thread_idle_counts{}; std::array<u64, Core::Hardware::NUM_CPU_CORES> m_running_thread_switch_counts{}; @@ -476,6 +479,10 @@ public: } #endif + Core::ArmInterface* GetArmInterface(size_t core_index) const { + return m_arm_interfaces[core_index].get(); + } + public: // Attempts to insert a watchpoint into a free slot. Returns false if none are available. bool InsertWatchpoint(KProcessAddress addr, u64 size, DebugWatchpointType type); @@ -493,6 +500,8 @@ public: void LoadModule(CodeSet code_set, KProcessAddress base_addr); + void InitializeInterfaces(); + Core::Memory::Memory& GetMemory() const; public: diff --git a/src/core/hle/kernel/k_process_page_table.h b/src/core/hle/kernel/k_process_page_table.h index 9e40f68bc..346d7ca08 100644 --- a/src/core/hle/kernel/k_process_page_table.h +++ b/src/core/hle/kernel/k_process_page_table.h @@ -7,10 +7,6 @@ #include "core/hle/kernel/k_scoped_lock.h" #include "core/hle/kernel/svc_types.h" -namespace Core { -class ARM_Interface; -} - namespace Kernel { class KProcessPageTable { diff --git a/src/core/hle/kernel/k_scheduler.cpp b/src/core/hle/kernel/k_scheduler.cpp index 1bce63a56..27d1c3846 100644 --- a/src/core/hle/kernel/k_scheduler.cpp +++ b/src/core/hle/kernel/k_scheduler.cpp @@ -494,12 +494,7 @@ void KScheduler::ScheduleImplFiber() { } void KScheduler::Unload(KThread* thread) { - auto& cpu_core = m_kernel.System().ArmInterface(m_core_id); - cpu_core.SaveContext(thread->GetContext32()); - cpu_core.SaveContext(thread->GetContext64()); - // Save the TPIDR_EL0 system register in case it was modified. - thread->SetTpidrEl0(cpu_core.GetTPIDR_EL0()); - cpu_core.ClearExclusiveState(); + m_kernel.PhysicalCore(m_core_id).SaveContext(thread); // Check if the thread is terminated by checking the DPC flags. if ((thread->GetStackParameters().dpc_flags & static_cast<u32>(DpcFlag::Terminated)) == 0) { @@ -509,14 +504,7 @@ void KScheduler::Unload(KThread* thread) { } void KScheduler::Reload(KThread* thread) { - auto& cpu_core = m_kernel.System().ArmInterface(m_core_id); - auto* process = thread->GetOwnerProcess(); - cpu_core.LoadContext(thread->GetContext32()); - cpu_core.LoadContext(thread->GetContext64()); - cpu_core.SetTlsAddress(GetInteger(thread->GetTlsAddress())); - cpu_core.SetTPIDR_EL0(thread->GetTpidrEl0()); - cpu_core.LoadWatchpointArray(process ? &process->GetWatchpoints() : nullptr); - cpu_core.ClearExclusiveState(); + m_kernel.PhysicalCore(m_core_id).LoadContext(thread); } void KScheduler::ClearPreviousThread(KernelCore& kernel, KThread* thread) { diff --git a/src/core/hle/kernel/k_thread.cpp b/src/core/hle/kernel/k_thread.cpp index a6deb50ec..7d9a6e9cf 100644 --- a/src/core/hle/kernel/k_thread.cpp +++ b/src/core/hle/kernel/k_thread.cpp @@ -41,24 +41,25 @@ namespace { constexpr inline s32 TerminatingThreadPriority = Kernel::Svc::SystemThreadPriorityHighest - 1; -static void ResetThreadContext32(Kernel::KThread::ThreadContext32& context, u32 stack_top, - u32 entry_point, u32 arg) { - context = {}; - context.cpu_registers[0] = arg; - context.cpu_registers[15] = entry_point; - context.cpu_registers[13] = stack_top; - context.fpscr = 0; -} - -static void ResetThreadContext64(Kernel::KThread::ThreadContext64& context, u64 stack_top, - u64 entry_point, u64 arg) { - context = {}; - context.cpu_registers[0] = arg; - context.cpu_registers[18] = Kernel::KSystemControl::GenerateRandomU64() | 1; - context.pc = entry_point; - context.sp = stack_top; - context.fpcr = 0; - context.fpsr = 0; +static void ResetThreadContext32(Kernel::Svc::ThreadContext& ctx, u64 stack_top, u64 entry_point, + u64 arg) { + ctx = {}; + ctx.r[0] = arg; + ctx.r[15] = entry_point; + ctx.r[13] = stack_top; + ctx.fpcr = 0; + ctx.fpsr = 0; +} + +static void ResetThreadContext64(Kernel::Svc::ThreadContext& ctx, u64 stack_top, u64 entry_point, + u64 arg) { + ctx = {}; + ctx.r[0] = arg; + ctx.r[18] = Kernel::KSystemControl::GenerateRandomU64() | 1; + ctx.pc = entry_point; + ctx.sp = stack_top; + ctx.fpcr = 0; + ctx.fpsr = 0; } } // namespace @@ -223,9 +224,11 @@ Result KThread::Initialize(KThreadFunction func, uintptr_t arg, KProcessAddress } // Initialize thread context. - ResetThreadContext64(m_thread_context_64, GetInteger(user_stack_top), GetInteger(func), arg); - ResetThreadContext32(m_thread_context_32, static_cast<u32>(GetInteger(user_stack_top)), - static_cast<u32>(GetInteger(func)), static_cast<u32>(arg)); + if (m_parent != nullptr && !m_parent->Is64Bit()) { + ResetThreadContext32(m_thread_context, GetInteger(user_stack_top), GetInteger(func), arg); + } else { + ResetThreadContext64(m_thread_context, GetInteger(user_stack_top), GetInteger(func), arg); + } // Setup the stack parameters. StackParameters& sp = this->GetStackParameters(); @@ -823,20 +826,7 @@ void KThread::CloneFpuStatus() { ASSERT(this->GetOwnerProcess() != nullptr); ASSERT(this->GetOwnerProcess() == GetCurrentProcessPointer(m_kernel)); - if (this->GetOwnerProcess()->Is64Bit()) { - // Clone FPSR and FPCR. - ThreadContext64 cur_ctx{}; - m_kernel.System().CurrentArmInterface().SaveContext(cur_ctx); - - this->GetContext64().fpcr = cur_ctx.fpcr; - this->GetContext64().fpsr = cur_ctx.fpsr; - } else { - // Clone FPSCR. - ThreadContext32 cur_ctx{}; - m_kernel.System().CurrentArmInterface().SaveContext(cur_ctx); - - this->GetContext32().fpscr = cur_ctx.fpscr; - } + m_kernel.CurrentPhysicalCore().CloneFpuStatus(this); } Result KThread::SetActivity(Svc::ThreadActivity activity) { @@ -912,7 +902,7 @@ Result KThread::SetActivity(Svc::ThreadActivity activity) { R_SUCCEED(); } -Result KThread::GetThreadContext3(Common::ScratchBuffer<u8>& out) { +Result KThread::GetThreadContext3(Svc::ThreadContext* out) { // Lock ourselves. KScopedLightLock lk{m_activity_pause_lock}; @@ -926,18 +916,16 @@ Result KThread::GetThreadContext3(Common::ScratchBuffer<u8>& out) { // If we're not terminating, get the thread's user context. if (!this->IsTerminationRequested()) { + *out = m_thread_context; + + // Mask away mode bits, interrupt bits, IL bit, and other reserved bits. + constexpr u32 El0Aarch64PsrMask = 0xF0000000; + constexpr u32 El0Aarch32PsrMask = 0xFE0FFE20; + if (m_parent->Is64Bit()) { - // Mask away mode bits, interrupt bits, IL bit, and other reserved bits. - auto context = GetContext64(); - context.pstate &= 0xFF0FFE20; - out.resize_destructive(sizeof(context)); - std::memcpy(out.data(), std::addressof(context), sizeof(context)); + out->pstate &= El0Aarch64PsrMask; } else { - // Mask away mode bits, interrupt bits, IL bit, and other reserved bits. - auto context = GetContext32(); - context.cpsr &= 0xFF0FFE20; - out.resize_destructive(sizeof(context)); - std::memcpy(out.data(), std::addressof(context), sizeof(context)); + out->pstate &= El0Aarch32PsrMask; } } } diff --git a/src/core/hle/kernel/k_thread.h b/src/core/hle/kernel/k_thread.h index e9ca5dfca..390db2409 100644 --- a/src/core/hle/kernel/k_thread.h +++ b/src/core/hle/kernel/k_thread.h @@ -38,7 +38,6 @@ namespace Core { namespace Memory { class Memory; } -class ARM_Interface; class System; } // namespace Core @@ -137,8 +136,6 @@ public: ~KThread() override; public: - using ThreadContext32 = Core::ARM_Interface::ThreadContext32; - using ThreadContext64 = Core::ARM_Interface::ThreadContext64; using WaiterList = Common::IntrusiveListBaseTraits<KThread>::ListType; /** @@ -246,31 +243,22 @@ public: * @returns The value of the TPIDR_EL0 register. */ u64 GetTpidrEl0() const { - return m_thread_context_64.tpidr; + return m_thread_context.tpidr; } /// Sets the value of the TPIDR_EL0 Read/Write system register for this thread. void SetTpidrEl0(u64 value) { - m_thread_context_64.tpidr = value; - m_thread_context_32.tpidr = static_cast<u32>(value); + m_thread_context.tpidr = value; } void CloneFpuStatus(); - ThreadContext32& GetContext32() { - return m_thread_context_32; + Svc::ThreadContext& GetContext() { + return m_thread_context; } - const ThreadContext32& GetContext32() const { - return m_thread_context_32; - } - - ThreadContext64& GetContext64() { - return m_thread_context_64; - } - - const ThreadContext64& GetContext64() const { - return m_thread_context_64; + const Svc::ThreadContext& GetContext() const { + return m_thread_context; } std::shared_ptr<Common::Fiber>& GetHostContext(); @@ -577,7 +565,7 @@ public: void RemoveWaiter(KThread* thread); - Result GetThreadContext3(Common::ScratchBuffer<u8>& out); + Result GetThreadContext3(Svc::ThreadContext* out); KThread* RemoveUserWaiterByKey(bool* out_has_waiters, KProcessAddress key) { return this->RemoveWaiterByKey(out_has_waiters, key, false); @@ -734,8 +722,7 @@ private: std::function<void()>&& init_func); // For core KThread implementation - ThreadContext32 m_thread_context_32{}; - ThreadContext64 m_thread_context_64{}; + Svc::ThreadContext m_thread_context{}; Common::IntrusiveListNode m_process_list_node; Common::IntrusiveRedBlackTreeNode m_condvar_arbiter_tree_node{}; s32 m_priority{}; diff --git a/src/core/hle/kernel/kernel.cpp b/src/core/hle/kernel/kernel.cpp index 4a1559291..032c4e093 100644 --- a/src/core/hle/kernel/kernel.cpp +++ b/src/core/hle/kernel/kernel.cpp @@ -99,13 +99,6 @@ struct KernelCore::Impl { RegisterHostThread(nullptr); } - void InitializeCores() { - for (u32 core_id = 0; core_id < Core::Hardware::NUM_CPU_CORES; core_id++) { - cores[core_id]->Initialize((*application_process).Is64Bit()); - system.ApplicationMemory().SetCurrentPageTable(*application_process, core_id); - } - } - void TerminateApplicationProcess() { application_process.load()->Terminate(); } @@ -205,7 +198,7 @@ struct KernelCore::Impl { const s32 core{static_cast<s32>(i)}; schedulers[i] = std::make_unique<Kernel::KScheduler>(system.Kernel()); - cores[i] = std::make_unique<Kernel::PhysicalCore>(i, system, *schedulers[i]); + cores[i] = std::make_unique<Kernel::PhysicalCore>(system.Kernel(), i); auto* main_thread{Kernel::KThread::Create(system.Kernel())}; main_thread->SetCurrentCore(core); @@ -880,10 +873,6 @@ void KernelCore::Initialize() { impl->Initialize(*this); } -void KernelCore::InitializeCores() { - impl->InitializeCores(); -} - void KernelCore::Shutdown() { impl->Shutdown(); } @@ -993,21 +982,6 @@ const KAutoObjectWithListContainer& KernelCore::ObjectListContainer() const { return *impl->global_object_list_container; } -void KernelCore::InvalidateAllInstructionCaches() { - for (auto& physical_core : impl->cores) { - physical_core->ArmInterface().ClearInstructionCache(); - } -} - -void KernelCore::InvalidateCpuInstructionCacheRange(KProcessAddress addr, std::size_t size) { - for (auto& physical_core : impl->cores) { - if (!physical_core->IsInitialized()) { - continue; - } - physical_core->ArmInterface().InvalidateCacheRange(GetInteger(addr), size); - } -} - void KernelCore::PrepareReschedule(std::size_t id) { // TODO: Reimplement, this } diff --git a/src/core/hle/kernel/kernel.h b/src/core/hle/kernel/kernel.h index d8086c0ea..69b5bbd6c 100644 --- a/src/core/hle/kernel/kernel.h +++ b/src/core/hle/kernel/kernel.h @@ -104,9 +104,6 @@ public: /// Resets the kernel to a clean slate for use. void Initialize(); - /// Initializes the CPU cores. - void InitializeCores(); - /// Clears all resources in use by the kernel instance. void Shutdown(); @@ -181,10 +178,6 @@ public: const KAutoObjectWithListContainer& ObjectListContainer() const; - void InvalidateAllInstructionCaches(); - - void InvalidateCpuInstructionCacheRange(KProcessAddress addr, std::size_t size); - /// Registers all kernel objects with the global emulation state, this is purely for tracking /// leaks after emulation has been shutdown. void RegisterKernelObject(KAutoObject* object); diff --git a/src/core/hle/kernel/physical_core.cpp b/src/core/hle/kernel/physical_core.cpp index 073039825..7fa8e2a85 100644 --- a/src/core/hle/kernel/physical_core.cpp +++ b/src/core/hle/kernel/physical_core.cpp @@ -1,62 +1,206 @@ // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later +#include "common/scope_exit.h" #include "common/settings.h" -#include "core/arm/dynarmic/arm_dynarmic_32.h" -#include "core/arm/dynarmic/arm_dynarmic_64.h" -#ifdef HAS_NCE -#include "core/arm/nce/arm_nce.h" -#endif #include "core/core.h" -#include "core/hle/kernel/k_scheduler.h" +#include "core/debugger/debugger.h" +#include "core/hle/kernel/k_process.h" +#include "core/hle/kernel/k_thread.h" #include "core/hle/kernel/kernel.h" #include "core/hle/kernel/physical_core.h" +#include "core/hle/kernel/svc.h" namespace Kernel { -PhysicalCore::PhysicalCore(std::size_t core_index, Core::System& system, KScheduler& scheduler) - : m_core_index{core_index}, m_system{system}, m_scheduler{scheduler} { -#if defined(ARCHITECTURE_x86_64) || defined(ARCHITECTURE_arm64) - // TODO(bunnei): Initialization relies on a core being available. We may later replace this with - // an NCE interface or a 32-bit instance of Dynarmic. This should be abstracted out to a CPU - // manager. - auto& kernel = system.Kernel(); - m_arm_interface = std::make_unique<Core::ARM_Dynarmic_64>( - system, kernel.IsMulticore(), - reinterpret_cast<Core::DynarmicExclusiveMonitor&>(kernel.GetExclusiveMonitor()), - m_core_index); -#else -#error Platform not supported yet. -#endif +PhysicalCore::PhysicalCore(KernelCore& kernel, std::size_t core_index) + : m_kernel{kernel}, m_core_index{core_index} { + m_is_single_core = !kernel.IsMulticore(); } - PhysicalCore::~PhysicalCore() = default; -void PhysicalCore::Initialize(bool is_64_bit) { -#if defined(HAS_NCE) - if (Settings::IsNceEnabled()) { - m_arm_interface = std::make_unique<Core::ARM_NCE>(m_system, m_system.Kernel().IsMulticore(), - m_core_index); +void PhysicalCore::RunThread(Kernel::KThread* thread) { + auto* process = thread->GetOwnerProcess(); + auto& system = m_kernel.System(); + auto* interface = process->GetArmInterface(m_core_index); + + interface->Initialize(); + + const auto EnterContext = [&]() { + system.EnterCPUProfile(); + + // Lock the core context. + std::scoped_lock lk{m_guard}; + + // Check if we are already interrupted. If we are, we can just stop immediately. + if (m_is_interrupted) { + return false; + } + + // Mark that we are running. + m_arm_interface = interface; + m_current_thread = thread; + + // Acquire the lock on the thread parameters. + // This allows us to force synchronization with Interrupt. + interface->LockThread(thread); + + return true; + }; + + const auto ExitContext = [&]() { + // Unlock the thread. + interface->UnlockThread(thread); + + // Lock the core context. + std::scoped_lock lk{m_guard}; + + // On exit, we no longer are running. + m_arm_interface = nullptr; + m_current_thread = nullptr; + + system.ExitCPUProfile(); + }; + + while (true) { + // If the thread is scheduled for termination, exit. + if (thread->HasDpc() && thread->IsTerminationRequested()) { + thread->Exit(); + } + + // Notify the debugger and go to sleep if a step was performed + // and this thread has been scheduled again. + if (thread->GetStepState() == StepState::StepPerformed) { + system.GetDebugger().NotifyThreadStopped(thread); + thread->RequestSuspend(SuspendType::Debug); + return; + } + + // Otherwise, run the thread. + Core::HaltReason hr{}; + { + // If we were interrupted, exit immediately. + if (!EnterContext()) { + return; + } + + if (thread->GetStepState() == StepState::StepPending) { + hr = interface->StepThread(thread); + + if (True(hr & Core::HaltReason::StepThread)) { + thread->SetStepState(StepState::StepPerformed); + } + } else { + hr = interface->RunThread(thread); + } + + ExitContext(); + } + + // Determine why we stopped. + const bool supervisor_call = True(hr & Core::HaltReason::SupervisorCall); + const bool prefetch_abort = True(hr & Core::HaltReason::PrefetchAbort); + const bool breakpoint = True(hr & Core::HaltReason::InstructionBreakpoint); + const bool data_abort = True(hr & Core::HaltReason::DataAbort); + const bool interrupt = True(hr & Core::HaltReason::BreakLoop); + + // Since scheduling may occur here, we cannot use any cached + // state after returning from calls we make. + + // Notify the debugger and go to sleep if a breakpoint was hit, + // or if the thread is unable to continue for any reason. + if (breakpoint || prefetch_abort) { + if (breakpoint) { + interface->RewindBreakpointInstruction(); + } + if (system.DebuggerEnabled()) { + system.GetDebugger().NotifyThreadStopped(thread); + } else { + interface->LogBacktrace(process); + } + thread->RequestSuspend(SuspendType::Debug); + return; + } + + // Notify the debugger and go to sleep on data abort. + if (data_abort) { + if (system.DebuggerEnabled()) { + system.GetDebugger().NotifyThreadWatchpoint(thread, *interface->HaltedWatchpoint()); + } + thread->RequestSuspend(SuspendType::Debug); + return; + } + + // Handle system calls. + if (supervisor_call) { + // Perform call. + Svc::Call(system, interface->GetSvcNumber()); + return; + } + + // Handle external interrupt sources. + if (interrupt || !m_is_single_core) { + return; + } + } +} + +void PhysicalCore::LoadContext(const KThread* thread) { + auto* const process = thread->GetOwnerProcess(); + if (!process) { + // Kernel threads do not run on emulated CPU cores. return; } -#endif -#if defined(ARCHITECTURE_x86_64) || defined(ARCHITECTURE_arm64) - auto& kernel = m_system.Kernel(); - if (!is_64_bit) { - // We already initialized a 64-bit core, replace with a 32-bit one. - m_arm_interface = std::make_unique<Core::ARM_Dynarmic_32>( - m_system, kernel.IsMulticore(), - reinterpret_cast<Core::DynarmicExclusiveMonitor&>(kernel.GetExclusiveMonitor()), - m_core_index); + + auto* interface = process->GetArmInterface(m_core_index); + if (interface) { + interface->SetContext(thread->GetContext()); + interface->SetTpidrroEl0(GetInteger(thread->GetTlsAddress())); + interface->SetWatchpointArray(&process->GetWatchpoints()); } -#else -#error Platform not supported yet. -#endif } -void PhysicalCore::Run() { - m_arm_interface->Run(); - m_arm_interface->ClearExclusiveState(); +void PhysicalCore::LoadSvcArguments(const KProcess& process, std::span<const uint64_t, 8> args) { + process.GetArmInterface(m_core_index)->SetSvcArguments(args); +} + +void PhysicalCore::SaveContext(KThread* thread) const { + auto* const process = thread->GetOwnerProcess(); + if (!process) { + // Kernel threads do not run on emulated CPU cores. + return; + } + + auto* interface = process->GetArmInterface(m_core_index); + if (interface) { + interface->GetContext(thread->GetContext()); + } +} + +void PhysicalCore::SaveSvcArguments(KProcess& process, std::span<uint64_t, 8> args) const { + process.GetArmInterface(m_core_index)->GetSvcArguments(args); +} + +void PhysicalCore::CloneFpuStatus(KThread* dst) const { + auto* process = dst->GetOwnerProcess(); + + Svc::ThreadContext ctx{}; + process->GetArmInterface(m_core_index)->GetContext(ctx); + + dst->GetContext().fpcr = ctx.fpcr; + dst->GetContext().fpsr = ctx.fpsr; +} + +void PhysicalCore::LogBacktrace() { + auto* process = GetCurrentProcessPointer(m_kernel); + if (!process) { + return; + } + + auto* interface = process->GetArmInterface(m_core_index); + if (interface) { + interface->LogBacktrace(process); + } } void PhysicalCore::Idle() { @@ -69,16 +213,31 @@ bool PhysicalCore::IsInterrupted() const { } void PhysicalCore::Interrupt() { - std::unique_lock lk{m_guard}; + // Lock core context. + std::scoped_lock lk{m_guard}; + + // Load members. + auto* arm_interface = m_arm_interface; + auto* thread = m_current_thread; + + // Add interrupt flag. m_is_interrupted = true; - m_arm_interface->SignalInterrupt(); - m_on_interrupt.notify_all(); + + // Interrupt ourselves. + m_on_interrupt.notify_one(); + + // If there is no thread running, we are done. + if (arm_interface == nullptr) { + return; + } + + // Interrupt the CPU. + arm_interface->SignalInterrupt(thread); } void PhysicalCore::ClearInterrupt() { - std::unique_lock lk{m_guard}; + std::scoped_lock lk{m_guard}; m_is_interrupted = false; - m_arm_interface->ClearInterrupt(); } } // namespace Kernel diff --git a/src/core/hle/kernel/physical_core.h b/src/core/hle/kernel/physical_core.h index 5cb398fdc..bae4fe5b8 100644 --- a/src/core/hle/kernel/physical_core.h +++ b/src/core/hle/kernel/physical_core.h @@ -11,7 +11,7 @@ #include "core/arm/arm_interface.h" namespace Kernel { -class KScheduler; +class KernelCore; } // namespace Kernel namespace Core { @@ -23,62 +23,55 @@ namespace Kernel { class PhysicalCore { public: - PhysicalCore(std::size_t core_index_, Core::System& system_, KScheduler& scheduler_); + PhysicalCore(KernelCore& kernel, std::size_t core_index); ~PhysicalCore(); YUZU_NON_COPYABLE(PhysicalCore); YUZU_NON_MOVEABLE(PhysicalCore); - /// Initialize the core for the specified parameters. - void Initialize(bool is_64_bit); + // Execute guest code running on the given thread. + void RunThread(KThread* thread); - /// Execute current jit state - void Run(); + // Copy context from thread to current core. + void LoadContext(const KThread* thread); + void LoadSvcArguments(const KProcess& process, std::span<const uint64_t, 8> args); + // Copy context from current core to thread. + void SaveContext(KThread* thread) const; + void SaveSvcArguments(KProcess& process, std::span<uint64_t, 8> args) const; + + // Copy floating point status registers to the target thread. + void CloneFpuStatus(KThread* dst) const; + + // Log backtrace of current processor state. + void LogBacktrace(); + + // Wait for an interrupt. void Idle(); - /// Interrupt this physical core. + // Interrupt this core. void Interrupt(); - /// Clear this core's interrupt + // Clear this core's interrupt. void ClearInterrupt(); - /// Check if this core is interrupted + // Check if this core is interrupted. bool IsInterrupted() const; - bool IsInitialized() const { - return m_arm_interface != nullptr; - } - - Core::ARM_Interface& ArmInterface() { - return *m_arm_interface; - } - - const Core::ARM_Interface& ArmInterface() const { - return *m_arm_interface; - } - std::size_t CoreIndex() const { return m_core_index; } - Kernel::KScheduler& Scheduler() { - return m_scheduler; - } - - const Kernel::KScheduler& Scheduler() const { - return m_scheduler; - } - private: + KernelCore& m_kernel; const std::size_t m_core_index; - Core::System& m_system; - Kernel::KScheduler& m_scheduler; std::mutex m_guard; std::condition_variable m_on_interrupt; - std::unique_ptr<Core::ARM_Interface> m_arm_interface; + Core::ArmInterface* m_arm_interface{}; + KThread* m_current_thread{}; bool m_is_interrupted{}; + bool m_is_single_core{}; }; } // namespace Kernel diff --git a/src/core/hle/kernel/svc.cpp b/src/core/hle/kernel/svc.cpp index b76683969..c55dc0c8a 100644 --- a/src/core/hle/kernel/svc.cpp +++ b/src/core/hle/kernel/svc.cpp @@ -12,20 +12,20 @@ namespace Kernel::Svc { -static uint32_t GetReg32(Core::System& system, int n) { - return static_cast<uint32_t>(system.CurrentArmInterface().GetReg(n)); +static uint32_t GetArg32(std::span<uint64_t, 8> args, int n) { + return static_cast<uint32_t>(args[n]); } -static void SetReg32(Core::System& system, int n, uint32_t result) { - system.CurrentArmInterface().SetReg(n, static_cast<uint64_t>(result)); +static void SetArg32(std::span<uint64_t, 8> args, int n, uint32_t result) { + args[n] = result; } -static uint64_t GetReg64(Core::System& system, int n) { - return system.CurrentArmInterface().GetReg(n); +static uint64_t GetArg64(std::span<uint64_t, 8> args, int n) { + return args[n]; } -static void SetReg64(Core::System& system, int n, uint64_t result) { - system.CurrentArmInterface().SetReg(n, result); +static void SetArg64(std::span<uint64_t, 8> args, int n, uint64_t result) { + args[n] = result; } // Like bit_cast, but handles the case when the source and dest @@ -79,37 +79,37 @@ static_assert(sizeof(int64_t) == 8); static_assert(sizeof(uint32_t) == 4); static_assert(sizeof(uint64_t) == 8); -static void SvcWrap_SetHeapSize64From32(Core::System& system) { +static void SvcWrap_SetHeapSize64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t out_address{}; uint32_t size{}; - size = Convert<uint32_t>(GetReg32(system, 1)); + size = Convert<uint32_t>(GetArg32(args, 1)); ret = SetHeapSize64From32(system, std::addressof(out_address), size); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_address)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_address)); } -static void SvcWrap_SetMemoryPermission64From32(Core::System& system) { +static void SvcWrap_SetMemoryPermission64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t address{}; uint32_t size{}; MemoryPermission perm{}; - address = Convert<uint32_t>(GetReg32(system, 0)); - size = Convert<uint32_t>(GetReg32(system, 1)); - perm = Convert<MemoryPermission>(GetReg32(system, 2)); + address = Convert<uint32_t>(GetArg32(args, 0)); + size = Convert<uint32_t>(GetArg32(args, 1)); + perm = Convert<MemoryPermission>(GetArg32(args, 2)); ret = SetMemoryPermission64From32(system, address, size, perm); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_SetMemoryAttribute64From32(Core::System& system) { +static void SvcWrap_SetMemoryAttribute64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t address{}; @@ -117,69 +117,69 @@ static void SvcWrap_SetMemoryAttribute64From32(Core::System& system) { uint32_t mask{}; uint32_t attr{}; - address = Convert<uint32_t>(GetReg32(system, 0)); - size = Convert<uint32_t>(GetReg32(system, 1)); - mask = Convert<uint32_t>(GetReg32(system, 2)); - attr = Convert<uint32_t>(GetReg32(system, 3)); + address = Convert<uint32_t>(GetArg32(args, 0)); + size = Convert<uint32_t>(GetArg32(args, 1)); + mask = Convert<uint32_t>(GetArg32(args, 2)); + attr = Convert<uint32_t>(GetArg32(args, 3)); ret = SetMemoryAttribute64From32(system, address, size, mask, attr); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_MapMemory64From32(Core::System& system) { +static void SvcWrap_MapMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t dst_address{}; uint32_t src_address{}; uint32_t size{}; - dst_address = Convert<uint32_t>(GetReg32(system, 0)); - src_address = Convert<uint32_t>(GetReg32(system, 1)); - size = Convert<uint32_t>(GetReg32(system, 2)); + dst_address = Convert<uint32_t>(GetArg32(args, 0)); + src_address = Convert<uint32_t>(GetArg32(args, 1)); + size = Convert<uint32_t>(GetArg32(args, 2)); ret = MapMemory64From32(system, dst_address, src_address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_UnmapMemory64From32(Core::System& system) { +static void SvcWrap_UnmapMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t dst_address{}; uint32_t src_address{}; uint32_t size{}; - dst_address = Convert<uint32_t>(GetReg32(system, 0)); - src_address = Convert<uint32_t>(GetReg32(system, 1)); - size = Convert<uint32_t>(GetReg32(system, 2)); + dst_address = Convert<uint32_t>(GetArg32(args, 0)); + src_address = Convert<uint32_t>(GetArg32(args, 1)); + size = Convert<uint32_t>(GetArg32(args, 2)); ret = UnmapMemory64From32(system, dst_address, src_address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_QueryMemory64From32(Core::System& system) { +static void SvcWrap_QueryMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; PageInfo out_page_info{}; uint32_t out_memory_info{}; uint32_t address{}; - out_memory_info = Convert<uint32_t>(GetReg32(system, 0)); - address = Convert<uint32_t>(GetReg32(system, 2)); + out_memory_info = Convert<uint32_t>(GetArg32(args, 0)); + address = Convert<uint32_t>(GetArg32(args, 2)); ret = QueryMemory64From32(system, out_memory_info, std::addressof(out_page_info), address); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_page_info)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_page_info)); } -static void SvcWrap_ExitProcess64From32(Core::System& system) { +static void SvcWrap_ExitProcess64From32(Core::System& system, std::span<uint64_t, 8> args) { ExitProcess64From32(system); } -static void SvcWrap_CreateThread64From32(Core::System& system) { +static void SvcWrap_CreateThread64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; @@ -189,143 +189,143 @@ static void SvcWrap_CreateThread64From32(Core::System& system) { int32_t priority{}; int32_t core_id{}; - func = Convert<uint32_t>(GetReg32(system, 1)); - arg = Convert<uint32_t>(GetReg32(system, 2)); - stack_bottom = Convert<uint32_t>(GetReg32(system, 3)); - priority = Convert<int32_t>(GetReg32(system, 0)); - core_id = Convert<int32_t>(GetReg32(system, 4)); + func = Convert<uint32_t>(GetArg32(args, 1)); + arg = Convert<uint32_t>(GetArg32(args, 2)); + stack_bottom = Convert<uint32_t>(GetArg32(args, 3)); + priority = Convert<int32_t>(GetArg32(args, 0)); + core_id = Convert<int32_t>(GetArg32(args, 4)); ret = CreateThread64From32(system, std::addressof(out_handle), func, arg, stack_bottom, priority, core_id); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_handle)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_handle)); } -static void SvcWrap_StartThread64From32(Core::System& system) { +static void SvcWrap_StartThread64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle thread_handle{}; - thread_handle = Convert<Handle>(GetReg32(system, 0)); + thread_handle = Convert<Handle>(GetArg32(args, 0)); ret = StartThread64From32(system, thread_handle); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_ExitThread64From32(Core::System& system) { +static void SvcWrap_ExitThread64From32(Core::System& system, std::span<uint64_t, 8> args) { ExitThread64From32(system); } -static void SvcWrap_SleepThread64From32(Core::System& system) { +static void SvcWrap_SleepThread64From32(Core::System& system, std::span<uint64_t, 8> args) { int64_t ns{}; std::array<uint32_t, 2> ns_gather{}; - ns_gather[0] = GetReg32(system, 0); - ns_gather[1] = GetReg32(system, 1); + ns_gather[0] = GetArg32(args, 0); + ns_gather[1] = GetArg32(args, 1); ns = Convert<int64_t>(ns_gather); SleepThread64From32(system, ns); } -static void SvcWrap_GetThreadPriority64From32(Core::System& system) { +static void SvcWrap_GetThreadPriority64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int32_t out_priority{}; Handle thread_handle{}; - thread_handle = Convert<Handle>(GetReg32(system, 1)); + thread_handle = Convert<Handle>(GetArg32(args, 1)); ret = GetThreadPriority64From32(system, std::addressof(out_priority), thread_handle); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_priority)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_priority)); } -static void SvcWrap_SetThreadPriority64From32(Core::System& system) { +static void SvcWrap_SetThreadPriority64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle thread_handle{}; int32_t priority{}; - thread_handle = Convert<Handle>(GetReg32(system, 0)); - priority = Convert<int32_t>(GetReg32(system, 1)); + thread_handle = Convert<Handle>(GetArg32(args, 0)); + priority = Convert<int32_t>(GetArg32(args, 1)); ret = SetThreadPriority64From32(system, thread_handle, priority); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_GetThreadCoreMask64From32(Core::System& system) { +static void SvcWrap_GetThreadCoreMask64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int32_t out_core_id{}; uint64_t out_affinity_mask{}; Handle thread_handle{}; - thread_handle = Convert<Handle>(GetReg32(system, 2)); + thread_handle = Convert<Handle>(GetArg32(args, 2)); ret = GetThreadCoreMask64From32(system, std::addressof(out_core_id), std::addressof(out_affinity_mask), thread_handle); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_core_id)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_core_id)); auto out_affinity_mask_scatter = Convert<std::array<uint32_t, 2>>(out_affinity_mask); - SetReg32(system, 2, out_affinity_mask_scatter[0]); - SetReg32(system, 3, out_affinity_mask_scatter[1]); + SetArg32(args, 2, out_affinity_mask_scatter[0]); + SetArg32(args, 3, out_affinity_mask_scatter[1]); } -static void SvcWrap_SetThreadCoreMask64From32(Core::System& system) { +static void SvcWrap_SetThreadCoreMask64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle thread_handle{}; int32_t core_id{}; uint64_t affinity_mask{}; - thread_handle = Convert<Handle>(GetReg32(system, 0)); - core_id = Convert<int32_t>(GetReg32(system, 1)); + thread_handle = Convert<Handle>(GetArg32(args, 0)); + core_id = Convert<int32_t>(GetArg32(args, 1)); std::array<uint32_t, 2> affinity_mask_gather{}; - affinity_mask_gather[0] = GetReg32(system, 2); - affinity_mask_gather[1] = GetReg32(system, 3); + affinity_mask_gather[0] = GetArg32(args, 2); + affinity_mask_gather[1] = GetArg32(args, 3); affinity_mask = Convert<uint64_t>(affinity_mask_gather); ret = SetThreadCoreMask64From32(system, thread_handle, core_id, affinity_mask); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_GetCurrentProcessorNumber64From32(Core::System& system) { +static void SvcWrap_GetCurrentProcessorNumber64From32(Core::System& system, std::span<uint64_t, 8> args) { int32_t ret{}; ret = GetCurrentProcessorNumber64From32(system); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_SignalEvent64From32(Core::System& system) { +static void SvcWrap_SignalEvent64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle event_handle{}; - event_handle = Convert<Handle>(GetReg32(system, 0)); + event_handle = Convert<Handle>(GetArg32(args, 0)); ret = SignalEvent64From32(system, event_handle); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_ClearEvent64From32(Core::System& system) { +static void SvcWrap_ClearEvent64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle event_handle{}; - event_handle = Convert<Handle>(GetReg32(system, 0)); + event_handle = Convert<Handle>(GetArg32(args, 0)); ret = ClearEvent64From32(system, event_handle); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_MapSharedMemory64From32(Core::System& system) { +static void SvcWrap_MapSharedMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle shmem_handle{}; @@ -333,33 +333,33 @@ static void SvcWrap_MapSharedMemory64From32(Core::System& system) { uint32_t size{}; MemoryPermission map_perm{}; - shmem_handle = Convert<Handle>(GetReg32(system, 0)); - address = Convert<uint32_t>(GetReg32(system, 1)); - size = Convert<uint32_t>(GetReg32(system, 2)); - map_perm = Convert<MemoryPermission>(GetReg32(system, 3)); + shmem_handle = Convert<Handle>(GetArg32(args, 0)); + address = Convert<uint32_t>(GetArg32(args, 1)); + size = Convert<uint32_t>(GetArg32(args, 2)); + map_perm = Convert<MemoryPermission>(GetArg32(args, 3)); ret = MapSharedMemory64From32(system, shmem_handle, address, size, map_perm); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_UnmapSharedMemory64From32(Core::System& system) { +static void SvcWrap_UnmapSharedMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle shmem_handle{}; uint32_t address{}; uint32_t size{}; - shmem_handle = Convert<Handle>(GetReg32(system, 0)); - address = Convert<uint32_t>(GetReg32(system, 1)); - size = Convert<uint32_t>(GetReg32(system, 2)); + shmem_handle = Convert<Handle>(GetArg32(args, 0)); + address = Convert<uint32_t>(GetArg32(args, 1)); + size = Convert<uint32_t>(GetArg32(args, 2)); ret = UnmapSharedMemory64From32(system, shmem_handle, address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_CreateTransferMemory64From32(Core::System& system) { +static void SvcWrap_CreateTransferMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; @@ -367,41 +367,41 @@ static void SvcWrap_CreateTransferMemory64From32(Core::System& system) { uint32_t size{}; MemoryPermission map_perm{}; - address = Convert<uint32_t>(GetReg32(system, 1)); - size = Convert<uint32_t>(GetReg32(system, 2)); - map_perm = Convert<MemoryPermission>(GetReg32(system, 3)); + address = Convert<uint32_t>(GetArg32(args, 1)); + size = Convert<uint32_t>(GetArg32(args, 2)); + map_perm = Convert<MemoryPermission>(GetArg32(args, 3)); ret = CreateTransferMemory64From32(system, std::addressof(out_handle), address, size, map_perm); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_handle)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_handle)); } -static void SvcWrap_CloseHandle64From32(Core::System& system) { +static void SvcWrap_CloseHandle64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle handle{}; - handle = Convert<Handle>(GetReg32(system, 0)); + handle = Convert<Handle>(GetArg32(args, 0)); ret = CloseHandle64From32(system, handle); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_ResetSignal64From32(Core::System& system) { +static void SvcWrap_ResetSignal64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle handle{}; - handle = Convert<Handle>(GetReg32(system, 0)); + handle = Convert<Handle>(GetArg32(args, 0)); ret = ResetSignal64From32(system, handle); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_WaitSynchronization64From32(Core::System& system) { +static void SvcWrap_WaitSynchronization64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int32_t out_index{}; @@ -409,60 +409,60 @@ static void SvcWrap_WaitSynchronization64From32(Core::System& system) { int32_t num_handles{}; int64_t timeout_ns{}; - handles = Convert<uint32_t>(GetReg32(system, 1)); - num_handles = Convert<int32_t>(GetReg32(system, 2)); + handles = Convert<uint32_t>(GetArg32(args, 1)); + num_handles = Convert<int32_t>(GetArg32(args, 2)); std::array<uint32_t, 2> timeout_ns_gather{}; - timeout_ns_gather[0] = GetReg32(system, 0); - timeout_ns_gather[1] = GetReg32(system, 3); + timeout_ns_gather[0] = GetArg32(args, 0); + timeout_ns_gather[1] = GetArg32(args, 3); timeout_ns = Convert<int64_t>(timeout_ns_gather); ret = WaitSynchronization64From32(system, std::addressof(out_index), handles, num_handles, timeout_ns); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_index)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_index)); } -static void SvcWrap_CancelSynchronization64From32(Core::System& system) { +static void SvcWrap_CancelSynchronization64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle handle{}; - handle = Convert<Handle>(GetReg32(system, 0)); + handle = Convert<Handle>(GetArg32(args, 0)); ret = CancelSynchronization64From32(system, handle); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_ArbitrateLock64From32(Core::System& system) { +static void SvcWrap_ArbitrateLock64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle thread_handle{}; uint32_t address{}; uint32_t tag{}; - thread_handle = Convert<Handle>(GetReg32(system, 0)); - address = Convert<uint32_t>(GetReg32(system, 1)); - tag = Convert<uint32_t>(GetReg32(system, 2)); + thread_handle = Convert<Handle>(GetArg32(args, 0)); + address = Convert<uint32_t>(GetArg32(args, 1)); + tag = Convert<uint32_t>(GetArg32(args, 2)); ret = ArbitrateLock64From32(system, thread_handle, address, tag); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_ArbitrateUnlock64From32(Core::System& system) { +static void SvcWrap_ArbitrateUnlock64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t address{}; - address = Convert<uint32_t>(GetReg32(system, 0)); + address = Convert<uint32_t>(GetArg32(args, 0)); ret = ArbitrateUnlock64From32(system, address); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_WaitProcessWideKeyAtomic64From32(Core::System& system) { +static void SvcWrap_WaitProcessWideKeyAtomic64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t address{}; @@ -470,82 +470,82 @@ static void SvcWrap_WaitProcessWideKeyAtomic64From32(Core::System& system) { uint32_t tag{}; int64_t timeout_ns{}; - address = Convert<uint32_t>(GetReg32(system, 0)); - cv_key = Convert<uint32_t>(GetReg32(system, 1)); - tag = Convert<uint32_t>(GetReg32(system, 2)); + address = Convert<uint32_t>(GetArg32(args, 0)); + cv_key = Convert<uint32_t>(GetArg32(args, 1)); + tag = Convert<uint32_t>(GetArg32(args, 2)); std::array<uint32_t, 2> timeout_ns_gather{}; - timeout_ns_gather[0] = GetReg32(system, 3); - timeout_ns_gather[1] = GetReg32(system, 4); + timeout_ns_gather[0] = GetArg32(args, 3); + timeout_ns_gather[1] = GetArg32(args, 4); timeout_ns = Convert<int64_t>(timeout_ns_gather); ret = WaitProcessWideKeyAtomic64From32(system, address, cv_key, tag, timeout_ns); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_SignalProcessWideKey64From32(Core::System& system) { +static void SvcWrap_SignalProcessWideKey64From32(Core::System& system, std::span<uint64_t, 8> args) { uint32_t cv_key{}; int32_t count{}; - cv_key = Convert<uint32_t>(GetReg32(system, 0)); - count = Convert<int32_t>(GetReg32(system, 1)); + cv_key = Convert<uint32_t>(GetArg32(args, 0)); + count = Convert<int32_t>(GetArg32(args, 1)); SignalProcessWideKey64From32(system, cv_key, count); } -static void SvcWrap_GetSystemTick64From32(Core::System& system) { +static void SvcWrap_GetSystemTick64From32(Core::System& system, std::span<uint64_t, 8> args) { int64_t ret{}; ret = GetSystemTick64From32(system); auto ret_scatter = Convert<std::array<uint32_t, 2>>(ret); - SetReg32(system, 0, ret_scatter[0]); - SetReg32(system, 1, ret_scatter[1]); + SetArg32(args, 0, ret_scatter[0]); + SetArg32(args, 1, ret_scatter[1]); } -static void SvcWrap_ConnectToNamedPort64From32(Core::System& system) { +static void SvcWrap_ConnectToNamedPort64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; uint32_t name{}; - name = Convert<uint32_t>(GetReg32(system, 1)); + name = Convert<uint32_t>(GetArg32(args, 1)); ret = ConnectToNamedPort64From32(system, std::addressof(out_handle), name); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_handle)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_handle)); } -static void SvcWrap_SendSyncRequest64From32(Core::System& system) { +static void SvcWrap_SendSyncRequest64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle session_handle{}; - session_handle = Convert<Handle>(GetReg32(system, 0)); + session_handle = Convert<Handle>(GetArg32(args, 0)); ret = SendSyncRequest64From32(system, session_handle); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_SendSyncRequestWithUserBuffer64From32(Core::System& system) { +static void SvcWrap_SendSyncRequestWithUserBuffer64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t message_buffer{}; uint32_t message_buffer_size{}; Handle session_handle{}; - message_buffer = Convert<uint32_t>(GetReg32(system, 0)); - message_buffer_size = Convert<uint32_t>(GetReg32(system, 1)); - session_handle = Convert<Handle>(GetReg32(system, 2)); + message_buffer = Convert<uint32_t>(GetArg32(args, 0)); + message_buffer_size = Convert<uint32_t>(GetArg32(args, 1)); + session_handle = Convert<Handle>(GetArg32(args, 2)); ret = SendSyncRequestWithUserBuffer64From32(system, message_buffer, message_buffer_size, session_handle); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_SendAsyncRequestWithUserBuffer64From32(Core::System& system) { +static void SvcWrap_SendAsyncRequestWithUserBuffer64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_event_handle{}; @@ -553,83 +553,83 @@ static void SvcWrap_SendAsyncRequestWithUserBuffer64From32(Core::System& system) uint32_t message_buffer_size{}; Handle session_handle{}; - message_buffer = Convert<uint32_t>(GetReg32(system, 1)); - message_buffer_size = Convert<uint32_t>(GetReg32(system, 2)); - session_handle = Convert<Handle>(GetReg32(system, 3)); + message_buffer = Convert<uint32_t>(GetArg32(args, 1)); + message_buffer_size = Convert<uint32_t>(GetArg32(args, 2)); + session_handle = Convert<Handle>(GetArg32(args, 3)); ret = SendAsyncRequestWithUserBuffer64From32(system, std::addressof(out_event_handle), message_buffer, message_buffer_size, session_handle); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_event_handle)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_event_handle)); } -static void SvcWrap_GetProcessId64From32(Core::System& system) { +static void SvcWrap_GetProcessId64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t out_process_id{}; Handle process_handle{}; - process_handle = Convert<Handle>(GetReg32(system, 1)); + process_handle = Convert<Handle>(GetArg32(args, 1)); ret = GetProcessId64From32(system, std::addressof(out_process_id), process_handle); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); auto out_process_id_scatter = Convert<std::array<uint32_t, 2>>(out_process_id); - SetReg32(system, 1, out_process_id_scatter[0]); - SetReg32(system, 2, out_process_id_scatter[1]); + SetArg32(args, 1, out_process_id_scatter[0]); + SetArg32(args, 2, out_process_id_scatter[1]); } -static void SvcWrap_GetThreadId64From32(Core::System& system) { +static void SvcWrap_GetThreadId64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t out_thread_id{}; Handle thread_handle{}; - thread_handle = Convert<Handle>(GetReg32(system, 1)); + thread_handle = Convert<Handle>(GetArg32(args, 1)); ret = GetThreadId64From32(system, std::addressof(out_thread_id), thread_handle); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); auto out_thread_id_scatter = Convert<std::array<uint32_t, 2>>(out_thread_id); - SetReg32(system, 1, out_thread_id_scatter[0]); - SetReg32(system, 2, out_thread_id_scatter[1]); + SetArg32(args, 1, out_thread_id_scatter[0]); + SetArg32(args, 2, out_thread_id_scatter[1]); } -static void SvcWrap_Break64From32(Core::System& system) { +static void SvcWrap_Break64From32(Core::System& system, std::span<uint64_t, 8> args) { BreakReason break_reason{}; uint32_t arg{}; uint32_t size{}; - break_reason = Convert<BreakReason>(GetReg32(system, 0)); - arg = Convert<uint32_t>(GetReg32(system, 1)); - size = Convert<uint32_t>(GetReg32(system, 2)); + break_reason = Convert<BreakReason>(GetArg32(args, 0)); + arg = Convert<uint32_t>(GetArg32(args, 1)); + size = Convert<uint32_t>(GetArg32(args, 2)); Break64From32(system, break_reason, arg, size); } -static void SvcWrap_OutputDebugString64From32(Core::System& system) { +static void SvcWrap_OutputDebugString64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t debug_str{}; uint32_t len{}; - debug_str = Convert<uint32_t>(GetReg32(system, 0)); - len = Convert<uint32_t>(GetReg32(system, 1)); + debug_str = Convert<uint32_t>(GetArg32(args, 0)); + len = Convert<uint32_t>(GetArg32(args, 1)); ret = OutputDebugString64From32(system, debug_str, len); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_ReturnFromException64From32(Core::System& system) { +static void SvcWrap_ReturnFromException64From32(Core::System& system, std::span<uint64_t, 8> args) { Result result{}; - result = Convert<Result>(GetReg32(system, 0)); + result = Convert<Result>(GetArg32(args, 0)); ReturnFromException64From32(system, result); } -static void SvcWrap_GetInfo64From32(Core::System& system) { +static void SvcWrap_GetInfo64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t out{}; @@ -637,68 +637,68 @@ static void SvcWrap_GetInfo64From32(Core::System& system) { Handle handle{}; uint64_t info_subtype{}; - info_type = Convert<InfoType>(GetReg32(system, 1)); - handle = Convert<Handle>(GetReg32(system, 2)); + info_type = Convert<InfoType>(GetArg32(args, 1)); + handle = Convert<Handle>(GetArg32(args, 2)); std::array<uint32_t, 2> info_subtype_gather{}; - info_subtype_gather[0] = GetReg32(system, 0); - info_subtype_gather[1] = GetReg32(system, 3); + info_subtype_gather[0] = GetArg32(args, 0); + info_subtype_gather[1] = GetArg32(args, 3); info_subtype = Convert<uint64_t>(info_subtype_gather); ret = GetInfo64From32(system, std::addressof(out), info_type, handle, info_subtype); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); auto out_scatter = Convert<std::array<uint32_t, 2>>(out); - SetReg32(system, 1, out_scatter[0]); - SetReg32(system, 2, out_scatter[1]); + SetArg32(args, 1, out_scatter[0]); + SetArg32(args, 2, out_scatter[1]); } -static void SvcWrap_FlushEntireDataCache64From32(Core::System& system) { +static void SvcWrap_FlushEntireDataCache64From32(Core::System& system, std::span<uint64_t, 8> args) { FlushEntireDataCache64From32(system); } -static void SvcWrap_FlushDataCache64From32(Core::System& system) { +static void SvcWrap_FlushDataCache64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t address{}; uint32_t size{}; - address = Convert<uint32_t>(GetReg32(system, 0)); - size = Convert<uint32_t>(GetReg32(system, 1)); + address = Convert<uint32_t>(GetArg32(args, 0)); + size = Convert<uint32_t>(GetArg32(args, 1)); ret = FlushDataCache64From32(system, address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_MapPhysicalMemory64From32(Core::System& system) { +static void SvcWrap_MapPhysicalMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t address{}; uint32_t size{}; - address = Convert<uint32_t>(GetReg32(system, 0)); - size = Convert<uint32_t>(GetReg32(system, 1)); + address = Convert<uint32_t>(GetArg32(args, 0)); + size = Convert<uint32_t>(GetArg32(args, 1)); ret = MapPhysicalMemory64From32(system, address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_UnmapPhysicalMemory64From32(Core::System& system) { +static void SvcWrap_UnmapPhysicalMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t address{}; uint32_t size{}; - address = Convert<uint32_t>(GetReg32(system, 0)); - size = Convert<uint32_t>(GetReg32(system, 1)); + address = Convert<uint32_t>(GetArg32(args, 0)); + size = Convert<uint32_t>(GetArg32(args, 1)); ret = UnmapPhysicalMemory64From32(system, address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_GetDebugFutureThreadInfo64From32(Core::System& system) { +static void SvcWrap_GetDebugFutureThreadInfo64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; ilp32::LastThreadContext out_context{}; @@ -706,26 +706,26 @@ static void SvcWrap_GetDebugFutureThreadInfo64From32(Core::System& system) { Handle debug_handle{}; int64_t ns{}; - debug_handle = Convert<Handle>(GetReg32(system, 2)); + debug_handle = Convert<Handle>(GetArg32(args, 2)); std::array<uint32_t, 2> ns_gather{}; - ns_gather[0] = GetReg32(system, 0); - ns_gather[1] = GetReg32(system, 1); + ns_gather[0] = GetArg32(args, 0); + ns_gather[1] = GetArg32(args, 1); ns = Convert<int64_t>(ns_gather); ret = GetDebugFutureThreadInfo64From32(system, std::addressof(out_context), std::addressof(out_thread_id), debug_handle, ns); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); auto out_context_scatter = Convert<std::array<uint32_t, 4>>(out_context); - SetReg32(system, 1, out_context_scatter[0]); - SetReg32(system, 2, out_context_scatter[1]); - SetReg32(system, 3, out_context_scatter[2]); - SetReg32(system, 4, out_context_scatter[3]); + SetArg32(args, 1, out_context_scatter[0]); + SetArg32(args, 2, out_context_scatter[1]); + SetArg32(args, 3, out_context_scatter[2]); + SetArg32(args, 4, out_context_scatter[3]); auto out_thread_id_scatter = Convert<std::array<uint32_t, 2>>(out_thread_id); - SetReg32(system, 5, out_thread_id_scatter[0]); - SetReg32(system, 6, out_thread_id_scatter[1]); + SetArg32(args, 5, out_thread_id_scatter[0]); + SetArg32(args, 6, out_thread_id_scatter[1]); } -static void SvcWrap_GetLastThreadInfo64From32(Core::System& system) { +static void SvcWrap_GetLastThreadInfo64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; ilp32::LastThreadContext out_context{}; @@ -734,81 +734,81 @@ static void SvcWrap_GetLastThreadInfo64From32(Core::System& system) { ret = GetLastThreadInfo64From32(system, std::addressof(out_context), std::addressof(out_tls_address), std::addressof(out_flags)); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); auto out_context_scatter = Convert<std::array<uint32_t, 4>>(out_context); - SetReg32(system, 1, out_context_scatter[0]); - SetReg32(system, 2, out_context_scatter[1]); - SetReg32(system, 3, out_context_scatter[2]); - SetReg32(system, 4, out_context_scatter[3]); - SetReg32(system, 5, Convert<uint32_t>(out_tls_address)); - SetReg32(system, 6, Convert<uint32_t>(out_flags)); + SetArg32(args, 1, out_context_scatter[0]); + SetArg32(args, 2, out_context_scatter[1]); + SetArg32(args, 3, out_context_scatter[2]); + SetArg32(args, 4, out_context_scatter[3]); + SetArg32(args, 5, Convert<uint32_t>(out_tls_address)); + SetArg32(args, 6, Convert<uint32_t>(out_flags)); } -static void SvcWrap_GetResourceLimitLimitValue64From32(Core::System& system) { +static void SvcWrap_GetResourceLimitLimitValue64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int64_t out_limit_value{}; Handle resource_limit_handle{}; LimitableResource which{}; - resource_limit_handle = Convert<Handle>(GetReg32(system, 1)); - which = Convert<LimitableResource>(GetReg32(system, 2)); + resource_limit_handle = Convert<Handle>(GetArg32(args, 1)); + which = Convert<LimitableResource>(GetArg32(args, 2)); ret = GetResourceLimitLimitValue64From32(system, std::addressof(out_limit_value), resource_limit_handle, which); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); auto out_limit_value_scatter = Convert<std::array<uint32_t, 2>>(out_limit_value); - SetReg32(system, 1, out_limit_value_scatter[0]); - SetReg32(system, 2, out_limit_value_scatter[1]); + SetArg32(args, 1, out_limit_value_scatter[0]); + SetArg32(args, 2, out_limit_value_scatter[1]); } -static void SvcWrap_GetResourceLimitCurrentValue64From32(Core::System& system) { +static void SvcWrap_GetResourceLimitCurrentValue64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int64_t out_current_value{}; Handle resource_limit_handle{}; LimitableResource which{}; - resource_limit_handle = Convert<Handle>(GetReg32(system, 1)); - which = Convert<LimitableResource>(GetReg32(system, 2)); + resource_limit_handle = Convert<Handle>(GetArg32(args, 1)); + which = Convert<LimitableResource>(GetArg32(args, 2)); ret = GetResourceLimitCurrentValue64From32(system, std::addressof(out_current_value), resource_limit_handle, which); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); auto out_current_value_scatter = Convert<std::array<uint32_t, 2>>(out_current_value); - SetReg32(system, 1, out_current_value_scatter[0]); - SetReg32(system, 2, out_current_value_scatter[1]); + SetArg32(args, 1, out_current_value_scatter[0]); + SetArg32(args, 2, out_current_value_scatter[1]); } -static void SvcWrap_SetThreadActivity64From32(Core::System& system) { +static void SvcWrap_SetThreadActivity64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle thread_handle{}; ThreadActivity thread_activity{}; - thread_handle = Convert<Handle>(GetReg32(system, 0)); - thread_activity = Convert<ThreadActivity>(GetReg32(system, 1)); + thread_handle = Convert<Handle>(GetArg32(args, 0)); + thread_activity = Convert<ThreadActivity>(GetArg32(args, 1)); ret = SetThreadActivity64From32(system, thread_handle, thread_activity); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_GetThreadContext364From32(Core::System& system) { +static void SvcWrap_GetThreadContext364From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t out_context{}; Handle thread_handle{}; - out_context = Convert<uint32_t>(GetReg32(system, 0)); - thread_handle = Convert<Handle>(GetReg32(system, 1)); + out_context = Convert<uint32_t>(GetArg32(args, 0)); + thread_handle = Convert<Handle>(GetArg32(args, 1)); ret = GetThreadContext364From32(system, out_context, thread_handle); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_WaitForAddress64From32(Core::System& system) { +static void SvcWrap_WaitForAddress64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t address{}; @@ -816,20 +816,20 @@ static void SvcWrap_WaitForAddress64From32(Core::System& system) { int32_t value{}; int64_t timeout_ns{}; - address = Convert<uint32_t>(GetReg32(system, 0)); - arb_type = Convert<ArbitrationType>(GetReg32(system, 1)); - value = Convert<int32_t>(GetReg32(system, 2)); + address = Convert<uint32_t>(GetArg32(args, 0)); + arb_type = Convert<ArbitrationType>(GetArg32(args, 1)); + value = Convert<int32_t>(GetArg32(args, 2)); std::array<uint32_t, 2> timeout_ns_gather{}; - timeout_ns_gather[0] = GetReg32(system, 3); - timeout_ns_gather[1] = GetReg32(system, 4); + timeout_ns_gather[0] = GetArg32(args, 3); + timeout_ns_gather[1] = GetArg32(args, 4); timeout_ns = Convert<int64_t>(timeout_ns_gather); ret = WaitForAddress64From32(system, address, arb_type, value, timeout_ns); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_SignalToAddress64From32(Core::System& system) { +static void SvcWrap_SignalToAddress64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t address{}; @@ -837,53 +837,53 @@ static void SvcWrap_SignalToAddress64From32(Core::System& system) { int32_t value{}; int32_t count{}; - address = Convert<uint32_t>(GetReg32(system, 0)); - signal_type = Convert<SignalType>(GetReg32(system, 1)); - value = Convert<int32_t>(GetReg32(system, 2)); - count = Convert<int32_t>(GetReg32(system, 3)); + address = Convert<uint32_t>(GetArg32(args, 0)); + signal_type = Convert<SignalType>(GetArg32(args, 1)); + value = Convert<int32_t>(GetArg32(args, 2)); + count = Convert<int32_t>(GetArg32(args, 3)); ret = SignalToAddress64From32(system, address, signal_type, value, count); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_SynchronizePreemptionState64From32(Core::System& system) { +static void SvcWrap_SynchronizePreemptionState64From32(Core::System& system, std::span<uint64_t, 8> args) { SynchronizePreemptionState64From32(system); } -static void SvcWrap_GetResourceLimitPeakValue64From32(Core::System& system) { +static void SvcWrap_GetResourceLimitPeakValue64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int64_t out_peak_value{}; Handle resource_limit_handle{}; LimitableResource which{}; - resource_limit_handle = Convert<Handle>(GetReg32(system, 1)); - which = Convert<LimitableResource>(GetReg32(system, 2)); + resource_limit_handle = Convert<Handle>(GetArg32(args, 1)); + which = Convert<LimitableResource>(GetArg32(args, 2)); ret = GetResourceLimitPeakValue64From32(system, std::addressof(out_peak_value), resource_limit_handle, which); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); auto out_peak_value_scatter = Convert<std::array<uint32_t, 2>>(out_peak_value); - SetReg32(system, 1, out_peak_value_scatter[0]); - SetReg32(system, 2, out_peak_value_scatter[1]); + SetArg32(args, 1, out_peak_value_scatter[0]); + SetArg32(args, 2, out_peak_value_scatter[1]); } -static void SvcWrap_CreateIoPool64From32(Core::System& system) { +static void SvcWrap_CreateIoPool64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; IoPoolType which{}; - which = Convert<IoPoolType>(GetReg32(system, 1)); + which = Convert<IoPoolType>(GetArg32(args, 1)); ret = CreateIoPool64From32(system, std::addressof(out_handle), which); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_handle)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_handle)); } -static void SvcWrap_CreateIoRegion64From32(Core::System& system) { +static void SvcWrap_CreateIoRegion64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; @@ -893,53 +893,53 @@ static void SvcWrap_CreateIoRegion64From32(Core::System& system) { MemoryMapping mapping{}; MemoryPermission perm{}; - io_pool = Convert<Handle>(GetReg32(system, 1)); + io_pool = Convert<Handle>(GetArg32(args, 1)); std::array<uint32_t, 2> physical_address_gather{}; - physical_address_gather[0] = GetReg32(system, 2); - physical_address_gather[1] = GetReg32(system, 3); + physical_address_gather[0] = GetArg32(args, 2); + physical_address_gather[1] = GetArg32(args, 3); physical_address = Convert<uint64_t>(physical_address_gather); - size = Convert<uint32_t>(GetReg32(system, 0)); - mapping = Convert<MemoryMapping>(GetReg32(system, 4)); - perm = Convert<MemoryPermission>(GetReg32(system, 5)); + size = Convert<uint32_t>(GetArg32(args, 0)); + mapping = Convert<MemoryMapping>(GetArg32(args, 4)); + perm = Convert<MemoryPermission>(GetArg32(args, 5)); ret = CreateIoRegion64From32(system, std::addressof(out_handle), io_pool, physical_address, size, mapping, perm); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_handle)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_handle)); } -static void SvcWrap_KernelDebug64From32(Core::System& system) { +static void SvcWrap_KernelDebug64From32(Core::System& system, std::span<uint64_t, 8> args) { KernelDebugType kern_debug_type{}; uint64_t arg0{}; uint64_t arg1{}; uint64_t arg2{}; - kern_debug_type = Convert<KernelDebugType>(GetReg32(system, 0)); + kern_debug_type = Convert<KernelDebugType>(GetArg32(args, 0)); std::array<uint32_t, 2> arg0_gather{}; - arg0_gather[0] = GetReg32(system, 2); - arg0_gather[1] = GetReg32(system, 3); + arg0_gather[0] = GetArg32(args, 2); + arg0_gather[1] = GetArg32(args, 3); arg0 = Convert<uint64_t>(arg0_gather); std::array<uint32_t, 2> arg1_gather{}; - arg1_gather[0] = GetReg32(system, 1); - arg1_gather[1] = GetReg32(system, 4); + arg1_gather[0] = GetArg32(args, 1); + arg1_gather[1] = GetArg32(args, 4); arg1 = Convert<uint64_t>(arg1_gather); std::array<uint32_t, 2> arg2_gather{}; - arg2_gather[0] = GetReg32(system, 5); - arg2_gather[1] = GetReg32(system, 6); + arg2_gather[0] = GetArg32(args, 5); + arg2_gather[1] = GetArg32(args, 6); arg2 = Convert<uint64_t>(arg2_gather); KernelDebug64From32(system, kern_debug_type, arg0, arg1, arg2); } -static void SvcWrap_ChangeKernelTraceState64From32(Core::System& system) { +static void SvcWrap_ChangeKernelTraceState64From32(Core::System& system, std::span<uint64_t, 8> args) { KernelTraceState kern_trace_state{}; - kern_trace_state = Convert<KernelTraceState>(GetReg32(system, 0)); + kern_trace_state = Convert<KernelTraceState>(GetArg32(args, 0)); ChangeKernelTraceState64From32(system, kern_trace_state); } -static void SvcWrap_CreateSession64From32(Core::System& system) { +static void SvcWrap_CreateSession64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_server_session_handle{}; @@ -947,31 +947,31 @@ static void SvcWrap_CreateSession64From32(Core::System& system) { bool is_light{}; uint32_t name{}; - is_light = Convert<bool>(GetReg32(system, 2)); - name = Convert<uint32_t>(GetReg32(system, 3)); + is_light = Convert<bool>(GetArg32(args, 2)); + name = Convert<uint32_t>(GetArg32(args, 3)); ret = CreateSession64From32(system, std::addressof(out_server_session_handle), std::addressof(out_client_session_handle), is_light, name); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_server_session_handle)); - SetReg32(system, 2, Convert<uint32_t>(out_client_session_handle)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_server_session_handle)); + SetArg32(args, 2, Convert<uint32_t>(out_client_session_handle)); } -static void SvcWrap_AcceptSession64From32(Core::System& system) { +static void SvcWrap_AcceptSession64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; Handle port{}; - port = Convert<Handle>(GetReg32(system, 1)); + port = Convert<Handle>(GetArg32(args, 1)); ret = AcceptSession64From32(system, std::addressof(out_handle), port); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_handle)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_handle)); } -static void SvcWrap_ReplyAndReceive64From32(Core::System& system) { +static void SvcWrap_ReplyAndReceive64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int32_t out_index{}; @@ -980,21 +980,21 @@ static void SvcWrap_ReplyAndReceive64From32(Core::System& system) { Handle reply_target{}; int64_t timeout_ns{}; - handles = Convert<uint32_t>(GetReg32(system, 1)); - num_handles = Convert<int32_t>(GetReg32(system, 2)); - reply_target = Convert<Handle>(GetReg32(system, 3)); + handles = Convert<uint32_t>(GetArg32(args, 1)); + num_handles = Convert<int32_t>(GetArg32(args, 2)); + reply_target = Convert<Handle>(GetArg32(args, 3)); std::array<uint32_t, 2> timeout_ns_gather{}; - timeout_ns_gather[0] = GetReg32(system, 0); - timeout_ns_gather[1] = GetReg32(system, 4); + timeout_ns_gather[0] = GetArg32(args, 0); + timeout_ns_gather[1] = GetArg32(args, 4); timeout_ns = Convert<int64_t>(timeout_ns_gather); ret = ReplyAndReceive64From32(system, std::addressof(out_index), handles, num_handles, reply_target, timeout_ns); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_index)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_index)); } -static void SvcWrap_ReplyAndReceiveWithUserBuffer64From32(Core::System& system) { +static void SvcWrap_ReplyAndReceiveWithUserBuffer64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int32_t out_index{}; @@ -1005,23 +1005,23 @@ static void SvcWrap_ReplyAndReceiveWithUserBuffer64From32(Core::System& system) Handle reply_target{}; int64_t timeout_ns{}; - message_buffer = Convert<uint32_t>(GetReg32(system, 1)); - message_buffer_size = Convert<uint32_t>(GetReg32(system, 2)); - handles = Convert<uint32_t>(GetReg32(system, 3)); - num_handles = Convert<int32_t>(GetReg32(system, 0)); - reply_target = Convert<Handle>(GetReg32(system, 4)); + message_buffer = Convert<uint32_t>(GetArg32(args, 1)); + message_buffer_size = Convert<uint32_t>(GetArg32(args, 2)); + handles = Convert<uint32_t>(GetArg32(args, 3)); + num_handles = Convert<int32_t>(GetArg32(args, 0)); + reply_target = Convert<Handle>(GetArg32(args, 4)); std::array<uint32_t, 2> timeout_ns_gather{}; - timeout_ns_gather[0] = GetReg32(system, 5); - timeout_ns_gather[1] = GetReg32(system, 6); + timeout_ns_gather[0] = GetArg32(args, 5); + timeout_ns_gather[1] = GetArg32(args, 6); timeout_ns = Convert<int64_t>(timeout_ns_gather); ret = ReplyAndReceiveWithUserBuffer64From32(system, std::addressof(out_index), message_buffer, message_buffer_size, handles, num_handles, reply_target, timeout_ns); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_index)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_index)); } -static void SvcWrap_CreateEvent64From32(Core::System& system) { +static void SvcWrap_CreateEvent64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_write_handle{}; @@ -1029,12 +1029,12 @@ static void SvcWrap_CreateEvent64From32(Core::System& system) { ret = CreateEvent64From32(system, std::addressof(out_write_handle), std::addressof(out_read_handle)); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_write_handle)); - SetReg32(system, 2, Convert<uint32_t>(out_read_handle)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_write_handle)); + SetArg32(args, 2, Convert<uint32_t>(out_read_handle)); } -static void SvcWrap_MapIoRegion64From32(Core::System& system) { +static void SvcWrap_MapIoRegion64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle io_region{}; @@ -1042,89 +1042,89 @@ static void SvcWrap_MapIoRegion64From32(Core::System& system) { uint32_t size{}; MemoryPermission perm{}; - io_region = Convert<Handle>(GetReg32(system, 0)); - address = Convert<uint32_t>(GetReg32(system, 1)); - size = Convert<uint32_t>(GetReg32(system, 2)); - perm = Convert<MemoryPermission>(GetReg32(system, 3)); + io_region = Convert<Handle>(GetArg32(args, 0)); + address = Convert<uint32_t>(GetArg32(args, 1)); + size = Convert<uint32_t>(GetArg32(args, 2)); + perm = Convert<MemoryPermission>(GetArg32(args, 3)); ret = MapIoRegion64From32(system, io_region, address, size, perm); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_UnmapIoRegion64From32(Core::System& system) { +static void SvcWrap_UnmapIoRegion64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle io_region{}; uint32_t address{}; uint32_t size{}; - io_region = Convert<Handle>(GetReg32(system, 0)); - address = Convert<uint32_t>(GetReg32(system, 1)); - size = Convert<uint32_t>(GetReg32(system, 2)); + io_region = Convert<Handle>(GetArg32(args, 0)); + address = Convert<uint32_t>(GetArg32(args, 1)); + size = Convert<uint32_t>(GetArg32(args, 2)); ret = UnmapIoRegion64From32(system, io_region, address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_MapPhysicalMemoryUnsafe64From32(Core::System& system) { +static void SvcWrap_MapPhysicalMemoryUnsafe64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t address{}; uint32_t size{}; - address = Convert<uint32_t>(GetReg32(system, 0)); - size = Convert<uint32_t>(GetReg32(system, 1)); + address = Convert<uint32_t>(GetArg32(args, 0)); + size = Convert<uint32_t>(GetArg32(args, 1)); ret = MapPhysicalMemoryUnsafe64From32(system, address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_UnmapPhysicalMemoryUnsafe64From32(Core::System& system) { +static void SvcWrap_UnmapPhysicalMemoryUnsafe64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t address{}; uint32_t size{}; - address = Convert<uint32_t>(GetReg32(system, 0)); - size = Convert<uint32_t>(GetReg32(system, 1)); + address = Convert<uint32_t>(GetArg32(args, 0)); + size = Convert<uint32_t>(GetArg32(args, 1)); ret = UnmapPhysicalMemoryUnsafe64From32(system, address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_SetUnsafeLimit64From32(Core::System& system) { +static void SvcWrap_SetUnsafeLimit64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t limit{}; - limit = Convert<uint32_t>(GetReg32(system, 0)); + limit = Convert<uint32_t>(GetArg32(args, 0)); ret = SetUnsafeLimit64From32(system, limit); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_CreateCodeMemory64From32(Core::System& system) { +static void SvcWrap_CreateCodeMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; uint32_t address{}; uint32_t size{}; - address = Convert<uint32_t>(GetReg32(system, 1)); - size = Convert<uint32_t>(GetReg32(system, 2)); + address = Convert<uint32_t>(GetArg32(args, 1)); + size = Convert<uint32_t>(GetArg32(args, 2)); ret = CreateCodeMemory64From32(system, std::addressof(out_handle), address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_handle)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_handle)); } -static void SvcWrap_ControlCodeMemory64From32(Core::System& system) { +static void SvcWrap_ControlCodeMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle code_memory_handle{}; @@ -1133,28 +1133,28 @@ static void SvcWrap_ControlCodeMemory64From32(Core::System& system) { uint64_t size{}; MemoryPermission perm{}; - code_memory_handle = Convert<Handle>(GetReg32(system, 0)); - operation = Convert<CodeMemoryOperation>(GetReg32(system, 1)); + code_memory_handle = Convert<Handle>(GetArg32(args, 0)); + operation = Convert<CodeMemoryOperation>(GetArg32(args, 1)); std::array<uint32_t, 2> address_gather{}; - address_gather[0] = GetReg32(system, 2); - address_gather[1] = GetReg32(system, 3); + address_gather[0] = GetArg32(args, 2); + address_gather[1] = GetArg32(args, 3); address = Convert<uint64_t>(address_gather); std::array<uint32_t, 2> size_gather{}; - size_gather[0] = GetReg32(system, 4); - size_gather[1] = GetReg32(system, 5); + size_gather[0] = GetArg32(args, 4); + size_gather[1] = GetArg32(args, 5); size = Convert<uint64_t>(size_gather); - perm = Convert<MemoryPermission>(GetReg32(system, 6)); + perm = Convert<MemoryPermission>(GetArg32(args, 6)); ret = ControlCodeMemory64From32(system, code_memory_handle, operation, address, size, perm); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_SleepSystem64From32(Core::System& system) { +static void SvcWrap_SleepSystem64From32(Core::System& system, std::span<uint64_t, 8> args) { SleepSystem64From32(system); } -static void SvcWrap_ReadWriteRegister64From32(Core::System& system) { +static void SvcWrap_ReadWriteRegister64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t out_value{}; @@ -1163,33 +1163,33 @@ static void SvcWrap_ReadWriteRegister64From32(Core::System& system) { uint32_t value{}; std::array<uint32_t, 2> address_gather{}; - address_gather[0] = GetReg32(system, 2); - address_gather[1] = GetReg32(system, 3); + address_gather[0] = GetArg32(args, 2); + address_gather[1] = GetArg32(args, 3); address = Convert<uint64_t>(address_gather); - mask = Convert<uint32_t>(GetReg32(system, 0)); - value = Convert<uint32_t>(GetReg32(system, 1)); + mask = Convert<uint32_t>(GetArg32(args, 0)); + value = Convert<uint32_t>(GetArg32(args, 1)); ret = ReadWriteRegister64From32(system, std::addressof(out_value), address, mask, value); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_value)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_value)); } -static void SvcWrap_SetProcessActivity64From32(Core::System& system) { +static void SvcWrap_SetProcessActivity64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle process_handle{}; ProcessActivity process_activity{}; - process_handle = Convert<Handle>(GetReg32(system, 0)); - process_activity = Convert<ProcessActivity>(GetReg32(system, 1)); + process_handle = Convert<Handle>(GetArg32(args, 0)); + process_activity = Convert<ProcessActivity>(GetArg32(args, 1)); ret = SetProcessActivity64From32(system, process_handle, process_activity); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_CreateSharedMemory64From32(Core::System& system) { +static void SvcWrap_CreateSharedMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; @@ -1197,17 +1197,17 @@ static void SvcWrap_CreateSharedMemory64From32(Core::System& system) { MemoryPermission owner_perm{}; MemoryPermission remote_perm{}; - size = Convert<uint32_t>(GetReg32(system, 1)); - owner_perm = Convert<MemoryPermission>(GetReg32(system, 2)); - remote_perm = Convert<MemoryPermission>(GetReg32(system, 3)); + size = Convert<uint32_t>(GetArg32(args, 1)); + owner_perm = Convert<MemoryPermission>(GetArg32(args, 2)); + remote_perm = Convert<MemoryPermission>(GetArg32(args, 3)); ret = CreateSharedMemory64From32(system, std::addressof(out_handle), size, owner_perm, remote_perm); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_handle)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_handle)); } -static void SvcWrap_MapTransferMemory64From32(Core::System& system) { +static void SvcWrap_MapTransferMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle trmem_handle{}; @@ -1215,67 +1215,67 @@ static void SvcWrap_MapTransferMemory64From32(Core::System& system) { uint32_t size{}; MemoryPermission owner_perm{}; - trmem_handle = Convert<Handle>(GetReg32(system, 0)); - address = Convert<uint32_t>(GetReg32(system, 1)); - size = Convert<uint32_t>(GetReg32(system, 2)); - owner_perm = Convert<MemoryPermission>(GetReg32(system, 3)); + trmem_handle = Convert<Handle>(GetArg32(args, 0)); + address = Convert<uint32_t>(GetArg32(args, 1)); + size = Convert<uint32_t>(GetArg32(args, 2)); + owner_perm = Convert<MemoryPermission>(GetArg32(args, 3)); ret = MapTransferMemory64From32(system, trmem_handle, address, size, owner_perm); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_UnmapTransferMemory64From32(Core::System& system) { +static void SvcWrap_UnmapTransferMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle trmem_handle{}; uint32_t address{}; uint32_t size{}; - trmem_handle = Convert<Handle>(GetReg32(system, 0)); - address = Convert<uint32_t>(GetReg32(system, 1)); - size = Convert<uint32_t>(GetReg32(system, 2)); + trmem_handle = Convert<Handle>(GetArg32(args, 0)); + address = Convert<uint32_t>(GetArg32(args, 1)); + size = Convert<uint32_t>(GetArg32(args, 2)); ret = UnmapTransferMemory64From32(system, trmem_handle, address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_CreateInterruptEvent64From32(Core::System& system) { +static void SvcWrap_CreateInterruptEvent64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_read_handle{}; int32_t interrupt_id{}; InterruptType interrupt_type{}; - interrupt_id = Convert<int32_t>(GetReg32(system, 1)); - interrupt_type = Convert<InterruptType>(GetReg32(system, 2)); + interrupt_id = Convert<int32_t>(GetArg32(args, 1)); + interrupt_type = Convert<InterruptType>(GetArg32(args, 2)); ret = CreateInterruptEvent64From32(system, std::addressof(out_read_handle), interrupt_id, interrupt_type); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_read_handle)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_read_handle)); } -static void SvcWrap_QueryPhysicalAddress64From32(Core::System& system) { +static void SvcWrap_QueryPhysicalAddress64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; ilp32::PhysicalMemoryInfo out_info{}; uint32_t address{}; - address = Convert<uint32_t>(GetReg32(system, 1)); + address = Convert<uint32_t>(GetArg32(args, 1)); ret = QueryPhysicalAddress64From32(system, std::addressof(out_info), address); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); auto out_info_scatter = Convert<std::array<uint32_t, 4>>(out_info); - SetReg32(system, 1, out_info_scatter[0]); - SetReg32(system, 2, out_info_scatter[1]); - SetReg32(system, 3, out_info_scatter[2]); - SetReg32(system, 4, out_info_scatter[3]); + SetArg32(args, 1, out_info_scatter[0]); + SetArg32(args, 2, out_info_scatter[1]); + SetArg32(args, 3, out_info_scatter[2]); + SetArg32(args, 4, out_info_scatter[3]); } -static void SvcWrap_QueryIoMapping64From32(Core::System& system) { +static void SvcWrap_QueryIoMapping64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t out_address{}; @@ -1284,19 +1284,19 @@ static void SvcWrap_QueryIoMapping64From32(Core::System& system) { uint32_t size{}; std::array<uint32_t, 2> physical_address_gather{}; - physical_address_gather[0] = GetReg32(system, 2); - physical_address_gather[1] = GetReg32(system, 3); + physical_address_gather[0] = GetArg32(args, 2); + physical_address_gather[1] = GetArg32(args, 3); physical_address = Convert<uint64_t>(physical_address_gather); - size = Convert<uint32_t>(GetReg32(system, 0)); + size = Convert<uint32_t>(GetArg32(args, 0)); ret = QueryIoMapping64From32(system, std::addressof(out_address), std::addressof(out_size), physical_address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_address)); - SetReg32(system, 2, Convert<uint32_t>(out_size)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_address)); + SetArg32(args, 2, Convert<uint32_t>(out_size)); } -static void SvcWrap_CreateDeviceAddressSpace64From32(Core::System& system) { +static void SvcWrap_CreateDeviceAddressSpace64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; @@ -1304,49 +1304,49 @@ static void SvcWrap_CreateDeviceAddressSpace64From32(Core::System& system) { uint64_t das_size{}; std::array<uint32_t, 2> das_address_gather{}; - das_address_gather[0] = GetReg32(system, 2); - das_address_gather[1] = GetReg32(system, 3); + das_address_gather[0] = GetArg32(args, 2); + das_address_gather[1] = GetArg32(args, 3); das_address = Convert<uint64_t>(das_address_gather); std::array<uint32_t, 2> das_size_gather{}; - das_size_gather[0] = GetReg32(system, 0); - das_size_gather[1] = GetReg32(system, 1); + das_size_gather[0] = GetArg32(args, 0); + das_size_gather[1] = GetArg32(args, 1); das_size = Convert<uint64_t>(das_size_gather); ret = CreateDeviceAddressSpace64From32(system, std::addressof(out_handle), das_address, das_size); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_handle)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_handle)); } -static void SvcWrap_AttachDeviceAddressSpace64From32(Core::System& system) { +static void SvcWrap_AttachDeviceAddressSpace64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; DeviceName device_name{}; Handle das_handle{}; - device_name = Convert<DeviceName>(GetReg32(system, 0)); - das_handle = Convert<Handle>(GetReg32(system, 1)); + device_name = Convert<DeviceName>(GetArg32(args, 0)); + das_handle = Convert<Handle>(GetArg32(args, 1)); ret = AttachDeviceAddressSpace64From32(system, device_name, das_handle); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_DetachDeviceAddressSpace64From32(Core::System& system) { +static void SvcWrap_DetachDeviceAddressSpace64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; DeviceName device_name{}; Handle das_handle{}; - device_name = Convert<DeviceName>(GetReg32(system, 0)); - das_handle = Convert<Handle>(GetReg32(system, 1)); + device_name = Convert<DeviceName>(GetArg32(args, 0)); + das_handle = Convert<Handle>(GetArg32(args, 1)); ret = DetachDeviceAddressSpace64From32(system, device_name, das_handle); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_MapDeviceAddressSpaceByForce64From32(Core::System& system) { +static void SvcWrap_MapDeviceAddressSpaceByForce64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle das_handle{}; @@ -1356,25 +1356,25 @@ static void SvcWrap_MapDeviceAddressSpaceByForce64From32(Core::System& system) { uint64_t device_address{}; uint32_t option{}; - das_handle = Convert<Handle>(GetReg32(system, 0)); - process_handle = Convert<Handle>(GetReg32(system, 1)); + das_handle = Convert<Handle>(GetArg32(args, 0)); + process_handle = Convert<Handle>(GetArg32(args, 1)); std::array<uint32_t, 2> process_address_gather{}; - process_address_gather[0] = GetReg32(system, 2); - process_address_gather[1] = GetReg32(system, 3); + process_address_gather[0] = GetArg32(args, 2); + process_address_gather[1] = GetArg32(args, 3); process_address = Convert<uint64_t>(process_address_gather); - size = Convert<uint32_t>(GetReg32(system, 4)); + size = Convert<uint32_t>(GetArg32(args, 4)); std::array<uint32_t, 2> device_address_gather{}; - device_address_gather[0] = GetReg32(system, 5); - device_address_gather[1] = GetReg32(system, 6); + device_address_gather[0] = GetArg32(args, 5); + device_address_gather[1] = GetArg32(args, 6); device_address = Convert<uint64_t>(device_address_gather); - option = Convert<uint32_t>(GetReg32(system, 7)); + option = Convert<uint32_t>(GetArg32(args, 7)); ret = MapDeviceAddressSpaceByForce64From32(system, das_handle, process_handle, process_address, size, device_address, option); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_MapDeviceAddressSpaceAligned64From32(Core::System& system) { +static void SvcWrap_MapDeviceAddressSpaceAligned64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle das_handle{}; @@ -1384,25 +1384,25 @@ static void SvcWrap_MapDeviceAddressSpaceAligned64From32(Core::System& system) { uint64_t device_address{}; uint32_t option{}; - das_handle = Convert<Handle>(GetReg32(system, 0)); - process_handle = Convert<Handle>(GetReg32(system, 1)); + das_handle = Convert<Handle>(GetArg32(args, 0)); + process_handle = Convert<Handle>(GetArg32(args, 1)); std::array<uint32_t, 2> process_address_gather{}; - process_address_gather[0] = GetReg32(system, 2); - process_address_gather[1] = GetReg32(system, 3); + process_address_gather[0] = GetArg32(args, 2); + process_address_gather[1] = GetArg32(args, 3); process_address = Convert<uint64_t>(process_address_gather); - size = Convert<uint32_t>(GetReg32(system, 4)); + size = Convert<uint32_t>(GetArg32(args, 4)); std::array<uint32_t, 2> device_address_gather{}; - device_address_gather[0] = GetReg32(system, 5); - device_address_gather[1] = GetReg32(system, 6); + device_address_gather[0] = GetArg32(args, 5); + device_address_gather[1] = GetArg32(args, 6); device_address = Convert<uint64_t>(device_address_gather); - option = Convert<uint32_t>(GetReg32(system, 7)); + option = Convert<uint32_t>(GetArg32(args, 7)); ret = MapDeviceAddressSpaceAligned64From32(system, das_handle, process_handle, process_address, size, device_address, option); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_UnmapDeviceAddressSpace64From32(Core::System& system) { +static void SvcWrap_UnmapDeviceAddressSpace64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle das_handle{}; @@ -1411,145 +1411,145 @@ static void SvcWrap_UnmapDeviceAddressSpace64From32(Core::System& system) { uint32_t size{}; uint64_t device_address{}; - das_handle = Convert<Handle>(GetReg32(system, 0)); - process_handle = Convert<Handle>(GetReg32(system, 1)); + das_handle = Convert<Handle>(GetArg32(args, 0)); + process_handle = Convert<Handle>(GetArg32(args, 1)); std::array<uint32_t, 2> process_address_gather{}; - process_address_gather[0] = GetReg32(system, 2); - process_address_gather[1] = GetReg32(system, 3); + process_address_gather[0] = GetArg32(args, 2); + process_address_gather[1] = GetArg32(args, 3); process_address = Convert<uint64_t>(process_address_gather); - size = Convert<uint32_t>(GetReg32(system, 4)); + size = Convert<uint32_t>(GetArg32(args, 4)); std::array<uint32_t, 2> device_address_gather{}; - device_address_gather[0] = GetReg32(system, 5); - device_address_gather[1] = GetReg32(system, 6); + device_address_gather[0] = GetArg32(args, 5); + device_address_gather[1] = GetArg32(args, 6); device_address = Convert<uint64_t>(device_address_gather); ret = UnmapDeviceAddressSpace64From32(system, das_handle, process_handle, process_address, size, device_address); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_InvalidateProcessDataCache64From32(Core::System& system) { +static void SvcWrap_InvalidateProcessDataCache64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle process_handle{}; uint64_t address{}; uint64_t size{}; - process_handle = Convert<Handle>(GetReg32(system, 0)); + process_handle = Convert<Handle>(GetArg32(args, 0)); std::array<uint32_t, 2> address_gather{}; - address_gather[0] = GetReg32(system, 2); - address_gather[1] = GetReg32(system, 3); + address_gather[0] = GetArg32(args, 2); + address_gather[1] = GetArg32(args, 3); address = Convert<uint64_t>(address_gather); std::array<uint32_t, 2> size_gather{}; - size_gather[0] = GetReg32(system, 1); - size_gather[1] = GetReg32(system, 4); + size_gather[0] = GetArg32(args, 1); + size_gather[1] = GetArg32(args, 4); size = Convert<uint64_t>(size_gather); ret = InvalidateProcessDataCache64From32(system, process_handle, address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_StoreProcessDataCache64From32(Core::System& system) { +static void SvcWrap_StoreProcessDataCache64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle process_handle{}; uint64_t address{}; uint64_t size{}; - process_handle = Convert<Handle>(GetReg32(system, 0)); + process_handle = Convert<Handle>(GetArg32(args, 0)); std::array<uint32_t, 2> address_gather{}; - address_gather[0] = GetReg32(system, 2); - address_gather[1] = GetReg32(system, 3); + address_gather[0] = GetArg32(args, 2); + address_gather[1] = GetArg32(args, 3); address = Convert<uint64_t>(address_gather); std::array<uint32_t, 2> size_gather{}; - size_gather[0] = GetReg32(system, 1); - size_gather[1] = GetReg32(system, 4); + size_gather[0] = GetArg32(args, 1); + size_gather[1] = GetArg32(args, 4); size = Convert<uint64_t>(size_gather); ret = StoreProcessDataCache64From32(system, process_handle, address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_FlushProcessDataCache64From32(Core::System& system) { +static void SvcWrap_FlushProcessDataCache64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle process_handle{}; uint64_t address{}; uint64_t size{}; - process_handle = Convert<Handle>(GetReg32(system, 0)); + process_handle = Convert<Handle>(GetArg32(args, 0)); std::array<uint32_t, 2> address_gather{}; - address_gather[0] = GetReg32(system, 2); - address_gather[1] = GetReg32(system, 3); + address_gather[0] = GetArg32(args, 2); + address_gather[1] = GetArg32(args, 3); address = Convert<uint64_t>(address_gather); std::array<uint32_t, 2> size_gather{}; - size_gather[0] = GetReg32(system, 1); - size_gather[1] = GetReg32(system, 4); + size_gather[0] = GetArg32(args, 1); + size_gather[1] = GetArg32(args, 4); size = Convert<uint64_t>(size_gather); ret = FlushProcessDataCache64From32(system, process_handle, address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_DebugActiveProcess64From32(Core::System& system) { +static void SvcWrap_DebugActiveProcess64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; uint64_t process_id{}; std::array<uint32_t, 2> process_id_gather{}; - process_id_gather[0] = GetReg32(system, 2); - process_id_gather[1] = GetReg32(system, 3); + process_id_gather[0] = GetArg32(args, 2); + process_id_gather[1] = GetArg32(args, 3); process_id = Convert<uint64_t>(process_id_gather); ret = DebugActiveProcess64From32(system, std::addressof(out_handle), process_id); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_handle)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_handle)); } -static void SvcWrap_BreakDebugProcess64From32(Core::System& system) { +static void SvcWrap_BreakDebugProcess64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle debug_handle{}; - debug_handle = Convert<Handle>(GetReg32(system, 0)); + debug_handle = Convert<Handle>(GetArg32(args, 0)); ret = BreakDebugProcess64From32(system, debug_handle); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_TerminateDebugProcess64From32(Core::System& system) { +static void SvcWrap_TerminateDebugProcess64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle debug_handle{}; - debug_handle = Convert<Handle>(GetReg32(system, 0)); + debug_handle = Convert<Handle>(GetArg32(args, 0)); ret = TerminateDebugProcess64From32(system, debug_handle); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_GetDebugEvent64From32(Core::System& system) { +static void SvcWrap_GetDebugEvent64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t out_info{}; Handle debug_handle{}; - out_info = Convert<uint32_t>(GetReg32(system, 0)); - debug_handle = Convert<Handle>(GetReg32(system, 1)); + out_info = Convert<uint32_t>(GetArg32(args, 0)); + debug_handle = Convert<Handle>(GetArg32(args, 1)); ret = GetDebugEvent64From32(system, out_info, debug_handle); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_ContinueDebugEvent64From32(Core::System& system) { +static void SvcWrap_ContinueDebugEvent64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle debug_handle{}; @@ -1557,33 +1557,33 @@ static void SvcWrap_ContinueDebugEvent64From32(Core::System& system) { uint32_t thread_ids{}; int32_t num_thread_ids{}; - debug_handle = Convert<Handle>(GetReg32(system, 0)); - flags = Convert<uint32_t>(GetReg32(system, 1)); - thread_ids = Convert<uint32_t>(GetReg32(system, 2)); - num_thread_ids = Convert<int32_t>(GetReg32(system, 3)); + debug_handle = Convert<Handle>(GetArg32(args, 0)); + flags = Convert<uint32_t>(GetArg32(args, 1)); + thread_ids = Convert<uint32_t>(GetArg32(args, 2)); + num_thread_ids = Convert<int32_t>(GetArg32(args, 3)); ret = ContinueDebugEvent64From32(system, debug_handle, flags, thread_ids, num_thread_ids); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_GetProcessList64From32(Core::System& system) { +static void SvcWrap_GetProcessList64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int32_t out_num_processes{}; uint32_t out_process_ids{}; int32_t max_out_count{}; - out_process_ids = Convert<uint32_t>(GetReg32(system, 1)); - max_out_count = Convert<int32_t>(GetReg32(system, 2)); + out_process_ids = Convert<uint32_t>(GetArg32(args, 1)); + max_out_count = Convert<int32_t>(GetArg32(args, 2)); ret = GetProcessList64From32(system, std::addressof(out_num_processes), out_process_ids, max_out_count); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_num_processes)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_num_processes)); } -static void SvcWrap_GetThreadList64From32(Core::System& system) { +static void SvcWrap_GetThreadList64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int32_t out_num_threads{}; @@ -1591,17 +1591,17 @@ static void SvcWrap_GetThreadList64From32(Core::System& system) { int32_t max_out_count{}; Handle debug_handle{}; - out_thread_ids = Convert<uint32_t>(GetReg32(system, 1)); - max_out_count = Convert<int32_t>(GetReg32(system, 2)); - debug_handle = Convert<Handle>(GetReg32(system, 3)); + out_thread_ids = Convert<uint32_t>(GetArg32(args, 1)); + max_out_count = Convert<int32_t>(GetArg32(args, 2)); + debug_handle = Convert<Handle>(GetArg32(args, 3)); ret = GetThreadList64From32(system, std::addressof(out_num_threads), out_thread_ids, max_out_count, debug_handle); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_num_threads)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_num_threads)); } -static void SvcWrap_GetDebugThreadContext64From32(Core::System& system) { +static void SvcWrap_GetDebugThreadContext64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t out_context{}; @@ -1609,20 +1609,20 @@ static void SvcWrap_GetDebugThreadContext64From32(Core::System& system) { uint64_t thread_id{}; uint32_t context_flags{}; - out_context = Convert<uint32_t>(GetReg32(system, 0)); - debug_handle = Convert<Handle>(GetReg32(system, 1)); + out_context = Convert<uint32_t>(GetArg32(args, 0)); + debug_handle = Convert<Handle>(GetArg32(args, 1)); std::array<uint32_t, 2> thread_id_gather{}; - thread_id_gather[0] = GetReg32(system, 2); - thread_id_gather[1] = GetReg32(system, 3); + thread_id_gather[0] = GetArg32(args, 2); + thread_id_gather[1] = GetArg32(args, 3); thread_id = Convert<uint64_t>(thread_id_gather); - context_flags = Convert<uint32_t>(GetReg32(system, 4)); + context_flags = Convert<uint32_t>(GetArg32(args, 4)); ret = GetDebugThreadContext64From32(system, out_context, debug_handle, thread_id, context_flags); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_SetDebugThreadContext64From32(Core::System& system) { +static void SvcWrap_SetDebugThreadContext64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle debug_handle{}; @@ -1630,20 +1630,20 @@ static void SvcWrap_SetDebugThreadContext64From32(Core::System& system) { uint32_t context{}; uint32_t context_flags{}; - debug_handle = Convert<Handle>(GetReg32(system, 0)); + debug_handle = Convert<Handle>(GetArg32(args, 0)); std::array<uint32_t, 2> thread_id_gather{}; - thread_id_gather[0] = GetReg32(system, 2); - thread_id_gather[1] = GetReg32(system, 3); + thread_id_gather[0] = GetArg32(args, 2); + thread_id_gather[1] = GetArg32(args, 3); thread_id = Convert<uint64_t>(thread_id_gather); - context = Convert<uint32_t>(GetReg32(system, 1)); - context_flags = Convert<uint32_t>(GetReg32(system, 4)); + context = Convert<uint32_t>(GetArg32(args, 1)); + context_flags = Convert<uint32_t>(GetArg32(args, 4)); ret = SetDebugThreadContext64From32(system, debug_handle, thread_id, context, context_flags); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_QueryDebugProcessMemory64From32(Core::System& system) { +static void SvcWrap_QueryDebugProcessMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; PageInfo out_page_info{}; @@ -1651,17 +1651,17 @@ static void SvcWrap_QueryDebugProcessMemory64From32(Core::System& system) { Handle process_handle{}; uint32_t address{}; - out_memory_info = Convert<uint32_t>(GetReg32(system, 0)); - process_handle = Convert<Handle>(GetReg32(system, 2)); - address = Convert<uint32_t>(GetReg32(system, 3)); + out_memory_info = Convert<uint32_t>(GetArg32(args, 0)); + process_handle = Convert<Handle>(GetArg32(args, 2)); + address = Convert<uint32_t>(GetArg32(args, 3)); ret = QueryDebugProcessMemory64From32(system, out_memory_info, std::addressof(out_page_info), process_handle, address); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_page_info)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_page_info)); } -static void SvcWrap_ReadDebugProcessMemory64From32(Core::System& system) { +static void SvcWrap_ReadDebugProcessMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t buffer{}; @@ -1669,17 +1669,17 @@ static void SvcWrap_ReadDebugProcessMemory64From32(Core::System& system) { uint32_t address{}; uint32_t size{}; - buffer = Convert<uint32_t>(GetReg32(system, 0)); - debug_handle = Convert<Handle>(GetReg32(system, 1)); - address = Convert<uint32_t>(GetReg32(system, 2)); - size = Convert<uint32_t>(GetReg32(system, 3)); + buffer = Convert<uint32_t>(GetArg32(args, 0)); + debug_handle = Convert<Handle>(GetArg32(args, 1)); + address = Convert<uint32_t>(GetArg32(args, 2)); + size = Convert<uint32_t>(GetArg32(args, 3)); ret = ReadDebugProcessMemory64From32(system, buffer, debug_handle, address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_WriteDebugProcessMemory64From32(Core::System& system) { +static void SvcWrap_WriteDebugProcessMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle debug_handle{}; @@ -1687,39 +1687,39 @@ static void SvcWrap_WriteDebugProcessMemory64From32(Core::System& system) { uint32_t address{}; uint32_t size{}; - debug_handle = Convert<Handle>(GetReg32(system, 0)); - buffer = Convert<uint32_t>(GetReg32(system, 1)); - address = Convert<uint32_t>(GetReg32(system, 2)); - size = Convert<uint32_t>(GetReg32(system, 3)); + debug_handle = Convert<Handle>(GetArg32(args, 0)); + buffer = Convert<uint32_t>(GetArg32(args, 1)); + address = Convert<uint32_t>(GetArg32(args, 2)); + size = Convert<uint32_t>(GetArg32(args, 3)); ret = WriteDebugProcessMemory64From32(system, debug_handle, buffer, address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_SetHardwareBreakPoint64From32(Core::System& system) { +static void SvcWrap_SetHardwareBreakPoint64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; HardwareBreakPointRegisterName name{}; uint64_t flags{}; uint64_t value{}; - name = Convert<HardwareBreakPointRegisterName>(GetReg32(system, 0)); + name = Convert<HardwareBreakPointRegisterName>(GetArg32(args, 0)); std::array<uint32_t, 2> flags_gather{}; - flags_gather[0] = GetReg32(system, 2); - flags_gather[1] = GetReg32(system, 3); + flags_gather[0] = GetArg32(args, 2); + flags_gather[1] = GetArg32(args, 3); flags = Convert<uint64_t>(flags_gather); std::array<uint32_t, 2> value_gather{}; - value_gather[0] = GetReg32(system, 1); - value_gather[1] = GetReg32(system, 4); + value_gather[0] = GetArg32(args, 1); + value_gather[1] = GetArg32(args, 4); value = Convert<uint64_t>(value_gather); ret = SetHardwareBreakPoint64From32(system, name, flags, value); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_GetDebugThreadParam64From32(Core::System& system) { +static void SvcWrap_GetDebugThreadParam64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t out_64{}; @@ -1728,23 +1728,23 @@ static void SvcWrap_GetDebugThreadParam64From32(Core::System& system) { uint64_t thread_id{}; DebugThreadParam param{}; - debug_handle = Convert<Handle>(GetReg32(system, 2)); + debug_handle = Convert<Handle>(GetArg32(args, 2)); std::array<uint32_t, 2> thread_id_gather{}; - thread_id_gather[0] = GetReg32(system, 0); - thread_id_gather[1] = GetReg32(system, 1); + thread_id_gather[0] = GetArg32(args, 0); + thread_id_gather[1] = GetArg32(args, 1); thread_id = Convert<uint64_t>(thread_id_gather); - param = Convert<DebugThreadParam>(GetReg32(system, 3)); + param = Convert<DebugThreadParam>(GetArg32(args, 3)); ret = GetDebugThreadParam64From32(system, std::addressof(out_64), std::addressof(out_32), debug_handle, thread_id, param); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); auto out_64_scatter = Convert<std::array<uint32_t, 2>>(out_64); - SetReg32(system, 1, out_64_scatter[0]); - SetReg32(system, 2, out_64_scatter[1]); - SetReg32(system, 3, Convert<uint32_t>(out_32)); + SetArg32(args, 1, out_64_scatter[0]); + SetArg32(args, 2, out_64_scatter[1]); + SetArg32(args, 3, Convert<uint32_t>(out_32)); } -static void SvcWrap_GetSystemInfo64From32(Core::System& system) { +static void SvcWrap_GetSystemInfo64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t out{}; @@ -1752,22 +1752,22 @@ static void SvcWrap_GetSystemInfo64From32(Core::System& system) { Handle handle{}; uint64_t info_subtype{}; - info_type = Convert<SystemInfoType>(GetReg32(system, 1)); - handle = Convert<Handle>(GetReg32(system, 2)); + info_type = Convert<SystemInfoType>(GetArg32(args, 1)); + handle = Convert<Handle>(GetArg32(args, 2)); std::array<uint32_t, 2> info_subtype_gather{}; - info_subtype_gather[0] = GetReg32(system, 0); - info_subtype_gather[1] = GetReg32(system, 3); + info_subtype_gather[0] = GetArg32(args, 0); + info_subtype_gather[1] = GetArg32(args, 3); info_subtype = Convert<uint64_t>(info_subtype_gather); ret = GetSystemInfo64From32(system, std::addressof(out), info_type, handle, info_subtype); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); auto out_scatter = Convert<std::array<uint32_t, 2>>(out); - SetReg32(system, 1, out_scatter[0]); - SetReg32(system, 2, out_scatter[1]); + SetArg32(args, 1, out_scatter[0]); + SetArg32(args, 2, out_scatter[1]); } -static void SvcWrap_CreatePort64From32(Core::System& system) { +static void SvcWrap_CreatePort64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_server_handle{}; @@ -1776,48 +1776,48 @@ static void SvcWrap_CreatePort64From32(Core::System& system) { bool is_light{}; uint32_t name{}; - max_sessions = Convert<int32_t>(GetReg32(system, 2)); - is_light = Convert<bool>(GetReg32(system, 3)); - name = Convert<uint32_t>(GetReg32(system, 0)); + max_sessions = Convert<int32_t>(GetArg32(args, 2)); + is_light = Convert<bool>(GetArg32(args, 3)); + name = Convert<uint32_t>(GetArg32(args, 0)); ret = CreatePort64From32(system, std::addressof(out_server_handle), std::addressof(out_client_handle), max_sessions, is_light, name); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_server_handle)); - SetReg32(system, 2, Convert<uint32_t>(out_client_handle)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_server_handle)); + SetArg32(args, 2, Convert<uint32_t>(out_client_handle)); } -static void SvcWrap_ManageNamedPort64From32(Core::System& system) { +static void SvcWrap_ManageNamedPort64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_server_handle{}; uint32_t name{}; int32_t max_sessions{}; - name = Convert<uint32_t>(GetReg32(system, 1)); - max_sessions = Convert<int32_t>(GetReg32(system, 2)); + name = Convert<uint32_t>(GetArg32(args, 1)); + max_sessions = Convert<int32_t>(GetArg32(args, 2)); ret = ManageNamedPort64From32(system, std::addressof(out_server_handle), name, max_sessions); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_server_handle)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_server_handle)); } -static void SvcWrap_ConnectToPort64From32(Core::System& system) { +static void SvcWrap_ConnectToPort64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; Handle port{}; - port = Convert<Handle>(GetReg32(system, 1)); + port = Convert<Handle>(GetArg32(args, 1)); ret = ConnectToPort64From32(system, std::addressof(out_handle), port); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_handle)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_handle)); } -static void SvcWrap_SetProcessMemoryPermission64From32(Core::System& system) { +static void SvcWrap_SetProcessMemoryPermission64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle process_handle{}; @@ -1825,23 +1825,23 @@ static void SvcWrap_SetProcessMemoryPermission64From32(Core::System& system) { uint64_t size{}; MemoryPermission perm{}; - process_handle = Convert<Handle>(GetReg32(system, 0)); + process_handle = Convert<Handle>(GetArg32(args, 0)); std::array<uint32_t, 2> address_gather{}; - address_gather[0] = GetReg32(system, 2); - address_gather[1] = GetReg32(system, 3); + address_gather[0] = GetArg32(args, 2); + address_gather[1] = GetArg32(args, 3); address = Convert<uint64_t>(address_gather); std::array<uint32_t, 2> size_gather{}; - size_gather[0] = GetReg32(system, 1); - size_gather[1] = GetReg32(system, 4); + size_gather[0] = GetArg32(args, 1); + size_gather[1] = GetArg32(args, 4); size = Convert<uint64_t>(size_gather); - perm = Convert<MemoryPermission>(GetReg32(system, 5)); + perm = Convert<MemoryPermission>(GetArg32(args, 5)); ret = SetProcessMemoryPermission64From32(system, process_handle, address, size, perm); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_MapProcessMemory64From32(Core::System& system) { +static void SvcWrap_MapProcessMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t dst_address{}; @@ -1849,20 +1849,20 @@ static void SvcWrap_MapProcessMemory64From32(Core::System& system) { uint64_t src_address{}; uint32_t size{}; - dst_address = Convert<uint32_t>(GetReg32(system, 0)); - process_handle = Convert<Handle>(GetReg32(system, 1)); + dst_address = Convert<uint32_t>(GetArg32(args, 0)); + process_handle = Convert<Handle>(GetArg32(args, 1)); std::array<uint32_t, 2> src_address_gather{}; - src_address_gather[0] = GetReg32(system, 2); - src_address_gather[1] = GetReg32(system, 3); + src_address_gather[0] = GetArg32(args, 2); + src_address_gather[1] = GetArg32(args, 3); src_address = Convert<uint64_t>(src_address_gather); - size = Convert<uint32_t>(GetReg32(system, 4)); + size = Convert<uint32_t>(GetArg32(args, 4)); ret = MapProcessMemory64From32(system, dst_address, process_handle, src_address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_UnmapProcessMemory64From32(Core::System& system) { +static void SvcWrap_UnmapProcessMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t dst_address{}; @@ -1870,20 +1870,20 @@ static void SvcWrap_UnmapProcessMemory64From32(Core::System& system) { uint64_t src_address{}; uint32_t size{}; - dst_address = Convert<uint32_t>(GetReg32(system, 0)); - process_handle = Convert<Handle>(GetReg32(system, 1)); + dst_address = Convert<uint32_t>(GetArg32(args, 0)); + process_handle = Convert<Handle>(GetArg32(args, 1)); std::array<uint32_t, 2> src_address_gather{}; - src_address_gather[0] = GetReg32(system, 2); - src_address_gather[1] = GetReg32(system, 3); + src_address_gather[0] = GetArg32(args, 2); + src_address_gather[1] = GetArg32(args, 3); src_address = Convert<uint64_t>(src_address_gather); - size = Convert<uint32_t>(GetReg32(system, 4)); + size = Convert<uint32_t>(GetArg32(args, 4)); ret = UnmapProcessMemory64From32(system, dst_address, process_handle, src_address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_QueryProcessMemory64From32(Core::System& system) { +static void SvcWrap_QueryProcessMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; PageInfo out_page_info{}; @@ -1891,20 +1891,20 @@ static void SvcWrap_QueryProcessMemory64From32(Core::System& system) { Handle process_handle{}; uint64_t address{}; - out_memory_info = Convert<uint32_t>(GetReg32(system, 0)); - process_handle = Convert<Handle>(GetReg32(system, 2)); + out_memory_info = Convert<uint32_t>(GetArg32(args, 0)); + process_handle = Convert<Handle>(GetArg32(args, 2)); std::array<uint32_t, 2> address_gather{}; - address_gather[0] = GetReg32(system, 1); - address_gather[1] = GetReg32(system, 3); + address_gather[0] = GetArg32(args, 1); + address_gather[1] = GetArg32(args, 3); address = Convert<uint64_t>(address_gather); ret = QueryProcessMemory64From32(system, out_memory_info, std::addressof(out_page_info), process_handle, address); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_page_info)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_page_info)); } -static void SvcWrap_MapProcessCodeMemory64From32(Core::System& system) { +static void SvcWrap_MapProcessCodeMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle process_handle{}; @@ -1912,26 +1912,26 @@ static void SvcWrap_MapProcessCodeMemory64From32(Core::System& system) { uint64_t src_address{}; uint64_t size{}; - process_handle = Convert<Handle>(GetReg32(system, 0)); + process_handle = Convert<Handle>(GetArg32(args, 0)); std::array<uint32_t, 2> dst_address_gather{}; - dst_address_gather[0] = GetReg32(system, 2); - dst_address_gather[1] = GetReg32(system, 3); + dst_address_gather[0] = GetArg32(args, 2); + dst_address_gather[1] = GetArg32(args, 3); dst_address = Convert<uint64_t>(dst_address_gather); std::array<uint32_t, 2> src_address_gather{}; - src_address_gather[0] = GetReg32(system, 1); - src_address_gather[1] = GetReg32(system, 4); + src_address_gather[0] = GetArg32(args, 1); + src_address_gather[1] = GetArg32(args, 4); src_address = Convert<uint64_t>(src_address_gather); std::array<uint32_t, 2> size_gather{}; - size_gather[0] = GetReg32(system, 5); - size_gather[1] = GetReg32(system, 6); + size_gather[0] = GetArg32(args, 5); + size_gather[1] = GetArg32(args, 6); size = Convert<uint64_t>(size_gather); ret = MapProcessCodeMemory64From32(system, process_handle, dst_address, src_address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_UnmapProcessCodeMemory64From32(Core::System& system) { +static void SvcWrap_UnmapProcessCodeMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle process_handle{}; @@ -1939,26 +1939,26 @@ static void SvcWrap_UnmapProcessCodeMemory64From32(Core::System& system) { uint64_t src_address{}; uint64_t size{}; - process_handle = Convert<Handle>(GetReg32(system, 0)); + process_handle = Convert<Handle>(GetArg32(args, 0)); std::array<uint32_t, 2> dst_address_gather{}; - dst_address_gather[0] = GetReg32(system, 2); - dst_address_gather[1] = GetReg32(system, 3); + dst_address_gather[0] = GetArg32(args, 2); + dst_address_gather[1] = GetArg32(args, 3); dst_address = Convert<uint64_t>(dst_address_gather); std::array<uint32_t, 2> src_address_gather{}; - src_address_gather[0] = GetReg32(system, 1); - src_address_gather[1] = GetReg32(system, 4); + src_address_gather[0] = GetArg32(args, 1); + src_address_gather[1] = GetArg32(args, 4); src_address = Convert<uint64_t>(src_address_gather); std::array<uint32_t, 2> size_gather{}; - size_gather[0] = GetReg32(system, 5); - size_gather[1] = GetReg32(system, 6); + size_gather[0] = GetArg32(args, 5); + size_gather[1] = GetArg32(args, 6); size = Convert<uint64_t>(size_gather); ret = UnmapProcessCodeMemory64From32(system, process_handle, dst_address, src_address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_CreateProcess64From32(Core::System& system) { +static void SvcWrap_CreateProcess64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; @@ -1966,17 +1966,17 @@ static void SvcWrap_CreateProcess64From32(Core::System& system) { uint32_t caps{}; int32_t num_caps{}; - parameters = Convert<uint32_t>(GetReg32(system, 1)); - caps = Convert<uint32_t>(GetReg32(system, 2)); - num_caps = Convert<int32_t>(GetReg32(system, 3)); + parameters = Convert<uint32_t>(GetArg32(args, 1)); + caps = Convert<uint32_t>(GetArg32(args, 2)); + num_caps = Convert<int32_t>(GetArg32(args, 3)); ret = CreateProcess64From32(system, std::addressof(out_handle), parameters, caps, num_caps); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_handle)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_handle)); } -static void SvcWrap_StartProcess64From32(Core::System& system) { +static void SvcWrap_StartProcess64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle process_handle{}; @@ -1984,138 +1984,138 @@ static void SvcWrap_StartProcess64From32(Core::System& system) { int32_t core_id{}; uint64_t main_thread_stack_size{}; - process_handle = Convert<Handle>(GetReg32(system, 0)); - priority = Convert<int32_t>(GetReg32(system, 1)); - core_id = Convert<int32_t>(GetReg32(system, 2)); + process_handle = Convert<Handle>(GetArg32(args, 0)); + priority = Convert<int32_t>(GetArg32(args, 1)); + core_id = Convert<int32_t>(GetArg32(args, 2)); std::array<uint32_t, 2> main_thread_stack_size_gather{}; - main_thread_stack_size_gather[0] = GetReg32(system, 3); - main_thread_stack_size_gather[1] = GetReg32(system, 4); + main_thread_stack_size_gather[0] = GetArg32(args, 3); + main_thread_stack_size_gather[1] = GetArg32(args, 4); main_thread_stack_size = Convert<uint64_t>(main_thread_stack_size_gather); ret = StartProcess64From32(system, process_handle, priority, core_id, main_thread_stack_size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_TerminateProcess64From32(Core::System& system) { +static void SvcWrap_TerminateProcess64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle process_handle{}; - process_handle = Convert<Handle>(GetReg32(system, 0)); + process_handle = Convert<Handle>(GetArg32(args, 0)); ret = TerminateProcess64From32(system, process_handle); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_GetProcessInfo64From32(Core::System& system) { +static void SvcWrap_GetProcessInfo64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int64_t out_info{}; Handle process_handle{}; ProcessInfoType info_type{}; - process_handle = Convert<Handle>(GetReg32(system, 1)); - info_type = Convert<ProcessInfoType>(GetReg32(system, 2)); + process_handle = Convert<Handle>(GetArg32(args, 1)); + info_type = Convert<ProcessInfoType>(GetArg32(args, 2)); ret = GetProcessInfo64From32(system, std::addressof(out_info), process_handle, info_type); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); auto out_info_scatter = Convert<std::array<uint32_t, 2>>(out_info); - SetReg32(system, 1, out_info_scatter[0]); - SetReg32(system, 2, out_info_scatter[1]); + SetArg32(args, 1, out_info_scatter[0]); + SetArg32(args, 2, out_info_scatter[1]); } -static void SvcWrap_CreateResourceLimit64From32(Core::System& system) { +static void SvcWrap_CreateResourceLimit64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; ret = CreateResourceLimit64From32(system, std::addressof(out_handle)); - SetReg32(system, 0, Convert<uint32_t>(ret)); - SetReg32(system, 1, Convert<uint32_t>(out_handle)); + SetArg32(args, 0, Convert<uint32_t>(ret)); + SetArg32(args, 1, Convert<uint32_t>(out_handle)); } -static void SvcWrap_SetResourceLimitLimitValue64From32(Core::System& system) { +static void SvcWrap_SetResourceLimitLimitValue64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle resource_limit_handle{}; LimitableResource which{}; int64_t limit_value{}; - resource_limit_handle = Convert<Handle>(GetReg32(system, 0)); - which = Convert<LimitableResource>(GetReg32(system, 1)); + resource_limit_handle = Convert<Handle>(GetArg32(args, 0)); + which = Convert<LimitableResource>(GetArg32(args, 1)); std::array<uint32_t, 2> limit_value_gather{}; - limit_value_gather[0] = GetReg32(system, 2); - limit_value_gather[1] = GetReg32(system, 3); + limit_value_gather[0] = GetArg32(args, 2); + limit_value_gather[1] = GetArg32(args, 3); limit_value = Convert<int64_t>(limit_value_gather); ret = SetResourceLimitLimitValue64From32(system, resource_limit_handle, which, limit_value); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_MapInsecureMemory64From32(Core::System& system) { +static void SvcWrap_MapInsecureMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t address{}; uint32_t size{}; - address = Convert<uint32_t>(GetReg32(system, 0)); - size = Convert<uint32_t>(GetReg32(system, 1)); + address = Convert<uint32_t>(GetArg32(args, 0)); + size = Convert<uint32_t>(GetArg32(args, 1)); ret = MapInsecureMemory64From32(system, address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_UnmapInsecureMemory64From32(Core::System& system) { +static void SvcWrap_UnmapInsecureMemory64From32(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t address{}; uint32_t size{}; - address = Convert<uint32_t>(GetReg32(system, 0)); - size = Convert<uint32_t>(GetReg32(system, 1)); + address = Convert<uint32_t>(GetArg32(args, 0)); + size = Convert<uint32_t>(GetArg32(args, 1)); ret = UnmapInsecureMemory64From32(system, address, size); - SetReg32(system, 0, Convert<uint32_t>(ret)); + SetArg32(args, 0, Convert<uint32_t>(ret)); } -static void SvcWrap_SetHeapSize64(Core::System& system) { +static void SvcWrap_SetHeapSize64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t out_address{}; uint64_t size{}; - size = Convert<uint64_t>(GetReg64(system, 1)); + size = Convert<uint64_t>(GetArg64(args, 1)); ret = SetHeapSize64(system, std::addressof(out_address), size); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_address)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_address)); } -static void SvcWrap_SetMemoryPermission64(Core::System& system) { +static void SvcWrap_SetMemoryPermission64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t address{}; uint64_t size{}; MemoryPermission perm{}; - address = Convert<uint64_t>(GetReg64(system, 0)); - size = Convert<uint64_t>(GetReg64(system, 1)); - perm = Convert<MemoryPermission>(GetReg64(system, 2)); + address = Convert<uint64_t>(GetArg64(args, 0)); + size = Convert<uint64_t>(GetArg64(args, 1)); + perm = Convert<MemoryPermission>(GetArg64(args, 2)); ret = SetMemoryPermission64(system, address, size, perm); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_SetMemoryAttribute64(Core::System& system) { +static void SvcWrap_SetMemoryAttribute64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t address{}; @@ -2123,69 +2123,69 @@ static void SvcWrap_SetMemoryAttribute64(Core::System& system) { uint32_t mask{}; uint32_t attr{}; - address = Convert<uint64_t>(GetReg64(system, 0)); - size = Convert<uint64_t>(GetReg64(system, 1)); - mask = Convert<uint32_t>(GetReg64(system, 2)); - attr = Convert<uint32_t>(GetReg64(system, 3)); + address = Convert<uint64_t>(GetArg64(args, 0)); + size = Convert<uint64_t>(GetArg64(args, 1)); + mask = Convert<uint32_t>(GetArg64(args, 2)); + attr = Convert<uint32_t>(GetArg64(args, 3)); ret = SetMemoryAttribute64(system, address, size, mask, attr); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_MapMemory64(Core::System& system) { +static void SvcWrap_MapMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t dst_address{}; uint64_t src_address{}; uint64_t size{}; - dst_address = Convert<uint64_t>(GetReg64(system, 0)); - src_address = Convert<uint64_t>(GetReg64(system, 1)); - size = Convert<uint64_t>(GetReg64(system, 2)); + dst_address = Convert<uint64_t>(GetArg64(args, 0)); + src_address = Convert<uint64_t>(GetArg64(args, 1)); + size = Convert<uint64_t>(GetArg64(args, 2)); ret = MapMemory64(system, dst_address, src_address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_UnmapMemory64(Core::System& system) { +static void SvcWrap_UnmapMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t dst_address{}; uint64_t src_address{}; uint64_t size{}; - dst_address = Convert<uint64_t>(GetReg64(system, 0)); - src_address = Convert<uint64_t>(GetReg64(system, 1)); - size = Convert<uint64_t>(GetReg64(system, 2)); + dst_address = Convert<uint64_t>(GetArg64(args, 0)); + src_address = Convert<uint64_t>(GetArg64(args, 1)); + size = Convert<uint64_t>(GetArg64(args, 2)); ret = UnmapMemory64(system, dst_address, src_address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_QueryMemory64(Core::System& system) { +static void SvcWrap_QueryMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; PageInfo out_page_info{}; uint64_t out_memory_info{}; uint64_t address{}; - out_memory_info = Convert<uint64_t>(GetReg64(system, 0)); - address = Convert<uint64_t>(GetReg64(system, 2)); + out_memory_info = Convert<uint64_t>(GetArg64(args, 0)); + address = Convert<uint64_t>(GetArg64(args, 2)); ret = QueryMemory64(system, out_memory_info, std::addressof(out_page_info), address); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_page_info)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_page_info)); } -static void SvcWrap_ExitProcess64(Core::System& system) { +static void SvcWrap_ExitProcess64(Core::System& system, std::span<uint64_t, 8> args) { ExitProcess64(system); } -static void SvcWrap_CreateThread64(Core::System& system) { +static void SvcWrap_CreateThread64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; @@ -2195,135 +2195,135 @@ static void SvcWrap_CreateThread64(Core::System& system) { int32_t priority{}; int32_t core_id{}; - func = Convert<uint64_t>(GetReg64(system, 1)); - arg = Convert<uint64_t>(GetReg64(system, 2)); - stack_bottom = Convert<uint64_t>(GetReg64(system, 3)); - priority = Convert<int32_t>(GetReg64(system, 4)); - core_id = Convert<int32_t>(GetReg64(system, 5)); + func = Convert<uint64_t>(GetArg64(args, 1)); + arg = Convert<uint64_t>(GetArg64(args, 2)); + stack_bottom = Convert<uint64_t>(GetArg64(args, 3)); + priority = Convert<int32_t>(GetArg64(args, 4)); + core_id = Convert<int32_t>(GetArg64(args, 5)); ret = CreateThread64(system, std::addressof(out_handle), func, arg, stack_bottom, priority, core_id); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_handle)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_handle)); } -static void SvcWrap_StartThread64(Core::System& system) { +static void SvcWrap_StartThread64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle thread_handle{}; - thread_handle = Convert<Handle>(GetReg64(system, 0)); + thread_handle = Convert<Handle>(GetArg64(args, 0)); ret = StartThread64(system, thread_handle); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_ExitThread64(Core::System& system) { +static void SvcWrap_ExitThread64(Core::System& system, std::span<uint64_t, 8> args) { ExitThread64(system); } -static void SvcWrap_SleepThread64(Core::System& system) { +static void SvcWrap_SleepThread64(Core::System& system, std::span<uint64_t, 8> args) { int64_t ns{}; - ns = Convert<int64_t>(GetReg64(system, 0)); + ns = Convert<int64_t>(GetArg64(args, 0)); SleepThread64(system, ns); } -static void SvcWrap_GetThreadPriority64(Core::System& system) { +static void SvcWrap_GetThreadPriority64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int32_t out_priority{}; Handle thread_handle{}; - thread_handle = Convert<Handle>(GetReg64(system, 1)); + thread_handle = Convert<Handle>(GetArg64(args, 1)); ret = GetThreadPriority64(system, std::addressof(out_priority), thread_handle); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_priority)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_priority)); } -static void SvcWrap_SetThreadPriority64(Core::System& system) { +static void SvcWrap_SetThreadPriority64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle thread_handle{}; int32_t priority{}; - thread_handle = Convert<Handle>(GetReg64(system, 0)); - priority = Convert<int32_t>(GetReg64(system, 1)); + thread_handle = Convert<Handle>(GetArg64(args, 0)); + priority = Convert<int32_t>(GetArg64(args, 1)); ret = SetThreadPriority64(system, thread_handle, priority); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_GetThreadCoreMask64(Core::System& system) { +static void SvcWrap_GetThreadCoreMask64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int32_t out_core_id{}; uint64_t out_affinity_mask{}; Handle thread_handle{}; - thread_handle = Convert<Handle>(GetReg64(system, 2)); + thread_handle = Convert<Handle>(GetArg64(args, 2)); ret = GetThreadCoreMask64(system, std::addressof(out_core_id), std::addressof(out_affinity_mask), thread_handle); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_core_id)); - SetReg64(system, 2, Convert<uint64_t>(out_affinity_mask)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_core_id)); + SetArg64(args, 2, Convert<uint64_t>(out_affinity_mask)); } -static void SvcWrap_SetThreadCoreMask64(Core::System& system) { +static void SvcWrap_SetThreadCoreMask64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle thread_handle{}; int32_t core_id{}; uint64_t affinity_mask{}; - thread_handle = Convert<Handle>(GetReg64(system, 0)); - core_id = Convert<int32_t>(GetReg64(system, 1)); - affinity_mask = Convert<uint64_t>(GetReg64(system, 2)); + thread_handle = Convert<Handle>(GetArg64(args, 0)); + core_id = Convert<int32_t>(GetArg64(args, 1)); + affinity_mask = Convert<uint64_t>(GetArg64(args, 2)); ret = SetThreadCoreMask64(system, thread_handle, core_id, affinity_mask); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_GetCurrentProcessorNumber64(Core::System& system) { +static void SvcWrap_GetCurrentProcessorNumber64(Core::System& system, std::span<uint64_t, 8> args) { int32_t ret{}; ret = GetCurrentProcessorNumber64(system); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_SignalEvent64(Core::System& system) { +static void SvcWrap_SignalEvent64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle event_handle{}; - event_handle = Convert<Handle>(GetReg64(system, 0)); + event_handle = Convert<Handle>(GetArg64(args, 0)); ret = SignalEvent64(system, event_handle); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_ClearEvent64(Core::System& system) { +static void SvcWrap_ClearEvent64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle event_handle{}; - event_handle = Convert<Handle>(GetReg64(system, 0)); + event_handle = Convert<Handle>(GetArg64(args, 0)); ret = ClearEvent64(system, event_handle); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_MapSharedMemory64(Core::System& system) { +static void SvcWrap_MapSharedMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle shmem_handle{}; @@ -2331,33 +2331,33 @@ static void SvcWrap_MapSharedMemory64(Core::System& system) { uint64_t size{}; MemoryPermission map_perm{}; - shmem_handle = Convert<Handle>(GetReg64(system, 0)); - address = Convert<uint64_t>(GetReg64(system, 1)); - size = Convert<uint64_t>(GetReg64(system, 2)); - map_perm = Convert<MemoryPermission>(GetReg64(system, 3)); + shmem_handle = Convert<Handle>(GetArg64(args, 0)); + address = Convert<uint64_t>(GetArg64(args, 1)); + size = Convert<uint64_t>(GetArg64(args, 2)); + map_perm = Convert<MemoryPermission>(GetArg64(args, 3)); ret = MapSharedMemory64(system, shmem_handle, address, size, map_perm); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_UnmapSharedMemory64(Core::System& system) { +static void SvcWrap_UnmapSharedMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle shmem_handle{}; uint64_t address{}; uint64_t size{}; - shmem_handle = Convert<Handle>(GetReg64(system, 0)); - address = Convert<uint64_t>(GetReg64(system, 1)); - size = Convert<uint64_t>(GetReg64(system, 2)); + shmem_handle = Convert<Handle>(GetArg64(args, 0)); + address = Convert<uint64_t>(GetArg64(args, 1)); + size = Convert<uint64_t>(GetArg64(args, 2)); ret = UnmapSharedMemory64(system, shmem_handle, address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_CreateTransferMemory64(Core::System& system) { +static void SvcWrap_CreateTransferMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; @@ -2365,41 +2365,41 @@ static void SvcWrap_CreateTransferMemory64(Core::System& system) { uint64_t size{}; MemoryPermission map_perm{}; - address = Convert<uint64_t>(GetReg64(system, 1)); - size = Convert<uint64_t>(GetReg64(system, 2)); - map_perm = Convert<MemoryPermission>(GetReg64(system, 3)); + address = Convert<uint64_t>(GetArg64(args, 1)); + size = Convert<uint64_t>(GetArg64(args, 2)); + map_perm = Convert<MemoryPermission>(GetArg64(args, 3)); ret = CreateTransferMemory64(system, std::addressof(out_handle), address, size, map_perm); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_handle)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_handle)); } -static void SvcWrap_CloseHandle64(Core::System& system) { +static void SvcWrap_CloseHandle64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle handle{}; - handle = Convert<Handle>(GetReg64(system, 0)); + handle = Convert<Handle>(GetArg64(args, 0)); ret = CloseHandle64(system, handle); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_ResetSignal64(Core::System& system) { +static void SvcWrap_ResetSignal64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle handle{}; - handle = Convert<Handle>(GetReg64(system, 0)); + handle = Convert<Handle>(GetArg64(args, 0)); ret = ResetSignal64(system, handle); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_WaitSynchronization64(Core::System& system) { +static void SvcWrap_WaitSynchronization64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int32_t out_index{}; @@ -2407,57 +2407,57 @@ static void SvcWrap_WaitSynchronization64(Core::System& system) { int32_t num_handles{}; int64_t timeout_ns{}; - handles = Convert<uint64_t>(GetReg64(system, 1)); - num_handles = Convert<int32_t>(GetReg64(system, 2)); - timeout_ns = Convert<int64_t>(GetReg64(system, 3)); + handles = Convert<uint64_t>(GetArg64(args, 1)); + num_handles = Convert<int32_t>(GetArg64(args, 2)); + timeout_ns = Convert<int64_t>(GetArg64(args, 3)); ret = WaitSynchronization64(system, std::addressof(out_index), handles, num_handles, timeout_ns); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_index)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_index)); } -static void SvcWrap_CancelSynchronization64(Core::System& system) { +static void SvcWrap_CancelSynchronization64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle handle{}; - handle = Convert<Handle>(GetReg64(system, 0)); + handle = Convert<Handle>(GetArg64(args, 0)); ret = CancelSynchronization64(system, handle); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_ArbitrateLock64(Core::System& system) { +static void SvcWrap_ArbitrateLock64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle thread_handle{}; uint64_t address{}; uint32_t tag{}; - thread_handle = Convert<Handle>(GetReg64(system, 0)); - address = Convert<uint64_t>(GetReg64(system, 1)); - tag = Convert<uint32_t>(GetReg64(system, 2)); + thread_handle = Convert<Handle>(GetArg64(args, 0)); + address = Convert<uint64_t>(GetArg64(args, 1)); + tag = Convert<uint32_t>(GetArg64(args, 2)); ret = ArbitrateLock64(system, thread_handle, address, tag); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_ArbitrateUnlock64(Core::System& system) { +static void SvcWrap_ArbitrateUnlock64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t address{}; - address = Convert<uint64_t>(GetReg64(system, 0)); + address = Convert<uint64_t>(GetArg64(args, 0)); ret = ArbitrateUnlock64(system, address); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_WaitProcessWideKeyAtomic64(Core::System& system) { +static void SvcWrap_WaitProcessWideKeyAtomic64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t address{}; @@ -2465,77 +2465,77 @@ static void SvcWrap_WaitProcessWideKeyAtomic64(Core::System& system) { uint32_t tag{}; int64_t timeout_ns{}; - address = Convert<uint64_t>(GetReg64(system, 0)); - cv_key = Convert<uint64_t>(GetReg64(system, 1)); - tag = Convert<uint32_t>(GetReg64(system, 2)); - timeout_ns = Convert<int64_t>(GetReg64(system, 3)); + address = Convert<uint64_t>(GetArg64(args, 0)); + cv_key = Convert<uint64_t>(GetArg64(args, 1)); + tag = Convert<uint32_t>(GetArg64(args, 2)); + timeout_ns = Convert<int64_t>(GetArg64(args, 3)); ret = WaitProcessWideKeyAtomic64(system, address, cv_key, tag, timeout_ns); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_SignalProcessWideKey64(Core::System& system) { +static void SvcWrap_SignalProcessWideKey64(Core::System& system, std::span<uint64_t, 8> args) { uint64_t cv_key{}; int32_t count{}; - cv_key = Convert<uint64_t>(GetReg64(system, 0)); - count = Convert<int32_t>(GetReg64(system, 1)); + cv_key = Convert<uint64_t>(GetArg64(args, 0)); + count = Convert<int32_t>(GetArg64(args, 1)); SignalProcessWideKey64(system, cv_key, count); } -static void SvcWrap_GetSystemTick64(Core::System& system) { +static void SvcWrap_GetSystemTick64(Core::System& system, std::span<uint64_t, 8> args) { int64_t ret{}; ret = GetSystemTick64(system); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_ConnectToNamedPort64(Core::System& system) { +static void SvcWrap_ConnectToNamedPort64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; uint64_t name{}; - name = Convert<uint64_t>(GetReg64(system, 1)); + name = Convert<uint64_t>(GetArg64(args, 1)); ret = ConnectToNamedPort64(system, std::addressof(out_handle), name); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_handle)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_handle)); } -static void SvcWrap_SendSyncRequest64(Core::System& system) { +static void SvcWrap_SendSyncRequest64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle session_handle{}; - session_handle = Convert<Handle>(GetReg64(system, 0)); + session_handle = Convert<Handle>(GetArg64(args, 0)); ret = SendSyncRequest64(system, session_handle); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_SendSyncRequestWithUserBuffer64(Core::System& system) { +static void SvcWrap_SendSyncRequestWithUserBuffer64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t message_buffer{}; uint64_t message_buffer_size{}; Handle session_handle{}; - message_buffer = Convert<uint64_t>(GetReg64(system, 0)); - message_buffer_size = Convert<uint64_t>(GetReg64(system, 1)); - session_handle = Convert<Handle>(GetReg64(system, 2)); + message_buffer = Convert<uint64_t>(GetArg64(args, 0)); + message_buffer_size = Convert<uint64_t>(GetArg64(args, 1)); + session_handle = Convert<Handle>(GetArg64(args, 2)); ret = SendSyncRequestWithUserBuffer64(system, message_buffer, message_buffer_size, session_handle); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_SendAsyncRequestWithUserBuffer64(Core::System& system) { +static void SvcWrap_SendAsyncRequestWithUserBuffer64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_event_handle{}; @@ -2543,79 +2543,79 @@ static void SvcWrap_SendAsyncRequestWithUserBuffer64(Core::System& system) { uint64_t message_buffer_size{}; Handle session_handle{}; - message_buffer = Convert<uint64_t>(GetReg64(system, 1)); - message_buffer_size = Convert<uint64_t>(GetReg64(system, 2)); - session_handle = Convert<Handle>(GetReg64(system, 3)); + message_buffer = Convert<uint64_t>(GetArg64(args, 1)); + message_buffer_size = Convert<uint64_t>(GetArg64(args, 2)); + session_handle = Convert<Handle>(GetArg64(args, 3)); ret = SendAsyncRequestWithUserBuffer64(system, std::addressof(out_event_handle), message_buffer, message_buffer_size, session_handle); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_event_handle)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_event_handle)); } -static void SvcWrap_GetProcessId64(Core::System& system) { +static void SvcWrap_GetProcessId64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t out_process_id{}; Handle process_handle{}; - process_handle = Convert<Handle>(GetReg64(system, 1)); + process_handle = Convert<Handle>(GetArg64(args, 1)); ret = GetProcessId64(system, std::addressof(out_process_id), process_handle); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_process_id)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_process_id)); } -static void SvcWrap_GetThreadId64(Core::System& system) { +static void SvcWrap_GetThreadId64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t out_thread_id{}; Handle thread_handle{}; - thread_handle = Convert<Handle>(GetReg64(system, 1)); + thread_handle = Convert<Handle>(GetArg64(args, 1)); ret = GetThreadId64(system, std::addressof(out_thread_id), thread_handle); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_thread_id)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_thread_id)); } -static void SvcWrap_Break64(Core::System& system) { +static void SvcWrap_Break64(Core::System& system, std::span<uint64_t, 8> args) { BreakReason break_reason{}; uint64_t arg{}; uint64_t size{}; - break_reason = Convert<BreakReason>(GetReg64(system, 0)); - arg = Convert<uint64_t>(GetReg64(system, 1)); - size = Convert<uint64_t>(GetReg64(system, 2)); + break_reason = Convert<BreakReason>(GetArg64(args, 0)); + arg = Convert<uint64_t>(GetArg64(args, 1)); + size = Convert<uint64_t>(GetArg64(args, 2)); Break64(system, break_reason, arg, size); } -static void SvcWrap_OutputDebugString64(Core::System& system) { +static void SvcWrap_OutputDebugString64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t debug_str{}; uint64_t len{}; - debug_str = Convert<uint64_t>(GetReg64(system, 0)); - len = Convert<uint64_t>(GetReg64(system, 1)); + debug_str = Convert<uint64_t>(GetArg64(args, 0)); + len = Convert<uint64_t>(GetArg64(args, 1)); ret = OutputDebugString64(system, debug_str, len); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_ReturnFromException64(Core::System& system) { +static void SvcWrap_ReturnFromException64(Core::System& system, std::span<uint64_t, 8> args) { Result result{}; - result = Convert<Result>(GetReg64(system, 0)); + result = Convert<Result>(GetArg64(args, 0)); ReturnFromException64(system, result); } -static void SvcWrap_GetInfo64(Core::System& system) { +static void SvcWrap_GetInfo64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t out{}; @@ -2623,63 +2623,63 @@ static void SvcWrap_GetInfo64(Core::System& system) { Handle handle{}; uint64_t info_subtype{}; - info_type = Convert<InfoType>(GetReg64(system, 1)); - handle = Convert<Handle>(GetReg64(system, 2)); - info_subtype = Convert<uint64_t>(GetReg64(system, 3)); + info_type = Convert<InfoType>(GetArg64(args, 1)); + handle = Convert<Handle>(GetArg64(args, 2)); + info_subtype = Convert<uint64_t>(GetArg64(args, 3)); ret = GetInfo64(system, std::addressof(out), info_type, handle, info_subtype); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out)); } -static void SvcWrap_FlushEntireDataCache64(Core::System& system) { +static void SvcWrap_FlushEntireDataCache64(Core::System& system, std::span<uint64_t, 8> args) { FlushEntireDataCache64(system); } -static void SvcWrap_FlushDataCache64(Core::System& system) { +static void SvcWrap_FlushDataCache64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t address{}; uint64_t size{}; - address = Convert<uint64_t>(GetReg64(system, 0)); - size = Convert<uint64_t>(GetReg64(system, 1)); + address = Convert<uint64_t>(GetArg64(args, 0)); + size = Convert<uint64_t>(GetArg64(args, 1)); ret = FlushDataCache64(system, address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_MapPhysicalMemory64(Core::System& system) { +static void SvcWrap_MapPhysicalMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t address{}; uint64_t size{}; - address = Convert<uint64_t>(GetReg64(system, 0)); - size = Convert<uint64_t>(GetReg64(system, 1)); + address = Convert<uint64_t>(GetArg64(args, 0)); + size = Convert<uint64_t>(GetArg64(args, 1)); ret = MapPhysicalMemory64(system, address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_UnmapPhysicalMemory64(Core::System& system) { +static void SvcWrap_UnmapPhysicalMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t address{}; uint64_t size{}; - address = Convert<uint64_t>(GetReg64(system, 0)); - size = Convert<uint64_t>(GetReg64(system, 1)); + address = Convert<uint64_t>(GetArg64(args, 0)); + size = Convert<uint64_t>(GetArg64(args, 1)); ret = UnmapPhysicalMemory64(system, address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_GetDebugFutureThreadInfo64(Core::System& system) { +static void SvcWrap_GetDebugFutureThreadInfo64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; lp64::LastThreadContext out_context{}; @@ -2687,21 +2687,21 @@ static void SvcWrap_GetDebugFutureThreadInfo64(Core::System& system) { Handle debug_handle{}; int64_t ns{}; - debug_handle = Convert<Handle>(GetReg64(system, 2)); - ns = Convert<int64_t>(GetReg64(system, 3)); + debug_handle = Convert<Handle>(GetArg64(args, 2)); + ns = Convert<int64_t>(GetArg64(args, 3)); ret = GetDebugFutureThreadInfo64(system, std::addressof(out_context), std::addressof(out_thread_id), debug_handle, ns); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); auto out_context_scatter = Convert<std::array<uint64_t, 4>>(out_context); - SetReg64(system, 1, out_context_scatter[0]); - SetReg64(system, 2, out_context_scatter[1]); - SetReg64(system, 3, out_context_scatter[2]); - SetReg64(system, 4, out_context_scatter[3]); - SetReg64(system, 5, Convert<uint64_t>(out_thread_id)); + SetArg64(args, 1, out_context_scatter[0]); + SetArg64(args, 2, out_context_scatter[1]); + SetArg64(args, 3, out_context_scatter[2]); + SetArg64(args, 4, out_context_scatter[3]); + SetArg64(args, 5, Convert<uint64_t>(out_thread_id)); } -static void SvcWrap_GetLastThreadInfo64(Core::System& system) { +static void SvcWrap_GetLastThreadInfo64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; lp64::LastThreadContext out_context{}; @@ -2710,77 +2710,77 @@ static void SvcWrap_GetLastThreadInfo64(Core::System& system) { ret = GetLastThreadInfo64(system, std::addressof(out_context), std::addressof(out_tls_address), std::addressof(out_flags)); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); auto out_context_scatter = Convert<std::array<uint64_t, 4>>(out_context); - SetReg64(system, 1, out_context_scatter[0]); - SetReg64(system, 2, out_context_scatter[1]); - SetReg64(system, 3, out_context_scatter[2]); - SetReg64(system, 4, out_context_scatter[3]); - SetReg64(system, 5, Convert<uint64_t>(out_tls_address)); - SetReg64(system, 6, Convert<uint64_t>(out_flags)); + SetArg64(args, 1, out_context_scatter[0]); + SetArg64(args, 2, out_context_scatter[1]); + SetArg64(args, 3, out_context_scatter[2]); + SetArg64(args, 4, out_context_scatter[3]); + SetArg64(args, 5, Convert<uint64_t>(out_tls_address)); + SetArg64(args, 6, Convert<uint64_t>(out_flags)); } -static void SvcWrap_GetResourceLimitLimitValue64(Core::System& system) { +static void SvcWrap_GetResourceLimitLimitValue64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int64_t out_limit_value{}; Handle resource_limit_handle{}; LimitableResource which{}; - resource_limit_handle = Convert<Handle>(GetReg64(system, 1)); - which = Convert<LimitableResource>(GetReg64(system, 2)); + resource_limit_handle = Convert<Handle>(GetArg64(args, 1)); + which = Convert<LimitableResource>(GetArg64(args, 2)); ret = GetResourceLimitLimitValue64(system, std::addressof(out_limit_value), resource_limit_handle, which); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_limit_value)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_limit_value)); } -static void SvcWrap_GetResourceLimitCurrentValue64(Core::System& system) { +static void SvcWrap_GetResourceLimitCurrentValue64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int64_t out_current_value{}; Handle resource_limit_handle{}; LimitableResource which{}; - resource_limit_handle = Convert<Handle>(GetReg64(system, 1)); - which = Convert<LimitableResource>(GetReg64(system, 2)); + resource_limit_handle = Convert<Handle>(GetArg64(args, 1)); + which = Convert<LimitableResource>(GetArg64(args, 2)); ret = GetResourceLimitCurrentValue64(system, std::addressof(out_current_value), resource_limit_handle, which); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_current_value)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_current_value)); } -static void SvcWrap_SetThreadActivity64(Core::System& system) { +static void SvcWrap_SetThreadActivity64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle thread_handle{}; ThreadActivity thread_activity{}; - thread_handle = Convert<Handle>(GetReg64(system, 0)); - thread_activity = Convert<ThreadActivity>(GetReg64(system, 1)); + thread_handle = Convert<Handle>(GetArg64(args, 0)); + thread_activity = Convert<ThreadActivity>(GetArg64(args, 1)); ret = SetThreadActivity64(system, thread_handle, thread_activity); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_GetThreadContext364(Core::System& system) { +static void SvcWrap_GetThreadContext364(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t out_context{}; Handle thread_handle{}; - out_context = Convert<uint64_t>(GetReg64(system, 0)); - thread_handle = Convert<Handle>(GetReg64(system, 1)); + out_context = Convert<uint64_t>(GetArg64(args, 0)); + thread_handle = Convert<Handle>(GetArg64(args, 1)); ret = GetThreadContext364(system, out_context, thread_handle); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_WaitForAddress64(Core::System& system) { +static void SvcWrap_WaitForAddress64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t address{}; @@ -2788,17 +2788,17 @@ static void SvcWrap_WaitForAddress64(Core::System& system) { int32_t value{}; int64_t timeout_ns{}; - address = Convert<uint64_t>(GetReg64(system, 0)); - arb_type = Convert<ArbitrationType>(GetReg64(system, 1)); - value = Convert<int32_t>(GetReg64(system, 2)); - timeout_ns = Convert<int64_t>(GetReg64(system, 3)); + address = Convert<uint64_t>(GetArg64(args, 0)); + arb_type = Convert<ArbitrationType>(GetArg64(args, 1)); + value = Convert<int32_t>(GetArg64(args, 2)); + timeout_ns = Convert<int64_t>(GetArg64(args, 3)); ret = WaitForAddress64(system, address, arb_type, value, timeout_ns); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_SignalToAddress64(Core::System& system) { +static void SvcWrap_SignalToAddress64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t address{}; @@ -2806,51 +2806,51 @@ static void SvcWrap_SignalToAddress64(Core::System& system) { int32_t value{}; int32_t count{}; - address = Convert<uint64_t>(GetReg64(system, 0)); - signal_type = Convert<SignalType>(GetReg64(system, 1)); - value = Convert<int32_t>(GetReg64(system, 2)); - count = Convert<int32_t>(GetReg64(system, 3)); + address = Convert<uint64_t>(GetArg64(args, 0)); + signal_type = Convert<SignalType>(GetArg64(args, 1)); + value = Convert<int32_t>(GetArg64(args, 2)); + count = Convert<int32_t>(GetArg64(args, 3)); ret = SignalToAddress64(system, address, signal_type, value, count); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_SynchronizePreemptionState64(Core::System& system) { +static void SvcWrap_SynchronizePreemptionState64(Core::System& system, std::span<uint64_t, 8> args) { SynchronizePreemptionState64(system); } -static void SvcWrap_GetResourceLimitPeakValue64(Core::System& system) { +static void SvcWrap_GetResourceLimitPeakValue64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int64_t out_peak_value{}; Handle resource_limit_handle{}; LimitableResource which{}; - resource_limit_handle = Convert<Handle>(GetReg64(system, 1)); - which = Convert<LimitableResource>(GetReg64(system, 2)); + resource_limit_handle = Convert<Handle>(GetArg64(args, 1)); + which = Convert<LimitableResource>(GetArg64(args, 2)); ret = GetResourceLimitPeakValue64(system, std::addressof(out_peak_value), resource_limit_handle, which); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_peak_value)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_peak_value)); } -static void SvcWrap_CreateIoPool64(Core::System& system) { +static void SvcWrap_CreateIoPool64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; IoPoolType which{}; - which = Convert<IoPoolType>(GetReg64(system, 1)); + which = Convert<IoPoolType>(GetArg64(args, 1)); ret = CreateIoPool64(system, std::addressof(out_handle), which); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_handle)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_handle)); } -static void SvcWrap_CreateIoRegion64(Core::System& system) { +static void SvcWrap_CreateIoRegion64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; @@ -2860,41 +2860,41 @@ static void SvcWrap_CreateIoRegion64(Core::System& system) { MemoryMapping mapping{}; MemoryPermission perm{}; - io_pool = Convert<Handle>(GetReg64(system, 1)); - physical_address = Convert<uint64_t>(GetReg64(system, 2)); - size = Convert<uint64_t>(GetReg64(system, 3)); - mapping = Convert<MemoryMapping>(GetReg64(system, 4)); - perm = Convert<MemoryPermission>(GetReg64(system, 5)); + io_pool = Convert<Handle>(GetArg64(args, 1)); + physical_address = Convert<uint64_t>(GetArg64(args, 2)); + size = Convert<uint64_t>(GetArg64(args, 3)); + mapping = Convert<MemoryMapping>(GetArg64(args, 4)); + perm = Convert<MemoryPermission>(GetArg64(args, 5)); ret = CreateIoRegion64(system, std::addressof(out_handle), io_pool, physical_address, size, mapping, perm); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_handle)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_handle)); } -static void SvcWrap_KernelDebug64(Core::System& system) { +static void SvcWrap_KernelDebug64(Core::System& system, std::span<uint64_t, 8> args) { KernelDebugType kern_debug_type{}; uint64_t arg0{}; uint64_t arg1{}; uint64_t arg2{}; - kern_debug_type = Convert<KernelDebugType>(GetReg64(system, 0)); - arg0 = Convert<uint64_t>(GetReg64(system, 1)); - arg1 = Convert<uint64_t>(GetReg64(system, 2)); - arg2 = Convert<uint64_t>(GetReg64(system, 3)); + kern_debug_type = Convert<KernelDebugType>(GetArg64(args, 0)); + arg0 = Convert<uint64_t>(GetArg64(args, 1)); + arg1 = Convert<uint64_t>(GetArg64(args, 2)); + arg2 = Convert<uint64_t>(GetArg64(args, 3)); KernelDebug64(system, kern_debug_type, arg0, arg1, arg2); } -static void SvcWrap_ChangeKernelTraceState64(Core::System& system) { +static void SvcWrap_ChangeKernelTraceState64(Core::System& system, std::span<uint64_t, 8> args) { KernelTraceState kern_trace_state{}; - kern_trace_state = Convert<KernelTraceState>(GetReg64(system, 0)); + kern_trace_state = Convert<KernelTraceState>(GetArg64(args, 0)); ChangeKernelTraceState64(system, kern_trace_state); } -static void SvcWrap_CreateSession64(Core::System& system) { +static void SvcWrap_CreateSession64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_server_session_handle{}; @@ -2902,31 +2902,31 @@ static void SvcWrap_CreateSession64(Core::System& system) { bool is_light{}; uint64_t name{}; - is_light = Convert<bool>(GetReg64(system, 2)); - name = Convert<uint64_t>(GetReg64(system, 3)); + is_light = Convert<bool>(GetArg64(args, 2)); + name = Convert<uint64_t>(GetArg64(args, 3)); ret = CreateSession64(system, std::addressof(out_server_session_handle), std::addressof(out_client_session_handle), is_light, name); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_server_session_handle)); - SetReg64(system, 2, Convert<uint64_t>(out_client_session_handle)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_server_session_handle)); + SetArg64(args, 2, Convert<uint64_t>(out_client_session_handle)); } -static void SvcWrap_AcceptSession64(Core::System& system) { +static void SvcWrap_AcceptSession64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; Handle port{}; - port = Convert<Handle>(GetReg64(system, 1)); + port = Convert<Handle>(GetArg64(args, 1)); ret = AcceptSession64(system, std::addressof(out_handle), port); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_handle)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_handle)); } -static void SvcWrap_ReplyAndReceive64(Core::System& system) { +static void SvcWrap_ReplyAndReceive64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int32_t out_index{}; @@ -2935,18 +2935,18 @@ static void SvcWrap_ReplyAndReceive64(Core::System& system) { Handle reply_target{}; int64_t timeout_ns{}; - handles = Convert<uint64_t>(GetReg64(system, 1)); - num_handles = Convert<int32_t>(GetReg64(system, 2)); - reply_target = Convert<Handle>(GetReg64(system, 3)); - timeout_ns = Convert<int64_t>(GetReg64(system, 4)); + handles = Convert<uint64_t>(GetArg64(args, 1)); + num_handles = Convert<int32_t>(GetArg64(args, 2)); + reply_target = Convert<Handle>(GetArg64(args, 3)); + timeout_ns = Convert<int64_t>(GetArg64(args, 4)); ret = ReplyAndReceive64(system, std::addressof(out_index), handles, num_handles, reply_target, timeout_ns); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_index)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_index)); } -static void SvcWrap_ReplyAndReceiveWithUserBuffer64(Core::System& system) { +static void SvcWrap_ReplyAndReceiveWithUserBuffer64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int32_t out_index{}; @@ -2957,20 +2957,20 @@ static void SvcWrap_ReplyAndReceiveWithUserBuffer64(Core::System& system) { Handle reply_target{}; int64_t timeout_ns{}; - message_buffer = Convert<uint64_t>(GetReg64(system, 1)); - message_buffer_size = Convert<uint64_t>(GetReg64(system, 2)); - handles = Convert<uint64_t>(GetReg64(system, 3)); - num_handles = Convert<int32_t>(GetReg64(system, 4)); - reply_target = Convert<Handle>(GetReg64(system, 5)); - timeout_ns = Convert<int64_t>(GetReg64(system, 6)); + message_buffer = Convert<uint64_t>(GetArg64(args, 1)); + message_buffer_size = Convert<uint64_t>(GetArg64(args, 2)); + handles = Convert<uint64_t>(GetArg64(args, 3)); + num_handles = Convert<int32_t>(GetArg64(args, 4)); + reply_target = Convert<Handle>(GetArg64(args, 5)); + timeout_ns = Convert<int64_t>(GetArg64(args, 6)); ret = ReplyAndReceiveWithUserBuffer64(system, std::addressof(out_index), message_buffer, message_buffer_size, handles, num_handles, reply_target, timeout_ns); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_index)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_index)); } -static void SvcWrap_CreateEvent64(Core::System& system) { +static void SvcWrap_CreateEvent64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_write_handle{}; @@ -2978,12 +2978,12 @@ static void SvcWrap_CreateEvent64(Core::System& system) { ret = CreateEvent64(system, std::addressof(out_write_handle), std::addressof(out_read_handle)); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_write_handle)); - SetReg64(system, 2, Convert<uint64_t>(out_read_handle)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_write_handle)); + SetArg64(args, 2, Convert<uint64_t>(out_read_handle)); } -static void SvcWrap_MapIoRegion64(Core::System& system) { +static void SvcWrap_MapIoRegion64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle io_region{}; @@ -2991,89 +2991,89 @@ static void SvcWrap_MapIoRegion64(Core::System& system) { uint64_t size{}; MemoryPermission perm{}; - io_region = Convert<Handle>(GetReg64(system, 0)); - address = Convert<uint64_t>(GetReg64(system, 1)); - size = Convert<uint64_t>(GetReg64(system, 2)); - perm = Convert<MemoryPermission>(GetReg64(system, 3)); + io_region = Convert<Handle>(GetArg64(args, 0)); + address = Convert<uint64_t>(GetArg64(args, 1)); + size = Convert<uint64_t>(GetArg64(args, 2)); + perm = Convert<MemoryPermission>(GetArg64(args, 3)); ret = MapIoRegion64(system, io_region, address, size, perm); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_UnmapIoRegion64(Core::System& system) { +static void SvcWrap_UnmapIoRegion64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle io_region{}; uint64_t address{}; uint64_t size{}; - io_region = Convert<Handle>(GetReg64(system, 0)); - address = Convert<uint64_t>(GetReg64(system, 1)); - size = Convert<uint64_t>(GetReg64(system, 2)); + io_region = Convert<Handle>(GetArg64(args, 0)); + address = Convert<uint64_t>(GetArg64(args, 1)); + size = Convert<uint64_t>(GetArg64(args, 2)); ret = UnmapIoRegion64(system, io_region, address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_MapPhysicalMemoryUnsafe64(Core::System& system) { +static void SvcWrap_MapPhysicalMemoryUnsafe64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t address{}; uint64_t size{}; - address = Convert<uint64_t>(GetReg64(system, 0)); - size = Convert<uint64_t>(GetReg64(system, 1)); + address = Convert<uint64_t>(GetArg64(args, 0)); + size = Convert<uint64_t>(GetArg64(args, 1)); ret = MapPhysicalMemoryUnsafe64(system, address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_UnmapPhysicalMemoryUnsafe64(Core::System& system) { +static void SvcWrap_UnmapPhysicalMemoryUnsafe64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t address{}; uint64_t size{}; - address = Convert<uint64_t>(GetReg64(system, 0)); - size = Convert<uint64_t>(GetReg64(system, 1)); + address = Convert<uint64_t>(GetArg64(args, 0)); + size = Convert<uint64_t>(GetArg64(args, 1)); ret = UnmapPhysicalMemoryUnsafe64(system, address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_SetUnsafeLimit64(Core::System& system) { +static void SvcWrap_SetUnsafeLimit64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t limit{}; - limit = Convert<uint64_t>(GetReg64(system, 0)); + limit = Convert<uint64_t>(GetArg64(args, 0)); ret = SetUnsafeLimit64(system, limit); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_CreateCodeMemory64(Core::System& system) { +static void SvcWrap_CreateCodeMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; uint64_t address{}; uint64_t size{}; - address = Convert<uint64_t>(GetReg64(system, 1)); - size = Convert<uint64_t>(GetReg64(system, 2)); + address = Convert<uint64_t>(GetArg64(args, 1)); + size = Convert<uint64_t>(GetArg64(args, 2)); ret = CreateCodeMemory64(system, std::addressof(out_handle), address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_handle)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_handle)); } -static void SvcWrap_ControlCodeMemory64(Core::System& system) { +static void SvcWrap_ControlCodeMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle code_memory_handle{}; @@ -3082,22 +3082,22 @@ static void SvcWrap_ControlCodeMemory64(Core::System& system) { uint64_t size{}; MemoryPermission perm{}; - code_memory_handle = Convert<Handle>(GetReg64(system, 0)); - operation = Convert<CodeMemoryOperation>(GetReg64(system, 1)); - address = Convert<uint64_t>(GetReg64(system, 2)); - size = Convert<uint64_t>(GetReg64(system, 3)); - perm = Convert<MemoryPermission>(GetReg64(system, 4)); + code_memory_handle = Convert<Handle>(GetArg64(args, 0)); + operation = Convert<CodeMemoryOperation>(GetArg64(args, 1)); + address = Convert<uint64_t>(GetArg64(args, 2)); + size = Convert<uint64_t>(GetArg64(args, 3)); + perm = Convert<MemoryPermission>(GetArg64(args, 4)); ret = ControlCodeMemory64(system, code_memory_handle, operation, address, size, perm); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_SleepSystem64(Core::System& system) { +static void SvcWrap_SleepSystem64(Core::System& system, std::span<uint64_t, 8> args) { SleepSystem64(system); } -static void SvcWrap_ReadWriteRegister64(Core::System& system) { +static void SvcWrap_ReadWriteRegister64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint32_t out_value{}; @@ -3105,31 +3105,31 @@ static void SvcWrap_ReadWriteRegister64(Core::System& system) { uint32_t mask{}; uint32_t value{}; - address = Convert<uint64_t>(GetReg64(system, 1)); - mask = Convert<uint32_t>(GetReg64(system, 2)); - value = Convert<uint32_t>(GetReg64(system, 3)); + address = Convert<uint64_t>(GetArg64(args, 1)); + mask = Convert<uint32_t>(GetArg64(args, 2)); + value = Convert<uint32_t>(GetArg64(args, 3)); ret = ReadWriteRegister64(system, std::addressof(out_value), address, mask, value); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_value)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_value)); } -static void SvcWrap_SetProcessActivity64(Core::System& system) { +static void SvcWrap_SetProcessActivity64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle process_handle{}; ProcessActivity process_activity{}; - process_handle = Convert<Handle>(GetReg64(system, 0)); - process_activity = Convert<ProcessActivity>(GetReg64(system, 1)); + process_handle = Convert<Handle>(GetArg64(args, 0)); + process_activity = Convert<ProcessActivity>(GetArg64(args, 1)); ret = SetProcessActivity64(system, process_handle, process_activity); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_CreateSharedMemory64(Core::System& system) { +static void SvcWrap_CreateSharedMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; @@ -3137,17 +3137,17 @@ static void SvcWrap_CreateSharedMemory64(Core::System& system) { MemoryPermission owner_perm{}; MemoryPermission remote_perm{}; - size = Convert<uint64_t>(GetReg64(system, 1)); - owner_perm = Convert<MemoryPermission>(GetReg64(system, 2)); - remote_perm = Convert<MemoryPermission>(GetReg64(system, 3)); + size = Convert<uint64_t>(GetArg64(args, 1)); + owner_perm = Convert<MemoryPermission>(GetArg64(args, 2)); + remote_perm = Convert<MemoryPermission>(GetArg64(args, 3)); ret = CreateSharedMemory64(system, std::addressof(out_handle), size, owner_perm, remote_perm); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_handle)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_handle)); } -static void SvcWrap_MapTransferMemory64(Core::System& system) { +static void SvcWrap_MapTransferMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle trmem_handle{}; @@ -3155,66 +3155,66 @@ static void SvcWrap_MapTransferMemory64(Core::System& system) { uint64_t size{}; MemoryPermission owner_perm{}; - trmem_handle = Convert<Handle>(GetReg64(system, 0)); - address = Convert<uint64_t>(GetReg64(system, 1)); - size = Convert<uint64_t>(GetReg64(system, 2)); - owner_perm = Convert<MemoryPermission>(GetReg64(system, 3)); + trmem_handle = Convert<Handle>(GetArg64(args, 0)); + address = Convert<uint64_t>(GetArg64(args, 1)); + size = Convert<uint64_t>(GetArg64(args, 2)); + owner_perm = Convert<MemoryPermission>(GetArg64(args, 3)); ret = MapTransferMemory64(system, trmem_handle, address, size, owner_perm); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_UnmapTransferMemory64(Core::System& system) { +static void SvcWrap_UnmapTransferMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle trmem_handle{}; uint64_t address{}; uint64_t size{}; - trmem_handle = Convert<Handle>(GetReg64(system, 0)); - address = Convert<uint64_t>(GetReg64(system, 1)); - size = Convert<uint64_t>(GetReg64(system, 2)); + trmem_handle = Convert<Handle>(GetArg64(args, 0)); + address = Convert<uint64_t>(GetArg64(args, 1)); + size = Convert<uint64_t>(GetArg64(args, 2)); ret = UnmapTransferMemory64(system, trmem_handle, address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_CreateInterruptEvent64(Core::System& system) { +static void SvcWrap_CreateInterruptEvent64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_read_handle{}; int32_t interrupt_id{}; InterruptType interrupt_type{}; - interrupt_id = Convert<int32_t>(GetReg64(system, 1)); - interrupt_type = Convert<InterruptType>(GetReg64(system, 2)); + interrupt_id = Convert<int32_t>(GetArg64(args, 1)); + interrupt_type = Convert<InterruptType>(GetArg64(args, 2)); ret = CreateInterruptEvent64(system, std::addressof(out_read_handle), interrupt_id, interrupt_type); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_read_handle)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_read_handle)); } -static void SvcWrap_QueryPhysicalAddress64(Core::System& system) { +static void SvcWrap_QueryPhysicalAddress64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; lp64::PhysicalMemoryInfo out_info{}; uint64_t address{}; - address = Convert<uint64_t>(GetReg64(system, 1)); + address = Convert<uint64_t>(GetArg64(args, 1)); ret = QueryPhysicalAddress64(system, std::addressof(out_info), address); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); auto out_info_scatter = Convert<std::array<uint64_t, 3>>(out_info); - SetReg64(system, 1, out_info_scatter[0]); - SetReg64(system, 2, out_info_scatter[1]); - SetReg64(system, 3, out_info_scatter[2]); + SetArg64(args, 1, out_info_scatter[0]); + SetArg64(args, 2, out_info_scatter[1]); + SetArg64(args, 3, out_info_scatter[2]); } -static void SvcWrap_QueryIoMapping64(Core::System& system) { +static void SvcWrap_QueryIoMapping64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t out_address{}; @@ -3222,61 +3222,61 @@ static void SvcWrap_QueryIoMapping64(Core::System& system) { uint64_t physical_address{}; uint64_t size{}; - physical_address = Convert<uint64_t>(GetReg64(system, 2)); - size = Convert<uint64_t>(GetReg64(system, 3)); + physical_address = Convert<uint64_t>(GetArg64(args, 2)); + size = Convert<uint64_t>(GetArg64(args, 3)); ret = QueryIoMapping64(system, std::addressof(out_address), std::addressof(out_size), physical_address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_address)); - SetReg64(system, 2, Convert<uint64_t>(out_size)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_address)); + SetArg64(args, 2, Convert<uint64_t>(out_size)); } -static void SvcWrap_CreateDeviceAddressSpace64(Core::System& system) { +static void SvcWrap_CreateDeviceAddressSpace64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; uint64_t das_address{}; uint64_t das_size{}; - das_address = Convert<uint64_t>(GetReg64(system, 1)); - das_size = Convert<uint64_t>(GetReg64(system, 2)); + das_address = Convert<uint64_t>(GetArg64(args, 1)); + das_size = Convert<uint64_t>(GetArg64(args, 2)); ret = CreateDeviceAddressSpace64(system, std::addressof(out_handle), das_address, das_size); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_handle)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_handle)); } -static void SvcWrap_AttachDeviceAddressSpace64(Core::System& system) { +static void SvcWrap_AttachDeviceAddressSpace64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; DeviceName device_name{}; Handle das_handle{}; - device_name = Convert<DeviceName>(GetReg64(system, 0)); - das_handle = Convert<Handle>(GetReg64(system, 1)); + device_name = Convert<DeviceName>(GetArg64(args, 0)); + das_handle = Convert<Handle>(GetArg64(args, 1)); ret = AttachDeviceAddressSpace64(system, device_name, das_handle); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_DetachDeviceAddressSpace64(Core::System& system) { +static void SvcWrap_DetachDeviceAddressSpace64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; DeviceName device_name{}; Handle das_handle{}; - device_name = Convert<DeviceName>(GetReg64(system, 0)); - das_handle = Convert<Handle>(GetReg64(system, 1)); + device_name = Convert<DeviceName>(GetArg64(args, 0)); + das_handle = Convert<Handle>(GetArg64(args, 1)); ret = DetachDeviceAddressSpace64(system, device_name, das_handle); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_MapDeviceAddressSpaceByForce64(Core::System& system) { +static void SvcWrap_MapDeviceAddressSpaceByForce64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle das_handle{}; @@ -3286,19 +3286,19 @@ static void SvcWrap_MapDeviceAddressSpaceByForce64(Core::System& system) { uint64_t device_address{}; uint32_t option{}; - das_handle = Convert<Handle>(GetReg64(system, 0)); - process_handle = Convert<Handle>(GetReg64(system, 1)); - process_address = Convert<uint64_t>(GetReg64(system, 2)); - size = Convert<uint64_t>(GetReg64(system, 3)); - device_address = Convert<uint64_t>(GetReg64(system, 4)); - option = Convert<uint32_t>(GetReg64(system, 5)); + das_handle = Convert<Handle>(GetArg64(args, 0)); + process_handle = Convert<Handle>(GetArg64(args, 1)); + process_address = Convert<uint64_t>(GetArg64(args, 2)); + size = Convert<uint64_t>(GetArg64(args, 3)); + device_address = Convert<uint64_t>(GetArg64(args, 4)); + option = Convert<uint32_t>(GetArg64(args, 5)); ret = MapDeviceAddressSpaceByForce64(system, das_handle, process_handle, process_address, size, device_address, option); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_MapDeviceAddressSpaceAligned64(Core::System& system) { +static void SvcWrap_MapDeviceAddressSpaceAligned64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle das_handle{}; @@ -3308,19 +3308,19 @@ static void SvcWrap_MapDeviceAddressSpaceAligned64(Core::System& system) { uint64_t device_address{}; uint32_t option{}; - das_handle = Convert<Handle>(GetReg64(system, 0)); - process_handle = Convert<Handle>(GetReg64(system, 1)); - process_address = Convert<uint64_t>(GetReg64(system, 2)); - size = Convert<uint64_t>(GetReg64(system, 3)); - device_address = Convert<uint64_t>(GetReg64(system, 4)); - option = Convert<uint32_t>(GetReg64(system, 5)); + das_handle = Convert<Handle>(GetArg64(args, 0)); + process_handle = Convert<Handle>(GetArg64(args, 1)); + process_address = Convert<uint64_t>(GetArg64(args, 2)); + size = Convert<uint64_t>(GetArg64(args, 3)); + device_address = Convert<uint64_t>(GetArg64(args, 4)); + option = Convert<uint32_t>(GetArg64(args, 5)); ret = MapDeviceAddressSpaceAligned64(system, das_handle, process_handle, process_address, size, device_address, option); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_UnmapDeviceAddressSpace64(Core::System& system) { +static void SvcWrap_UnmapDeviceAddressSpace64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle das_handle{}; @@ -3329,118 +3329,118 @@ static void SvcWrap_UnmapDeviceAddressSpace64(Core::System& system) { uint64_t size{}; uint64_t device_address{}; - das_handle = Convert<Handle>(GetReg64(system, 0)); - process_handle = Convert<Handle>(GetReg64(system, 1)); - process_address = Convert<uint64_t>(GetReg64(system, 2)); - size = Convert<uint64_t>(GetReg64(system, 3)); - device_address = Convert<uint64_t>(GetReg64(system, 4)); + das_handle = Convert<Handle>(GetArg64(args, 0)); + process_handle = Convert<Handle>(GetArg64(args, 1)); + process_address = Convert<uint64_t>(GetArg64(args, 2)); + size = Convert<uint64_t>(GetArg64(args, 3)); + device_address = Convert<uint64_t>(GetArg64(args, 4)); ret = UnmapDeviceAddressSpace64(system, das_handle, process_handle, process_address, size, device_address); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_InvalidateProcessDataCache64(Core::System& system) { +static void SvcWrap_InvalidateProcessDataCache64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle process_handle{}; uint64_t address{}; uint64_t size{}; - process_handle = Convert<Handle>(GetReg64(system, 0)); - address = Convert<uint64_t>(GetReg64(system, 1)); - size = Convert<uint64_t>(GetReg64(system, 2)); + process_handle = Convert<Handle>(GetArg64(args, 0)); + address = Convert<uint64_t>(GetArg64(args, 1)); + size = Convert<uint64_t>(GetArg64(args, 2)); ret = InvalidateProcessDataCache64(system, process_handle, address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_StoreProcessDataCache64(Core::System& system) { +static void SvcWrap_StoreProcessDataCache64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle process_handle{}; uint64_t address{}; uint64_t size{}; - process_handle = Convert<Handle>(GetReg64(system, 0)); - address = Convert<uint64_t>(GetReg64(system, 1)); - size = Convert<uint64_t>(GetReg64(system, 2)); + process_handle = Convert<Handle>(GetArg64(args, 0)); + address = Convert<uint64_t>(GetArg64(args, 1)); + size = Convert<uint64_t>(GetArg64(args, 2)); ret = StoreProcessDataCache64(system, process_handle, address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_FlushProcessDataCache64(Core::System& system) { +static void SvcWrap_FlushProcessDataCache64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle process_handle{}; uint64_t address{}; uint64_t size{}; - process_handle = Convert<Handle>(GetReg64(system, 0)); - address = Convert<uint64_t>(GetReg64(system, 1)); - size = Convert<uint64_t>(GetReg64(system, 2)); + process_handle = Convert<Handle>(GetArg64(args, 0)); + address = Convert<uint64_t>(GetArg64(args, 1)); + size = Convert<uint64_t>(GetArg64(args, 2)); ret = FlushProcessDataCache64(system, process_handle, address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_DebugActiveProcess64(Core::System& system) { +static void SvcWrap_DebugActiveProcess64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; uint64_t process_id{}; - process_id = Convert<uint64_t>(GetReg64(system, 1)); + process_id = Convert<uint64_t>(GetArg64(args, 1)); ret = DebugActiveProcess64(system, std::addressof(out_handle), process_id); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_handle)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_handle)); } -static void SvcWrap_BreakDebugProcess64(Core::System& system) { +static void SvcWrap_BreakDebugProcess64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle debug_handle{}; - debug_handle = Convert<Handle>(GetReg64(system, 0)); + debug_handle = Convert<Handle>(GetArg64(args, 0)); ret = BreakDebugProcess64(system, debug_handle); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_TerminateDebugProcess64(Core::System& system) { +static void SvcWrap_TerminateDebugProcess64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle debug_handle{}; - debug_handle = Convert<Handle>(GetReg64(system, 0)); + debug_handle = Convert<Handle>(GetArg64(args, 0)); ret = TerminateDebugProcess64(system, debug_handle); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_GetDebugEvent64(Core::System& system) { +static void SvcWrap_GetDebugEvent64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t out_info{}; Handle debug_handle{}; - out_info = Convert<uint64_t>(GetReg64(system, 0)); - debug_handle = Convert<Handle>(GetReg64(system, 1)); + out_info = Convert<uint64_t>(GetArg64(args, 0)); + debug_handle = Convert<Handle>(GetArg64(args, 1)); ret = GetDebugEvent64(system, out_info, debug_handle); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_ContinueDebugEvent64(Core::System& system) { +static void SvcWrap_ContinueDebugEvent64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle debug_handle{}; @@ -3448,33 +3448,33 @@ static void SvcWrap_ContinueDebugEvent64(Core::System& system) { uint64_t thread_ids{}; int32_t num_thread_ids{}; - debug_handle = Convert<Handle>(GetReg64(system, 0)); - flags = Convert<uint32_t>(GetReg64(system, 1)); - thread_ids = Convert<uint64_t>(GetReg64(system, 2)); - num_thread_ids = Convert<int32_t>(GetReg64(system, 3)); + debug_handle = Convert<Handle>(GetArg64(args, 0)); + flags = Convert<uint32_t>(GetArg64(args, 1)); + thread_ids = Convert<uint64_t>(GetArg64(args, 2)); + num_thread_ids = Convert<int32_t>(GetArg64(args, 3)); ret = ContinueDebugEvent64(system, debug_handle, flags, thread_ids, num_thread_ids); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_GetProcessList64(Core::System& system) { +static void SvcWrap_GetProcessList64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int32_t out_num_processes{}; uint64_t out_process_ids{}; int32_t max_out_count{}; - out_process_ids = Convert<uint64_t>(GetReg64(system, 1)); - max_out_count = Convert<int32_t>(GetReg64(system, 2)); + out_process_ids = Convert<uint64_t>(GetArg64(args, 1)); + max_out_count = Convert<int32_t>(GetArg64(args, 2)); ret = GetProcessList64(system, std::addressof(out_num_processes), out_process_ids, max_out_count); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_num_processes)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_num_processes)); } -static void SvcWrap_GetThreadList64(Core::System& system) { +static void SvcWrap_GetThreadList64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int32_t out_num_threads{}; @@ -3482,17 +3482,17 @@ static void SvcWrap_GetThreadList64(Core::System& system) { int32_t max_out_count{}; Handle debug_handle{}; - out_thread_ids = Convert<uint64_t>(GetReg64(system, 1)); - max_out_count = Convert<int32_t>(GetReg64(system, 2)); - debug_handle = Convert<Handle>(GetReg64(system, 3)); + out_thread_ids = Convert<uint64_t>(GetArg64(args, 1)); + max_out_count = Convert<int32_t>(GetArg64(args, 2)); + debug_handle = Convert<Handle>(GetArg64(args, 3)); ret = GetThreadList64(system, std::addressof(out_num_threads), out_thread_ids, max_out_count, debug_handle); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_num_threads)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_num_threads)); } -static void SvcWrap_GetDebugThreadContext64(Core::System& system) { +static void SvcWrap_GetDebugThreadContext64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t out_context{}; @@ -3500,17 +3500,17 @@ static void SvcWrap_GetDebugThreadContext64(Core::System& system) { uint64_t thread_id{}; uint32_t context_flags{}; - out_context = Convert<uint64_t>(GetReg64(system, 0)); - debug_handle = Convert<Handle>(GetReg64(system, 1)); - thread_id = Convert<uint64_t>(GetReg64(system, 2)); - context_flags = Convert<uint32_t>(GetReg64(system, 3)); + out_context = Convert<uint64_t>(GetArg64(args, 0)); + debug_handle = Convert<Handle>(GetArg64(args, 1)); + thread_id = Convert<uint64_t>(GetArg64(args, 2)); + context_flags = Convert<uint32_t>(GetArg64(args, 3)); ret = GetDebugThreadContext64(system, out_context, debug_handle, thread_id, context_flags); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_SetDebugThreadContext64(Core::System& system) { +static void SvcWrap_SetDebugThreadContext64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle debug_handle{}; @@ -3518,17 +3518,17 @@ static void SvcWrap_SetDebugThreadContext64(Core::System& system) { uint64_t context{}; uint32_t context_flags{}; - debug_handle = Convert<Handle>(GetReg64(system, 0)); - thread_id = Convert<uint64_t>(GetReg64(system, 1)); - context = Convert<uint64_t>(GetReg64(system, 2)); - context_flags = Convert<uint32_t>(GetReg64(system, 3)); + debug_handle = Convert<Handle>(GetArg64(args, 0)); + thread_id = Convert<uint64_t>(GetArg64(args, 1)); + context = Convert<uint64_t>(GetArg64(args, 2)); + context_flags = Convert<uint32_t>(GetArg64(args, 3)); ret = SetDebugThreadContext64(system, debug_handle, thread_id, context, context_flags); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_QueryDebugProcessMemory64(Core::System& system) { +static void SvcWrap_QueryDebugProcessMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; PageInfo out_page_info{}; @@ -3536,17 +3536,17 @@ static void SvcWrap_QueryDebugProcessMemory64(Core::System& system) { Handle process_handle{}; uint64_t address{}; - out_memory_info = Convert<uint64_t>(GetReg64(system, 0)); - process_handle = Convert<Handle>(GetReg64(system, 2)); - address = Convert<uint64_t>(GetReg64(system, 3)); + out_memory_info = Convert<uint64_t>(GetArg64(args, 0)); + process_handle = Convert<Handle>(GetArg64(args, 2)); + address = Convert<uint64_t>(GetArg64(args, 3)); ret = QueryDebugProcessMemory64(system, out_memory_info, std::addressof(out_page_info), process_handle, address); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_page_info)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_page_info)); } -static void SvcWrap_ReadDebugProcessMemory64(Core::System& system) { +static void SvcWrap_ReadDebugProcessMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t buffer{}; @@ -3554,17 +3554,17 @@ static void SvcWrap_ReadDebugProcessMemory64(Core::System& system) { uint64_t address{}; uint64_t size{}; - buffer = Convert<uint64_t>(GetReg64(system, 0)); - debug_handle = Convert<Handle>(GetReg64(system, 1)); - address = Convert<uint64_t>(GetReg64(system, 2)); - size = Convert<uint64_t>(GetReg64(system, 3)); + buffer = Convert<uint64_t>(GetArg64(args, 0)); + debug_handle = Convert<Handle>(GetArg64(args, 1)); + address = Convert<uint64_t>(GetArg64(args, 2)); + size = Convert<uint64_t>(GetArg64(args, 3)); ret = ReadDebugProcessMemory64(system, buffer, debug_handle, address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_WriteDebugProcessMemory64(Core::System& system) { +static void SvcWrap_WriteDebugProcessMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle debug_handle{}; @@ -3572,33 +3572,33 @@ static void SvcWrap_WriteDebugProcessMemory64(Core::System& system) { uint64_t address{}; uint64_t size{}; - debug_handle = Convert<Handle>(GetReg64(system, 0)); - buffer = Convert<uint64_t>(GetReg64(system, 1)); - address = Convert<uint64_t>(GetReg64(system, 2)); - size = Convert<uint64_t>(GetReg64(system, 3)); + debug_handle = Convert<Handle>(GetArg64(args, 0)); + buffer = Convert<uint64_t>(GetArg64(args, 1)); + address = Convert<uint64_t>(GetArg64(args, 2)); + size = Convert<uint64_t>(GetArg64(args, 3)); ret = WriteDebugProcessMemory64(system, debug_handle, buffer, address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_SetHardwareBreakPoint64(Core::System& system) { +static void SvcWrap_SetHardwareBreakPoint64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; HardwareBreakPointRegisterName name{}; uint64_t flags{}; uint64_t value{}; - name = Convert<HardwareBreakPointRegisterName>(GetReg64(system, 0)); - flags = Convert<uint64_t>(GetReg64(system, 1)); - value = Convert<uint64_t>(GetReg64(system, 2)); + name = Convert<HardwareBreakPointRegisterName>(GetArg64(args, 0)); + flags = Convert<uint64_t>(GetArg64(args, 1)); + value = Convert<uint64_t>(GetArg64(args, 2)); ret = SetHardwareBreakPoint64(system, name, flags, value); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_GetDebugThreadParam64(Core::System& system) { +static void SvcWrap_GetDebugThreadParam64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t out_64{}; @@ -3607,18 +3607,18 @@ static void SvcWrap_GetDebugThreadParam64(Core::System& system) { uint64_t thread_id{}; DebugThreadParam param{}; - debug_handle = Convert<Handle>(GetReg64(system, 2)); - thread_id = Convert<uint64_t>(GetReg64(system, 3)); - param = Convert<DebugThreadParam>(GetReg64(system, 4)); + debug_handle = Convert<Handle>(GetArg64(args, 2)); + thread_id = Convert<uint64_t>(GetArg64(args, 3)); + param = Convert<DebugThreadParam>(GetArg64(args, 4)); ret = GetDebugThreadParam64(system, std::addressof(out_64), std::addressof(out_32), debug_handle, thread_id, param); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_64)); - SetReg64(system, 2, Convert<uint64_t>(out_32)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_64)); + SetArg64(args, 2, Convert<uint64_t>(out_32)); } -static void SvcWrap_GetSystemInfo64(Core::System& system) { +static void SvcWrap_GetSystemInfo64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t out{}; @@ -3626,17 +3626,17 @@ static void SvcWrap_GetSystemInfo64(Core::System& system) { Handle handle{}; uint64_t info_subtype{}; - info_type = Convert<SystemInfoType>(GetReg64(system, 1)); - handle = Convert<Handle>(GetReg64(system, 2)); - info_subtype = Convert<uint64_t>(GetReg64(system, 3)); + info_type = Convert<SystemInfoType>(GetArg64(args, 1)); + handle = Convert<Handle>(GetArg64(args, 2)); + info_subtype = Convert<uint64_t>(GetArg64(args, 3)); ret = GetSystemInfo64(system, std::addressof(out), info_type, handle, info_subtype); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out)); } -static void SvcWrap_CreatePort64(Core::System& system) { +static void SvcWrap_CreatePort64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_server_handle{}; @@ -3645,48 +3645,48 @@ static void SvcWrap_CreatePort64(Core::System& system) { bool is_light{}; uint64_t name{}; - max_sessions = Convert<int32_t>(GetReg64(system, 2)); - is_light = Convert<bool>(GetReg64(system, 3)); - name = Convert<uint64_t>(GetReg64(system, 4)); + max_sessions = Convert<int32_t>(GetArg64(args, 2)); + is_light = Convert<bool>(GetArg64(args, 3)); + name = Convert<uint64_t>(GetArg64(args, 4)); ret = CreatePort64(system, std::addressof(out_server_handle), std::addressof(out_client_handle), max_sessions, is_light, name); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_server_handle)); - SetReg64(system, 2, Convert<uint64_t>(out_client_handle)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_server_handle)); + SetArg64(args, 2, Convert<uint64_t>(out_client_handle)); } -static void SvcWrap_ManageNamedPort64(Core::System& system) { +static void SvcWrap_ManageNamedPort64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_server_handle{}; uint64_t name{}; int32_t max_sessions{}; - name = Convert<uint64_t>(GetReg64(system, 1)); - max_sessions = Convert<int32_t>(GetReg64(system, 2)); + name = Convert<uint64_t>(GetArg64(args, 1)); + max_sessions = Convert<int32_t>(GetArg64(args, 2)); ret = ManageNamedPort64(system, std::addressof(out_server_handle), name, max_sessions); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_server_handle)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_server_handle)); } -static void SvcWrap_ConnectToPort64(Core::System& system) { +static void SvcWrap_ConnectToPort64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; Handle port{}; - port = Convert<Handle>(GetReg64(system, 1)); + port = Convert<Handle>(GetArg64(args, 1)); ret = ConnectToPort64(system, std::addressof(out_handle), port); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_handle)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_handle)); } -static void SvcWrap_SetProcessMemoryPermission64(Core::System& system) { +static void SvcWrap_SetProcessMemoryPermission64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle process_handle{}; @@ -3694,17 +3694,17 @@ static void SvcWrap_SetProcessMemoryPermission64(Core::System& system) { uint64_t size{}; MemoryPermission perm{}; - process_handle = Convert<Handle>(GetReg64(system, 0)); - address = Convert<uint64_t>(GetReg64(system, 1)); - size = Convert<uint64_t>(GetReg64(system, 2)); - perm = Convert<MemoryPermission>(GetReg64(system, 3)); + process_handle = Convert<Handle>(GetArg64(args, 0)); + address = Convert<uint64_t>(GetArg64(args, 1)); + size = Convert<uint64_t>(GetArg64(args, 2)); + perm = Convert<MemoryPermission>(GetArg64(args, 3)); ret = SetProcessMemoryPermission64(system, process_handle, address, size, perm); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_MapProcessMemory64(Core::System& system) { +static void SvcWrap_MapProcessMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t dst_address{}; @@ -3712,17 +3712,17 @@ static void SvcWrap_MapProcessMemory64(Core::System& system) { uint64_t src_address{}; uint64_t size{}; - dst_address = Convert<uint64_t>(GetReg64(system, 0)); - process_handle = Convert<Handle>(GetReg64(system, 1)); - src_address = Convert<uint64_t>(GetReg64(system, 2)); - size = Convert<uint64_t>(GetReg64(system, 3)); + dst_address = Convert<uint64_t>(GetArg64(args, 0)); + process_handle = Convert<Handle>(GetArg64(args, 1)); + src_address = Convert<uint64_t>(GetArg64(args, 2)); + size = Convert<uint64_t>(GetArg64(args, 3)); ret = MapProcessMemory64(system, dst_address, process_handle, src_address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_UnmapProcessMemory64(Core::System& system) { +static void SvcWrap_UnmapProcessMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t dst_address{}; @@ -3730,17 +3730,17 @@ static void SvcWrap_UnmapProcessMemory64(Core::System& system) { uint64_t src_address{}; uint64_t size{}; - dst_address = Convert<uint64_t>(GetReg64(system, 0)); - process_handle = Convert<Handle>(GetReg64(system, 1)); - src_address = Convert<uint64_t>(GetReg64(system, 2)); - size = Convert<uint64_t>(GetReg64(system, 3)); + dst_address = Convert<uint64_t>(GetArg64(args, 0)); + process_handle = Convert<Handle>(GetArg64(args, 1)); + src_address = Convert<uint64_t>(GetArg64(args, 2)); + size = Convert<uint64_t>(GetArg64(args, 3)); ret = UnmapProcessMemory64(system, dst_address, process_handle, src_address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_QueryProcessMemory64(Core::System& system) { +static void SvcWrap_QueryProcessMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; PageInfo out_page_info{}; @@ -3748,17 +3748,17 @@ static void SvcWrap_QueryProcessMemory64(Core::System& system) { Handle process_handle{}; uint64_t address{}; - out_memory_info = Convert<uint64_t>(GetReg64(system, 0)); - process_handle = Convert<Handle>(GetReg64(system, 2)); - address = Convert<uint64_t>(GetReg64(system, 3)); + out_memory_info = Convert<uint64_t>(GetArg64(args, 0)); + process_handle = Convert<Handle>(GetArg64(args, 2)); + address = Convert<uint64_t>(GetArg64(args, 3)); ret = QueryProcessMemory64(system, out_memory_info, std::addressof(out_page_info), process_handle, address); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_page_info)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_page_info)); } -static void SvcWrap_MapProcessCodeMemory64(Core::System& system) { +static void SvcWrap_MapProcessCodeMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle process_handle{}; @@ -3766,17 +3766,17 @@ static void SvcWrap_MapProcessCodeMemory64(Core::System& system) { uint64_t src_address{}; uint64_t size{}; - process_handle = Convert<Handle>(GetReg64(system, 0)); - dst_address = Convert<uint64_t>(GetReg64(system, 1)); - src_address = Convert<uint64_t>(GetReg64(system, 2)); - size = Convert<uint64_t>(GetReg64(system, 3)); + process_handle = Convert<Handle>(GetArg64(args, 0)); + dst_address = Convert<uint64_t>(GetArg64(args, 1)); + src_address = Convert<uint64_t>(GetArg64(args, 2)); + size = Convert<uint64_t>(GetArg64(args, 3)); ret = MapProcessCodeMemory64(system, process_handle, dst_address, src_address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_UnmapProcessCodeMemory64(Core::System& system) { +static void SvcWrap_UnmapProcessCodeMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle process_handle{}; @@ -3784,17 +3784,17 @@ static void SvcWrap_UnmapProcessCodeMemory64(Core::System& system) { uint64_t src_address{}; uint64_t size{}; - process_handle = Convert<Handle>(GetReg64(system, 0)); - dst_address = Convert<uint64_t>(GetReg64(system, 1)); - src_address = Convert<uint64_t>(GetReg64(system, 2)); - size = Convert<uint64_t>(GetReg64(system, 3)); + process_handle = Convert<Handle>(GetArg64(args, 0)); + dst_address = Convert<uint64_t>(GetArg64(args, 1)); + src_address = Convert<uint64_t>(GetArg64(args, 2)); + size = Convert<uint64_t>(GetArg64(args, 3)); ret = UnmapProcessCodeMemory64(system, process_handle, dst_address, src_address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_CreateProcess64(Core::System& system) { +static void SvcWrap_CreateProcess64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; @@ -3802,17 +3802,17 @@ static void SvcWrap_CreateProcess64(Core::System& system) { uint64_t caps{}; int32_t num_caps{}; - parameters = Convert<uint64_t>(GetReg64(system, 1)); - caps = Convert<uint64_t>(GetReg64(system, 2)); - num_caps = Convert<int32_t>(GetReg64(system, 3)); + parameters = Convert<uint64_t>(GetArg64(args, 1)); + caps = Convert<uint64_t>(GetArg64(args, 2)); + num_caps = Convert<int32_t>(GetArg64(args, 3)); ret = CreateProcess64(system, std::addressof(out_handle), parameters, caps, num_caps); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_handle)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_handle)); } -static void SvcWrap_StartProcess64(Core::System& system) { +static void SvcWrap_StartProcess64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle process_handle{}; @@ -3820,601 +3820,601 @@ static void SvcWrap_StartProcess64(Core::System& system) { int32_t core_id{}; uint64_t main_thread_stack_size{}; - process_handle = Convert<Handle>(GetReg64(system, 0)); - priority = Convert<int32_t>(GetReg64(system, 1)); - core_id = Convert<int32_t>(GetReg64(system, 2)); - main_thread_stack_size = Convert<uint64_t>(GetReg64(system, 3)); + process_handle = Convert<Handle>(GetArg64(args, 0)); + priority = Convert<int32_t>(GetArg64(args, 1)); + core_id = Convert<int32_t>(GetArg64(args, 2)); + main_thread_stack_size = Convert<uint64_t>(GetArg64(args, 3)); ret = StartProcess64(system, process_handle, priority, core_id, main_thread_stack_size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_TerminateProcess64(Core::System& system) { +static void SvcWrap_TerminateProcess64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle process_handle{}; - process_handle = Convert<Handle>(GetReg64(system, 0)); + process_handle = Convert<Handle>(GetArg64(args, 0)); ret = TerminateProcess64(system, process_handle); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_GetProcessInfo64(Core::System& system) { +static void SvcWrap_GetProcessInfo64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; int64_t out_info{}; Handle process_handle{}; ProcessInfoType info_type{}; - process_handle = Convert<Handle>(GetReg64(system, 1)); - info_type = Convert<ProcessInfoType>(GetReg64(system, 2)); + process_handle = Convert<Handle>(GetArg64(args, 1)); + info_type = Convert<ProcessInfoType>(GetArg64(args, 2)); ret = GetProcessInfo64(system, std::addressof(out_info), process_handle, info_type); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_info)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_info)); } -static void SvcWrap_CreateResourceLimit64(Core::System& system) { +static void SvcWrap_CreateResourceLimit64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle out_handle{}; ret = CreateResourceLimit64(system, std::addressof(out_handle)); - SetReg64(system, 0, Convert<uint64_t>(ret)); - SetReg64(system, 1, Convert<uint64_t>(out_handle)); + SetArg64(args, 0, Convert<uint64_t>(ret)); + SetArg64(args, 1, Convert<uint64_t>(out_handle)); } -static void SvcWrap_SetResourceLimitLimitValue64(Core::System& system) { +static void SvcWrap_SetResourceLimitLimitValue64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; Handle resource_limit_handle{}; LimitableResource which{}; int64_t limit_value{}; - resource_limit_handle = Convert<Handle>(GetReg64(system, 0)); - which = Convert<LimitableResource>(GetReg64(system, 1)); - limit_value = Convert<int64_t>(GetReg64(system, 2)); + resource_limit_handle = Convert<Handle>(GetArg64(args, 0)); + which = Convert<LimitableResource>(GetArg64(args, 1)); + limit_value = Convert<int64_t>(GetArg64(args, 2)); ret = SetResourceLimitLimitValue64(system, resource_limit_handle, which, limit_value); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_MapInsecureMemory64(Core::System& system) { +static void SvcWrap_MapInsecureMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t address{}; uint64_t size{}; - address = Convert<uint64_t>(GetReg64(system, 0)); - size = Convert<uint64_t>(GetReg64(system, 1)); + address = Convert<uint64_t>(GetArg64(args, 0)); + size = Convert<uint64_t>(GetArg64(args, 1)); ret = MapInsecureMemory64(system, address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void SvcWrap_UnmapInsecureMemory64(Core::System& system) { +static void SvcWrap_UnmapInsecureMemory64(Core::System& system, std::span<uint64_t, 8> args) { Result ret{}; uint64_t address{}; uint64_t size{}; - address = Convert<uint64_t>(GetReg64(system, 0)); - size = Convert<uint64_t>(GetReg64(system, 1)); + address = Convert<uint64_t>(GetArg64(args, 0)); + size = Convert<uint64_t>(GetArg64(args, 1)); ret = UnmapInsecureMemory64(system, address, size); - SetReg64(system, 0, Convert<uint64_t>(ret)); + SetArg64(args, 0, Convert<uint64_t>(ret)); } -static void Call32(Core::System& system, u32 imm) { +static void Call32(Core::System& system, u32 imm, std::span<uint64_t, 8> args) { switch (static_cast<SvcId>(imm)) { case SvcId::SetHeapSize: - return SvcWrap_SetHeapSize64From32(system); + return SvcWrap_SetHeapSize64From32(system, args); case SvcId::SetMemoryPermission: - return SvcWrap_SetMemoryPermission64From32(system); + return SvcWrap_SetMemoryPermission64From32(system, args); case SvcId::SetMemoryAttribute: - return SvcWrap_SetMemoryAttribute64From32(system); + return SvcWrap_SetMemoryAttribute64From32(system, args); case SvcId::MapMemory: - return SvcWrap_MapMemory64From32(system); + return SvcWrap_MapMemory64From32(system, args); case SvcId::UnmapMemory: - return SvcWrap_UnmapMemory64From32(system); + return SvcWrap_UnmapMemory64From32(system, args); case SvcId::QueryMemory: - return SvcWrap_QueryMemory64From32(system); + return SvcWrap_QueryMemory64From32(system, args); case SvcId::ExitProcess: - return SvcWrap_ExitProcess64From32(system); + return SvcWrap_ExitProcess64From32(system, args); case SvcId::CreateThread: - return SvcWrap_CreateThread64From32(system); + return SvcWrap_CreateThread64From32(system, args); case SvcId::StartThread: - return SvcWrap_StartThread64From32(system); + return SvcWrap_StartThread64From32(system, args); case SvcId::ExitThread: - return SvcWrap_ExitThread64From32(system); + return SvcWrap_ExitThread64From32(system, args); case SvcId::SleepThread: - return SvcWrap_SleepThread64From32(system); + return SvcWrap_SleepThread64From32(system, args); case SvcId::GetThreadPriority: - return SvcWrap_GetThreadPriority64From32(system); + return SvcWrap_GetThreadPriority64From32(system, args); case SvcId::SetThreadPriority: - return SvcWrap_SetThreadPriority64From32(system); + return SvcWrap_SetThreadPriority64From32(system, args); case SvcId::GetThreadCoreMask: - return SvcWrap_GetThreadCoreMask64From32(system); + return SvcWrap_GetThreadCoreMask64From32(system, args); case SvcId::SetThreadCoreMask: - return SvcWrap_SetThreadCoreMask64From32(system); + return SvcWrap_SetThreadCoreMask64From32(system, args); case SvcId::GetCurrentProcessorNumber: - return SvcWrap_GetCurrentProcessorNumber64From32(system); + return SvcWrap_GetCurrentProcessorNumber64From32(system, args); case SvcId::SignalEvent: - return SvcWrap_SignalEvent64From32(system); + return SvcWrap_SignalEvent64From32(system, args); case SvcId::ClearEvent: - return SvcWrap_ClearEvent64From32(system); + return SvcWrap_ClearEvent64From32(system, args); case SvcId::MapSharedMemory: - return SvcWrap_MapSharedMemory64From32(system); + return SvcWrap_MapSharedMemory64From32(system, args); case SvcId::UnmapSharedMemory: - return SvcWrap_UnmapSharedMemory64From32(system); + return SvcWrap_UnmapSharedMemory64From32(system, args); case SvcId::CreateTransferMemory: - return SvcWrap_CreateTransferMemory64From32(system); + return SvcWrap_CreateTransferMemory64From32(system, args); case SvcId::CloseHandle: - return SvcWrap_CloseHandle64From32(system); + return SvcWrap_CloseHandle64From32(system, args); case SvcId::ResetSignal: - return SvcWrap_ResetSignal64From32(system); + return SvcWrap_ResetSignal64From32(system, args); case SvcId::WaitSynchronization: - return SvcWrap_WaitSynchronization64From32(system); + return SvcWrap_WaitSynchronization64From32(system, args); case SvcId::CancelSynchronization: - return SvcWrap_CancelSynchronization64From32(system); + return SvcWrap_CancelSynchronization64From32(system, args); case SvcId::ArbitrateLock: - return SvcWrap_ArbitrateLock64From32(system); + return SvcWrap_ArbitrateLock64From32(system, args); case SvcId::ArbitrateUnlock: - return SvcWrap_ArbitrateUnlock64From32(system); + return SvcWrap_ArbitrateUnlock64From32(system, args); case SvcId::WaitProcessWideKeyAtomic: - return SvcWrap_WaitProcessWideKeyAtomic64From32(system); + return SvcWrap_WaitProcessWideKeyAtomic64From32(system, args); case SvcId::SignalProcessWideKey: - return SvcWrap_SignalProcessWideKey64From32(system); + return SvcWrap_SignalProcessWideKey64From32(system, args); case SvcId::GetSystemTick: - return SvcWrap_GetSystemTick64From32(system); + return SvcWrap_GetSystemTick64From32(system, args); case SvcId::ConnectToNamedPort: - return SvcWrap_ConnectToNamedPort64From32(system); + return SvcWrap_ConnectToNamedPort64From32(system, args); case SvcId::SendSyncRequestLight: - return SvcWrap_SendSyncRequestLight64From32(system); + return SvcWrap_SendSyncRequestLight64From32(system, args); case SvcId::SendSyncRequest: - return SvcWrap_SendSyncRequest64From32(system); + return SvcWrap_SendSyncRequest64From32(system, args); case SvcId::SendSyncRequestWithUserBuffer: - return SvcWrap_SendSyncRequestWithUserBuffer64From32(system); + return SvcWrap_SendSyncRequestWithUserBuffer64From32(system, args); case SvcId::SendAsyncRequestWithUserBuffer: - return SvcWrap_SendAsyncRequestWithUserBuffer64From32(system); + return SvcWrap_SendAsyncRequestWithUserBuffer64From32(system, args); case SvcId::GetProcessId: - return SvcWrap_GetProcessId64From32(system); + return SvcWrap_GetProcessId64From32(system, args); case SvcId::GetThreadId: - return SvcWrap_GetThreadId64From32(system); + return SvcWrap_GetThreadId64From32(system, args); case SvcId::Break: - return SvcWrap_Break64From32(system); + return SvcWrap_Break64From32(system, args); case SvcId::OutputDebugString: - return SvcWrap_OutputDebugString64From32(system); + return SvcWrap_OutputDebugString64From32(system, args); case SvcId::ReturnFromException: - return SvcWrap_ReturnFromException64From32(system); + return SvcWrap_ReturnFromException64From32(system, args); case SvcId::GetInfo: - return SvcWrap_GetInfo64From32(system); + return SvcWrap_GetInfo64From32(system, args); case SvcId::FlushEntireDataCache: - return SvcWrap_FlushEntireDataCache64From32(system); + return SvcWrap_FlushEntireDataCache64From32(system, args); case SvcId::FlushDataCache: - return SvcWrap_FlushDataCache64From32(system); + return SvcWrap_FlushDataCache64From32(system, args); case SvcId::MapPhysicalMemory: - return SvcWrap_MapPhysicalMemory64From32(system); + return SvcWrap_MapPhysicalMemory64From32(system, args); case SvcId::UnmapPhysicalMemory: - return SvcWrap_UnmapPhysicalMemory64From32(system); + return SvcWrap_UnmapPhysicalMemory64From32(system, args); case SvcId::GetDebugFutureThreadInfo: - return SvcWrap_GetDebugFutureThreadInfo64From32(system); + return SvcWrap_GetDebugFutureThreadInfo64From32(system, args); case SvcId::GetLastThreadInfo: - return SvcWrap_GetLastThreadInfo64From32(system); + return SvcWrap_GetLastThreadInfo64From32(system, args); case SvcId::GetResourceLimitLimitValue: - return SvcWrap_GetResourceLimitLimitValue64From32(system); + return SvcWrap_GetResourceLimitLimitValue64From32(system, args); case SvcId::GetResourceLimitCurrentValue: - return SvcWrap_GetResourceLimitCurrentValue64From32(system); + return SvcWrap_GetResourceLimitCurrentValue64From32(system, args); case SvcId::SetThreadActivity: - return SvcWrap_SetThreadActivity64From32(system); + return SvcWrap_SetThreadActivity64From32(system, args); case SvcId::GetThreadContext3: - return SvcWrap_GetThreadContext364From32(system); + return SvcWrap_GetThreadContext364From32(system, args); case SvcId::WaitForAddress: - return SvcWrap_WaitForAddress64From32(system); + return SvcWrap_WaitForAddress64From32(system, args); case SvcId::SignalToAddress: - return SvcWrap_SignalToAddress64From32(system); + return SvcWrap_SignalToAddress64From32(system, args); case SvcId::SynchronizePreemptionState: - return SvcWrap_SynchronizePreemptionState64From32(system); + return SvcWrap_SynchronizePreemptionState64From32(system, args); case SvcId::GetResourceLimitPeakValue: - return SvcWrap_GetResourceLimitPeakValue64From32(system); + return SvcWrap_GetResourceLimitPeakValue64From32(system, args); case SvcId::CreateIoPool: - return SvcWrap_CreateIoPool64From32(system); + return SvcWrap_CreateIoPool64From32(system, args); case SvcId::CreateIoRegion: - return SvcWrap_CreateIoRegion64From32(system); + return SvcWrap_CreateIoRegion64From32(system, args); case SvcId::KernelDebug: - return SvcWrap_KernelDebug64From32(system); + return SvcWrap_KernelDebug64From32(system, args); case SvcId::ChangeKernelTraceState: - return SvcWrap_ChangeKernelTraceState64From32(system); + return SvcWrap_ChangeKernelTraceState64From32(system, args); case SvcId::CreateSession: - return SvcWrap_CreateSession64From32(system); + return SvcWrap_CreateSession64From32(system, args); case SvcId::AcceptSession: - return SvcWrap_AcceptSession64From32(system); + return SvcWrap_AcceptSession64From32(system, args); case SvcId::ReplyAndReceiveLight: - return SvcWrap_ReplyAndReceiveLight64From32(system); + return SvcWrap_ReplyAndReceiveLight64From32(system, args); case SvcId::ReplyAndReceive: - return SvcWrap_ReplyAndReceive64From32(system); + return SvcWrap_ReplyAndReceive64From32(system, args); case SvcId::ReplyAndReceiveWithUserBuffer: - return SvcWrap_ReplyAndReceiveWithUserBuffer64From32(system); + return SvcWrap_ReplyAndReceiveWithUserBuffer64From32(system, args); case SvcId::CreateEvent: - return SvcWrap_CreateEvent64From32(system); + return SvcWrap_CreateEvent64From32(system, args); case SvcId::MapIoRegion: - return SvcWrap_MapIoRegion64From32(system); + return SvcWrap_MapIoRegion64From32(system, args); case SvcId::UnmapIoRegion: - return SvcWrap_UnmapIoRegion64From32(system); + return SvcWrap_UnmapIoRegion64From32(system, args); case SvcId::MapPhysicalMemoryUnsafe: - return SvcWrap_MapPhysicalMemoryUnsafe64From32(system); + return SvcWrap_MapPhysicalMemoryUnsafe64From32(system, args); case SvcId::UnmapPhysicalMemoryUnsafe: - return SvcWrap_UnmapPhysicalMemoryUnsafe64From32(system); + return SvcWrap_UnmapPhysicalMemoryUnsafe64From32(system, args); case SvcId::SetUnsafeLimit: - return SvcWrap_SetUnsafeLimit64From32(system); + return SvcWrap_SetUnsafeLimit64From32(system, args); case SvcId::CreateCodeMemory: - return SvcWrap_CreateCodeMemory64From32(system); + return SvcWrap_CreateCodeMemory64From32(system, args); case SvcId::ControlCodeMemory: - return SvcWrap_ControlCodeMemory64From32(system); + return SvcWrap_ControlCodeMemory64From32(system, args); case SvcId::SleepSystem: - return SvcWrap_SleepSystem64From32(system); + return SvcWrap_SleepSystem64From32(system, args); case SvcId::ReadWriteRegister: - return SvcWrap_ReadWriteRegister64From32(system); + return SvcWrap_ReadWriteRegister64From32(system, args); case SvcId::SetProcessActivity: - return SvcWrap_SetProcessActivity64From32(system); + return SvcWrap_SetProcessActivity64From32(system, args); case SvcId::CreateSharedMemory: - return SvcWrap_CreateSharedMemory64From32(system); + return SvcWrap_CreateSharedMemory64From32(system, args); case SvcId::MapTransferMemory: - return SvcWrap_MapTransferMemory64From32(system); + return SvcWrap_MapTransferMemory64From32(system, args); case SvcId::UnmapTransferMemory: - return SvcWrap_UnmapTransferMemory64From32(system); + return SvcWrap_UnmapTransferMemory64From32(system, args); case SvcId::CreateInterruptEvent: - return SvcWrap_CreateInterruptEvent64From32(system); + return SvcWrap_CreateInterruptEvent64From32(system, args); case SvcId::QueryPhysicalAddress: - return SvcWrap_QueryPhysicalAddress64From32(system); + return SvcWrap_QueryPhysicalAddress64From32(system, args); case SvcId::QueryIoMapping: - return SvcWrap_QueryIoMapping64From32(system); + return SvcWrap_QueryIoMapping64From32(system, args); case SvcId::CreateDeviceAddressSpace: - return SvcWrap_CreateDeviceAddressSpace64From32(system); + return SvcWrap_CreateDeviceAddressSpace64From32(system, args); case SvcId::AttachDeviceAddressSpace: - return SvcWrap_AttachDeviceAddressSpace64From32(system); + return SvcWrap_AttachDeviceAddressSpace64From32(system, args); case SvcId::DetachDeviceAddressSpace: - return SvcWrap_DetachDeviceAddressSpace64From32(system); + return SvcWrap_DetachDeviceAddressSpace64From32(system, args); case SvcId::MapDeviceAddressSpaceByForce: - return SvcWrap_MapDeviceAddressSpaceByForce64From32(system); + return SvcWrap_MapDeviceAddressSpaceByForce64From32(system, args); case SvcId::MapDeviceAddressSpaceAligned: - return SvcWrap_MapDeviceAddressSpaceAligned64From32(system); + return SvcWrap_MapDeviceAddressSpaceAligned64From32(system, args); case SvcId::UnmapDeviceAddressSpace: - return SvcWrap_UnmapDeviceAddressSpace64From32(system); + return SvcWrap_UnmapDeviceAddressSpace64From32(system, args); case SvcId::InvalidateProcessDataCache: - return SvcWrap_InvalidateProcessDataCache64From32(system); + return SvcWrap_InvalidateProcessDataCache64From32(system, args); case SvcId::StoreProcessDataCache: - return SvcWrap_StoreProcessDataCache64From32(system); + return SvcWrap_StoreProcessDataCache64From32(system, args); case SvcId::FlushProcessDataCache: - return SvcWrap_FlushProcessDataCache64From32(system); + return SvcWrap_FlushProcessDataCache64From32(system, args); case SvcId::DebugActiveProcess: - return SvcWrap_DebugActiveProcess64From32(system); + return SvcWrap_DebugActiveProcess64From32(system, args); case SvcId::BreakDebugProcess: - return SvcWrap_BreakDebugProcess64From32(system); + return SvcWrap_BreakDebugProcess64From32(system, args); case SvcId::TerminateDebugProcess: - return SvcWrap_TerminateDebugProcess64From32(system); + return SvcWrap_TerminateDebugProcess64From32(system, args); case SvcId::GetDebugEvent: - return SvcWrap_GetDebugEvent64From32(system); + return SvcWrap_GetDebugEvent64From32(system, args); case SvcId::ContinueDebugEvent: - return SvcWrap_ContinueDebugEvent64From32(system); + return SvcWrap_ContinueDebugEvent64From32(system, args); case SvcId::GetProcessList: - return SvcWrap_GetProcessList64From32(system); + return SvcWrap_GetProcessList64From32(system, args); case SvcId::GetThreadList: - return SvcWrap_GetThreadList64From32(system); + return SvcWrap_GetThreadList64From32(system, args); case SvcId::GetDebugThreadContext: - return SvcWrap_GetDebugThreadContext64From32(system); + return SvcWrap_GetDebugThreadContext64From32(system, args); case SvcId::SetDebugThreadContext: - return SvcWrap_SetDebugThreadContext64From32(system); + return SvcWrap_SetDebugThreadContext64From32(system, args); case SvcId::QueryDebugProcessMemory: - return SvcWrap_QueryDebugProcessMemory64From32(system); + return SvcWrap_QueryDebugProcessMemory64From32(system, args); case SvcId::ReadDebugProcessMemory: - return SvcWrap_ReadDebugProcessMemory64From32(system); + return SvcWrap_ReadDebugProcessMemory64From32(system, args); case SvcId::WriteDebugProcessMemory: - return SvcWrap_WriteDebugProcessMemory64From32(system); + return SvcWrap_WriteDebugProcessMemory64From32(system, args); case SvcId::SetHardwareBreakPoint: - return SvcWrap_SetHardwareBreakPoint64From32(system); + return SvcWrap_SetHardwareBreakPoint64From32(system, args); case SvcId::GetDebugThreadParam: - return SvcWrap_GetDebugThreadParam64From32(system); + return SvcWrap_GetDebugThreadParam64From32(system, args); case SvcId::GetSystemInfo: - return SvcWrap_GetSystemInfo64From32(system); + return SvcWrap_GetSystemInfo64From32(system, args); case SvcId::CreatePort: - return SvcWrap_CreatePort64From32(system); + return SvcWrap_CreatePort64From32(system, args); case SvcId::ManageNamedPort: - return SvcWrap_ManageNamedPort64From32(system); + return SvcWrap_ManageNamedPort64From32(system, args); case SvcId::ConnectToPort: - return SvcWrap_ConnectToPort64From32(system); + return SvcWrap_ConnectToPort64From32(system, args); case SvcId::SetProcessMemoryPermission: - return SvcWrap_SetProcessMemoryPermission64From32(system); + return SvcWrap_SetProcessMemoryPermission64From32(system, args); case SvcId::MapProcessMemory: - return SvcWrap_MapProcessMemory64From32(system); + return SvcWrap_MapProcessMemory64From32(system, args); case SvcId::UnmapProcessMemory: - return SvcWrap_UnmapProcessMemory64From32(system); + return SvcWrap_UnmapProcessMemory64From32(system, args); case SvcId::QueryProcessMemory: - return SvcWrap_QueryProcessMemory64From32(system); + return SvcWrap_QueryProcessMemory64From32(system, args); case SvcId::MapProcessCodeMemory: - return SvcWrap_MapProcessCodeMemory64From32(system); + return SvcWrap_MapProcessCodeMemory64From32(system, args); case SvcId::UnmapProcessCodeMemory: - return SvcWrap_UnmapProcessCodeMemory64From32(system); + return SvcWrap_UnmapProcessCodeMemory64From32(system, args); case SvcId::CreateProcess: - return SvcWrap_CreateProcess64From32(system); + return SvcWrap_CreateProcess64From32(system, args); case SvcId::StartProcess: - return SvcWrap_StartProcess64From32(system); + return SvcWrap_StartProcess64From32(system, args); case SvcId::TerminateProcess: - return SvcWrap_TerminateProcess64From32(system); + return SvcWrap_TerminateProcess64From32(system, args); case SvcId::GetProcessInfo: - return SvcWrap_GetProcessInfo64From32(system); + return SvcWrap_GetProcessInfo64From32(system, args); case SvcId::CreateResourceLimit: - return SvcWrap_CreateResourceLimit64From32(system); + return SvcWrap_CreateResourceLimit64From32(system, args); case SvcId::SetResourceLimitLimitValue: - return SvcWrap_SetResourceLimitLimitValue64From32(system); + return SvcWrap_SetResourceLimitLimitValue64From32(system, args); case SvcId::CallSecureMonitor: - return SvcWrap_CallSecureMonitor64From32(system); + return SvcWrap_CallSecureMonitor64From32(system, args); case SvcId::MapInsecureMemory: - return SvcWrap_MapInsecureMemory64From32(system); + return SvcWrap_MapInsecureMemory64From32(system, args); case SvcId::UnmapInsecureMemory: - return SvcWrap_UnmapInsecureMemory64From32(system); + return SvcWrap_UnmapInsecureMemory64From32(system, args); default: LOG_CRITICAL(Kernel_SVC, "Unknown SVC {:x}!", imm); break; } } -static void Call64(Core::System& system, u32 imm) { +static void Call64(Core::System& system, u32 imm, std::span<uint64_t, 8> args) { switch (static_cast<SvcId>(imm)) { case SvcId::SetHeapSize: - return SvcWrap_SetHeapSize64(system); + return SvcWrap_SetHeapSize64(system, args); case SvcId::SetMemoryPermission: - return SvcWrap_SetMemoryPermission64(system); + return SvcWrap_SetMemoryPermission64(system, args); case SvcId::SetMemoryAttribute: - return SvcWrap_SetMemoryAttribute64(system); + return SvcWrap_SetMemoryAttribute64(system, args); case SvcId::MapMemory: - return SvcWrap_MapMemory64(system); + return SvcWrap_MapMemory64(system, args); case SvcId::UnmapMemory: - return SvcWrap_UnmapMemory64(system); + return SvcWrap_UnmapMemory64(system, args); case SvcId::QueryMemory: - return SvcWrap_QueryMemory64(system); + return SvcWrap_QueryMemory64(system, args); case SvcId::ExitProcess: - return SvcWrap_ExitProcess64(system); + return SvcWrap_ExitProcess64(system, args); case SvcId::CreateThread: - return SvcWrap_CreateThread64(system); + return SvcWrap_CreateThread64(system, args); case SvcId::StartThread: - return SvcWrap_StartThread64(system); + return SvcWrap_StartThread64(system, args); case SvcId::ExitThread: - return SvcWrap_ExitThread64(system); + return SvcWrap_ExitThread64(system, args); case SvcId::SleepThread: - return SvcWrap_SleepThread64(system); + return SvcWrap_SleepThread64(system, args); case SvcId::GetThreadPriority: - return SvcWrap_GetThreadPriority64(system); + return SvcWrap_GetThreadPriority64(system, args); case SvcId::SetThreadPriority: - return SvcWrap_SetThreadPriority64(system); + return SvcWrap_SetThreadPriority64(system, args); case SvcId::GetThreadCoreMask: - return SvcWrap_GetThreadCoreMask64(system); + return SvcWrap_GetThreadCoreMask64(system, args); case SvcId::SetThreadCoreMask: - return SvcWrap_SetThreadCoreMask64(system); + return SvcWrap_SetThreadCoreMask64(system, args); case SvcId::GetCurrentProcessorNumber: - return SvcWrap_GetCurrentProcessorNumber64(system); + return SvcWrap_GetCurrentProcessorNumber64(system, args); case SvcId::SignalEvent: - return SvcWrap_SignalEvent64(system); + return SvcWrap_SignalEvent64(system, args); case SvcId::ClearEvent: - return SvcWrap_ClearEvent64(system); + return SvcWrap_ClearEvent64(system, args); case SvcId::MapSharedMemory: - return SvcWrap_MapSharedMemory64(system); + return SvcWrap_MapSharedMemory64(system, args); case SvcId::UnmapSharedMemory: - return SvcWrap_UnmapSharedMemory64(system); + return SvcWrap_UnmapSharedMemory64(system, args); case SvcId::CreateTransferMemory: - return SvcWrap_CreateTransferMemory64(system); + return SvcWrap_CreateTransferMemory64(system, args); case SvcId::CloseHandle: - return SvcWrap_CloseHandle64(system); + return SvcWrap_CloseHandle64(system, args); case SvcId::ResetSignal: - return SvcWrap_ResetSignal64(system); + return SvcWrap_ResetSignal64(system, args); case SvcId::WaitSynchronization: - return SvcWrap_WaitSynchronization64(system); + return SvcWrap_WaitSynchronization64(system, args); case SvcId::CancelSynchronization: - return SvcWrap_CancelSynchronization64(system); + return SvcWrap_CancelSynchronization64(system, args); case SvcId::ArbitrateLock: - return SvcWrap_ArbitrateLock64(system); + return SvcWrap_ArbitrateLock64(system, args); case SvcId::ArbitrateUnlock: - return SvcWrap_ArbitrateUnlock64(system); + return SvcWrap_ArbitrateUnlock64(system, args); case SvcId::WaitProcessWideKeyAtomic: - return SvcWrap_WaitProcessWideKeyAtomic64(system); + return SvcWrap_WaitProcessWideKeyAtomic64(system, args); case SvcId::SignalProcessWideKey: - return SvcWrap_SignalProcessWideKey64(system); + return SvcWrap_SignalProcessWideKey64(system, args); case SvcId::GetSystemTick: - return SvcWrap_GetSystemTick64(system); + return SvcWrap_GetSystemTick64(system, args); case SvcId::ConnectToNamedPort: - return SvcWrap_ConnectToNamedPort64(system); + return SvcWrap_ConnectToNamedPort64(system, args); case SvcId::SendSyncRequestLight: - return SvcWrap_SendSyncRequestLight64(system); + return SvcWrap_SendSyncRequestLight64(system, args); case SvcId::SendSyncRequest: - return SvcWrap_SendSyncRequest64(system); + return SvcWrap_SendSyncRequest64(system, args); case SvcId::SendSyncRequestWithUserBuffer: - return SvcWrap_SendSyncRequestWithUserBuffer64(system); + return SvcWrap_SendSyncRequestWithUserBuffer64(system, args); case SvcId::SendAsyncRequestWithUserBuffer: - return SvcWrap_SendAsyncRequestWithUserBuffer64(system); + return SvcWrap_SendAsyncRequestWithUserBuffer64(system, args); case SvcId::GetProcessId: - return SvcWrap_GetProcessId64(system); + return SvcWrap_GetProcessId64(system, args); case SvcId::GetThreadId: - return SvcWrap_GetThreadId64(system); + return SvcWrap_GetThreadId64(system, args); case SvcId::Break: - return SvcWrap_Break64(system); + return SvcWrap_Break64(system, args); case SvcId::OutputDebugString: - return SvcWrap_OutputDebugString64(system); + return SvcWrap_OutputDebugString64(system, args); case SvcId::ReturnFromException: - return SvcWrap_ReturnFromException64(system); + return SvcWrap_ReturnFromException64(system, args); case SvcId::GetInfo: - return SvcWrap_GetInfo64(system); + return SvcWrap_GetInfo64(system, args); case SvcId::FlushEntireDataCache: - return SvcWrap_FlushEntireDataCache64(system); + return SvcWrap_FlushEntireDataCache64(system, args); case SvcId::FlushDataCache: - return SvcWrap_FlushDataCache64(system); + return SvcWrap_FlushDataCache64(system, args); case SvcId::MapPhysicalMemory: - return SvcWrap_MapPhysicalMemory64(system); + return SvcWrap_MapPhysicalMemory64(system, args); case SvcId::UnmapPhysicalMemory: - return SvcWrap_UnmapPhysicalMemory64(system); + return SvcWrap_UnmapPhysicalMemory64(system, args); case SvcId::GetDebugFutureThreadInfo: - return SvcWrap_GetDebugFutureThreadInfo64(system); + return SvcWrap_GetDebugFutureThreadInfo64(system, args); case SvcId::GetLastThreadInfo: - return SvcWrap_GetLastThreadInfo64(system); + return SvcWrap_GetLastThreadInfo64(system, args); case SvcId::GetResourceLimitLimitValue: - return SvcWrap_GetResourceLimitLimitValue64(system); + return SvcWrap_GetResourceLimitLimitValue64(system, args); case SvcId::GetResourceLimitCurrentValue: - return SvcWrap_GetResourceLimitCurrentValue64(system); + return SvcWrap_GetResourceLimitCurrentValue64(system, args); case SvcId::SetThreadActivity: - return SvcWrap_SetThreadActivity64(system); + return SvcWrap_SetThreadActivity64(system, args); case SvcId::GetThreadContext3: - return SvcWrap_GetThreadContext364(system); + return SvcWrap_GetThreadContext364(system, args); case SvcId::WaitForAddress: - return SvcWrap_WaitForAddress64(system); + return SvcWrap_WaitForAddress64(system, args); case SvcId::SignalToAddress: - return SvcWrap_SignalToAddress64(system); + return SvcWrap_SignalToAddress64(system, args); case SvcId::SynchronizePreemptionState: - return SvcWrap_SynchronizePreemptionState64(system); + return SvcWrap_SynchronizePreemptionState64(system, args); case SvcId::GetResourceLimitPeakValue: - return SvcWrap_GetResourceLimitPeakValue64(system); + return SvcWrap_GetResourceLimitPeakValue64(system, args); case SvcId::CreateIoPool: - return SvcWrap_CreateIoPool64(system); + return SvcWrap_CreateIoPool64(system, args); case SvcId::CreateIoRegion: - return SvcWrap_CreateIoRegion64(system); + return SvcWrap_CreateIoRegion64(system, args); case SvcId::KernelDebug: - return SvcWrap_KernelDebug64(system); + return SvcWrap_KernelDebug64(system, args); case SvcId::ChangeKernelTraceState: - return SvcWrap_ChangeKernelTraceState64(system); + return SvcWrap_ChangeKernelTraceState64(system, args); case SvcId::CreateSession: - return SvcWrap_CreateSession64(system); + return SvcWrap_CreateSession64(system, args); case SvcId::AcceptSession: - return SvcWrap_AcceptSession64(system); + return SvcWrap_AcceptSession64(system, args); case SvcId::ReplyAndReceiveLight: - return SvcWrap_ReplyAndReceiveLight64(system); + return SvcWrap_ReplyAndReceiveLight64(system, args); case SvcId::ReplyAndReceive: - return SvcWrap_ReplyAndReceive64(system); + return SvcWrap_ReplyAndReceive64(system, args); case SvcId::ReplyAndReceiveWithUserBuffer: - return SvcWrap_ReplyAndReceiveWithUserBuffer64(system); + return SvcWrap_ReplyAndReceiveWithUserBuffer64(system, args); case SvcId::CreateEvent: - return SvcWrap_CreateEvent64(system); + return SvcWrap_CreateEvent64(system, args); case SvcId::MapIoRegion: - return SvcWrap_MapIoRegion64(system); + return SvcWrap_MapIoRegion64(system, args); case SvcId::UnmapIoRegion: - return SvcWrap_UnmapIoRegion64(system); + return SvcWrap_UnmapIoRegion64(system, args); case SvcId::MapPhysicalMemoryUnsafe: - return SvcWrap_MapPhysicalMemoryUnsafe64(system); + return SvcWrap_MapPhysicalMemoryUnsafe64(system, args); case SvcId::UnmapPhysicalMemoryUnsafe: - return SvcWrap_UnmapPhysicalMemoryUnsafe64(system); + return SvcWrap_UnmapPhysicalMemoryUnsafe64(system, args); case SvcId::SetUnsafeLimit: - return SvcWrap_SetUnsafeLimit64(system); + return SvcWrap_SetUnsafeLimit64(system, args); case SvcId::CreateCodeMemory: - return SvcWrap_CreateCodeMemory64(system); + return SvcWrap_CreateCodeMemory64(system, args); case SvcId::ControlCodeMemory: - return SvcWrap_ControlCodeMemory64(system); + return SvcWrap_ControlCodeMemory64(system, args); case SvcId::SleepSystem: - return SvcWrap_SleepSystem64(system); + return SvcWrap_SleepSystem64(system, args); case SvcId::ReadWriteRegister: - return SvcWrap_ReadWriteRegister64(system); + return SvcWrap_ReadWriteRegister64(system, args); case SvcId::SetProcessActivity: - return SvcWrap_SetProcessActivity64(system); + return SvcWrap_SetProcessActivity64(system, args); case SvcId::CreateSharedMemory: - return SvcWrap_CreateSharedMemory64(system); + return SvcWrap_CreateSharedMemory64(system, args); case SvcId::MapTransferMemory: - return SvcWrap_MapTransferMemory64(system); + return SvcWrap_MapTransferMemory64(system, args); case SvcId::UnmapTransferMemory: - return SvcWrap_UnmapTransferMemory64(system); + return SvcWrap_UnmapTransferMemory64(system, args); case SvcId::CreateInterruptEvent: - return SvcWrap_CreateInterruptEvent64(system); + return SvcWrap_CreateInterruptEvent64(system, args); case SvcId::QueryPhysicalAddress: - return SvcWrap_QueryPhysicalAddress64(system); + return SvcWrap_QueryPhysicalAddress64(system, args); case SvcId::QueryIoMapping: - return SvcWrap_QueryIoMapping64(system); + return SvcWrap_QueryIoMapping64(system, args); case SvcId::CreateDeviceAddressSpace: - return SvcWrap_CreateDeviceAddressSpace64(system); + return SvcWrap_CreateDeviceAddressSpace64(system, args); case SvcId::AttachDeviceAddressSpace: - return SvcWrap_AttachDeviceAddressSpace64(system); + return SvcWrap_AttachDeviceAddressSpace64(system, args); case SvcId::DetachDeviceAddressSpace: - return SvcWrap_DetachDeviceAddressSpace64(system); + return SvcWrap_DetachDeviceAddressSpace64(system, args); case SvcId::MapDeviceAddressSpaceByForce: - return SvcWrap_MapDeviceAddressSpaceByForce64(system); + return SvcWrap_MapDeviceAddressSpaceByForce64(system, args); case SvcId::MapDeviceAddressSpaceAligned: - return SvcWrap_MapDeviceAddressSpaceAligned64(system); + return SvcWrap_MapDeviceAddressSpaceAligned64(system, args); case SvcId::UnmapDeviceAddressSpace: - return SvcWrap_UnmapDeviceAddressSpace64(system); + return SvcWrap_UnmapDeviceAddressSpace64(system, args); case SvcId::InvalidateProcessDataCache: - return SvcWrap_InvalidateProcessDataCache64(system); + return SvcWrap_InvalidateProcessDataCache64(system, args); case SvcId::StoreProcessDataCache: - return SvcWrap_StoreProcessDataCache64(system); + return SvcWrap_StoreProcessDataCache64(system, args); case SvcId::FlushProcessDataCache: - return SvcWrap_FlushProcessDataCache64(system); + return SvcWrap_FlushProcessDataCache64(system, args); case SvcId::DebugActiveProcess: - return SvcWrap_DebugActiveProcess64(system); + return SvcWrap_DebugActiveProcess64(system, args); case SvcId::BreakDebugProcess: - return SvcWrap_BreakDebugProcess64(system); + return SvcWrap_BreakDebugProcess64(system, args); case SvcId::TerminateDebugProcess: - return SvcWrap_TerminateDebugProcess64(system); + return SvcWrap_TerminateDebugProcess64(system, args); case SvcId::GetDebugEvent: - return SvcWrap_GetDebugEvent64(system); + return SvcWrap_GetDebugEvent64(system, args); case SvcId::ContinueDebugEvent: - return SvcWrap_ContinueDebugEvent64(system); + return SvcWrap_ContinueDebugEvent64(system, args); case SvcId::GetProcessList: - return SvcWrap_GetProcessList64(system); + return SvcWrap_GetProcessList64(system, args); case SvcId::GetThreadList: - return SvcWrap_GetThreadList64(system); + return SvcWrap_GetThreadList64(system, args); case SvcId::GetDebugThreadContext: - return SvcWrap_GetDebugThreadContext64(system); + return SvcWrap_GetDebugThreadContext64(system, args); case SvcId::SetDebugThreadContext: - return SvcWrap_SetDebugThreadContext64(system); + return SvcWrap_SetDebugThreadContext64(system, args); case SvcId::QueryDebugProcessMemory: - return SvcWrap_QueryDebugProcessMemory64(system); + return SvcWrap_QueryDebugProcessMemory64(system, args); case SvcId::ReadDebugProcessMemory: - return SvcWrap_ReadDebugProcessMemory64(system); + return SvcWrap_ReadDebugProcessMemory64(system, args); case SvcId::WriteDebugProcessMemory: - return SvcWrap_WriteDebugProcessMemory64(system); + return SvcWrap_WriteDebugProcessMemory64(system, args); case SvcId::SetHardwareBreakPoint: - return SvcWrap_SetHardwareBreakPoint64(system); + return SvcWrap_SetHardwareBreakPoint64(system, args); case SvcId::GetDebugThreadParam: - return SvcWrap_GetDebugThreadParam64(system); + return SvcWrap_GetDebugThreadParam64(system, args); case SvcId::GetSystemInfo: - return SvcWrap_GetSystemInfo64(system); + return SvcWrap_GetSystemInfo64(system, args); case SvcId::CreatePort: - return SvcWrap_CreatePort64(system); + return SvcWrap_CreatePort64(system, args); case SvcId::ManageNamedPort: - return SvcWrap_ManageNamedPort64(system); + return SvcWrap_ManageNamedPort64(system, args); case SvcId::ConnectToPort: - return SvcWrap_ConnectToPort64(system); + return SvcWrap_ConnectToPort64(system, args); case SvcId::SetProcessMemoryPermission: - return SvcWrap_SetProcessMemoryPermission64(system); + return SvcWrap_SetProcessMemoryPermission64(system, args); case SvcId::MapProcessMemory: - return SvcWrap_MapProcessMemory64(system); + return SvcWrap_MapProcessMemory64(system, args); case SvcId::UnmapProcessMemory: - return SvcWrap_UnmapProcessMemory64(system); + return SvcWrap_UnmapProcessMemory64(system, args); case SvcId::QueryProcessMemory: - return SvcWrap_QueryProcessMemory64(system); + return SvcWrap_QueryProcessMemory64(system, args); case SvcId::MapProcessCodeMemory: - return SvcWrap_MapProcessCodeMemory64(system); + return SvcWrap_MapProcessCodeMemory64(system, args); case SvcId::UnmapProcessCodeMemory: - return SvcWrap_UnmapProcessCodeMemory64(system); + return SvcWrap_UnmapProcessCodeMemory64(system, args); case SvcId::CreateProcess: - return SvcWrap_CreateProcess64(system); + return SvcWrap_CreateProcess64(system, args); case SvcId::StartProcess: - return SvcWrap_StartProcess64(system); + return SvcWrap_StartProcess64(system, args); case SvcId::TerminateProcess: - return SvcWrap_TerminateProcess64(system); + return SvcWrap_TerminateProcess64(system, args); case SvcId::GetProcessInfo: - return SvcWrap_GetProcessInfo64(system); + return SvcWrap_GetProcessInfo64(system, args); case SvcId::CreateResourceLimit: - return SvcWrap_CreateResourceLimit64(system); + return SvcWrap_CreateResourceLimit64(system, args); case SvcId::SetResourceLimitLimitValue: - return SvcWrap_SetResourceLimitLimitValue64(system); + return SvcWrap_SetResourceLimitLimitValue64(system, args); case SvcId::CallSecureMonitor: - return SvcWrap_CallSecureMonitor64(system); + return SvcWrap_CallSecureMonitor64(system, args); case SvcId::MapInsecureMemory: - return SvcWrap_MapInsecureMemory64(system); + return SvcWrap_MapInsecureMemory64(system, args); case SvcId::UnmapInsecureMemory: - return SvcWrap_UnmapInsecureMemory64(system); + return SvcWrap_UnmapInsecureMemory64(system, args); default: LOG_CRITICAL(Kernel_SVC, "Unknown SVC {:x}!", imm); break; @@ -4424,15 +4424,20 @@ static void Call64(Core::System& system, u32 imm) { void Call(Core::System& system, u32 imm) { auto& kernel = system.Kernel(); + auto& process = GetCurrentProcess(kernel); + + std::array<uint64_t, 8> args; + kernel.CurrentPhysicalCore().SaveSvcArguments(process, args); kernel.EnterSVCProfile(); - if (GetCurrentProcess(system.Kernel()).Is64Bit()) { - Call64(system, imm); + if (process.Is64Bit()) { + Call64(system, imm, args); } else { - Call32(system, imm); + Call32(system, imm, args); } kernel.ExitSVCProfile(); + kernel.CurrentPhysicalCore().LoadSvcArguments(process, args); } } // namespace Kernel::Svc diff --git a/src/core/hle/kernel/svc.h b/src/core/hle/kernel/svc.h index ac4696008..828f39611 100644 --- a/src/core/hle/kernel/svc.h +++ b/src/core/hle/kernel/svc.h @@ -9,6 +9,8 @@ namespace Core { class System; } +#include <span> + #include "common/common_types.h" #include "core/hle/kernel/svc_types.h" #include "core/hle/result.h" @@ -520,15 +522,15 @@ void CallSecureMonitor64From32(Core::System& system, ilp32::SecureMonitorArgumen void CallSecureMonitor64(Core::System& system, lp64::SecureMonitorArguments* args); // Defined in svc_light_ipc.cpp. -void SvcWrap_ReplyAndReceiveLight64From32(Core::System& system); -void SvcWrap_ReplyAndReceiveLight64(Core::System& system); +void SvcWrap_ReplyAndReceiveLight64From32(Core::System& system, std::span<uint64_t, 8> args); +void SvcWrap_ReplyAndReceiveLight64(Core::System& system, std::span<uint64_t, 8> args); -void SvcWrap_SendSyncRequestLight64From32(Core::System& system); -void SvcWrap_SendSyncRequestLight64(Core::System& system); +void SvcWrap_SendSyncRequestLight64From32(Core::System& system, std::span<uint64_t, 8> args); +void SvcWrap_SendSyncRequestLight64(Core::System& system, std::span<uint64_t, 8> args); // Defined in svc_secure_monitor_call.cpp. -void SvcWrap_CallSecureMonitor64From32(Core::System& system); -void SvcWrap_CallSecureMonitor64(Core::System& system); +void SvcWrap_CallSecureMonitor64From32(Core::System& system, std::span<uint64_t, 8> args); +void SvcWrap_CallSecureMonitor64(Core::System& system, std::span<uint64_t, 8> args); // Perform a supervisor call by index. void Call(Core::System& system, u32 imm); diff --git a/src/core/hle/kernel/svc/svc_exception.cpp b/src/core/hle/kernel/svc/svc_exception.cpp index c581c086b..47b756828 100644 --- a/src/core/hle/kernel/svc/svc_exception.cpp +++ b/src/core/hle/kernel/svc/svc_exception.cpp @@ -103,9 +103,7 @@ void Break(Core::System& system, BreakReason reason, u64 info1, u64 info2) { handle_debug_buffer(info1, info2); - auto* const current_thread = GetCurrentThreadPointer(system.Kernel()); - const auto thread_processor_id = current_thread->GetActiveCore(); - system.ArmInterface(static_cast<std::size_t>(thread_processor_id)).LogBacktrace(); + system.CurrentPhysicalCore().LogBacktrace(); } const bool is_hbl = GetCurrentProcess(system.Kernel()).IsHbl(); diff --git a/src/core/hle/kernel/svc/svc_light_ipc.cpp b/src/core/hle/kernel/svc/svc_light_ipc.cpp index b76ce984c..d757d5af2 100644 --- a/src/core/hle/kernel/svc/svc_light_ipc.cpp +++ b/src/core/hle/kernel/svc/svc_light_ipc.cpp @@ -37,37 +37,36 @@ Result ReplyAndReceiveLight64From32(Core::System& system, Handle session_handle, // Custom ABI implementation for light IPC. template <typename F> -static void SvcWrap_LightIpc(Core::System& system, F&& cb) { - auto& core = system.CurrentArmInterface(); - std::array<u32, 7> arguments{}; +static void SvcWrap_LightIpc(Core::System& system, std::span<uint64_t, 8> args, F&& cb) { + std::array<u32, 7> ipc_args{}; - Handle session_handle = static_cast<Handle>(core.GetReg(0)); + Handle session_handle = static_cast<Handle>(args[0]); for (int i = 0; i < 7; i++) { - arguments[i] = static_cast<u32>(core.GetReg(i + 1)); + ipc_args[i] = static_cast<u32>(args[i + 1]); } - Result ret = cb(system, session_handle, arguments.data()); + Result ret = cb(system, session_handle, ipc_args.data()); - core.SetReg(0, ret.raw); + args[0] = ret.raw; for (int i = 0; i < 7; i++) { - core.SetReg(i + 1, arguments[i]); + args[i + 1] = ipc_args[i]; } } -void SvcWrap_SendSyncRequestLight64(Core::System& system) { - SvcWrap_LightIpc(system, SendSyncRequestLight64); +void SvcWrap_SendSyncRequestLight64(Core::System& system, std::span<uint64_t, 8> args) { + SvcWrap_LightIpc(system, args, SendSyncRequestLight64); } -void SvcWrap_ReplyAndReceiveLight64(Core::System& system) { - SvcWrap_LightIpc(system, ReplyAndReceiveLight64); +void SvcWrap_ReplyAndReceiveLight64(Core::System& system, std::span<uint64_t, 8> args) { + SvcWrap_LightIpc(system, args, ReplyAndReceiveLight64); } -void SvcWrap_SendSyncRequestLight64From32(Core::System& system) { - SvcWrap_LightIpc(system, SendSyncRequestLight64From32); +void SvcWrap_SendSyncRequestLight64From32(Core::System& system, std::span<uint64_t, 8> args) { + SvcWrap_LightIpc(system, args, SendSyncRequestLight64From32); } -void SvcWrap_ReplyAndReceiveLight64From32(Core::System& system) { - SvcWrap_LightIpc(system, ReplyAndReceiveLight64From32); +void SvcWrap_ReplyAndReceiveLight64From32(Core::System& system, std::span<uint64_t, 8> args) { + SvcWrap_LightIpc(system, args, ReplyAndReceiveLight64From32); } } // namespace Kernel::Svc diff --git a/src/core/hle/kernel/svc/svc_secure_monitor_call.cpp b/src/core/hle/kernel/svc/svc_secure_monitor_call.cpp index 62c781551..48b564ec8 100644 --- a/src/core/hle/kernel/svc/svc_secure_monitor_call.cpp +++ b/src/core/hle/kernel/svc/svc_secure_monitor_call.cpp @@ -22,31 +22,29 @@ void CallSecureMonitor64From32(Core::System& system, ilp32::SecureMonitorArgumen // Custom ABI for CallSecureMonitor. -void SvcWrap_CallSecureMonitor64(Core::System& system) { - auto& core = system.CurrentPhysicalCore().ArmInterface(); - lp64::SecureMonitorArguments args{}; +void SvcWrap_CallSecureMonitor64(Core::System& system, std::span<uint64_t, 8> args) { + lp64::SecureMonitorArguments smc_args{}; for (int i = 0; i < 8; i++) { - args.r[i] = core.GetReg(i); + smc_args.r[i] = args[i]; } - CallSecureMonitor64(system, std::addressof(args)); + CallSecureMonitor64(system, std::addressof(smc_args)); for (int i = 0; i < 8; i++) { - core.SetReg(i, args.r[i]); + args[i] = smc_args.r[i]; } } -void SvcWrap_CallSecureMonitor64From32(Core::System& system) { - auto& core = system.CurrentPhysicalCore().ArmInterface(); - ilp32::SecureMonitorArguments args{}; +void SvcWrap_CallSecureMonitor64From32(Core::System& system, std::span<uint64_t, 8> args) { + ilp32::SecureMonitorArguments smc_args{}; for (int i = 0; i < 8; i++) { - args.r[i] = static_cast<u32>(core.GetReg(i)); + smc_args.r[i] = static_cast<u32>(args[i]); } - CallSecureMonitor64From32(system, std::addressof(args)); + CallSecureMonitor64From32(system, std::addressof(smc_args)); for (int i = 0; i < 8; i++) { - core.SetReg(i, args.r[i]); + args[i] = smc_args.r[i]; } } diff --git a/src/core/hle/kernel/svc/svc_thread.cpp b/src/core/hle/kernel/svc/svc_thread.cpp index 755fd62b5..7681afa33 100644 --- a/src/core/hle/kernel/svc/svc_thread.cpp +++ b/src/core/hle/kernel/svc/svc_thread.cpp @@ -90,8 +90,6 @@ Result StartThread(Core::System& system, Handle thread_handle) { /// Called when a thread exits void ExitThread(Core::System& system) { - LOG_DEBUG(Kernel_SVC, "called, pc=0x{:08X}", system.CurrentArmInterface().GetPC()); - auto* const current_thread = GetCurrentThreadPointer(system.Kernel()); system.GlobalSchedulerContext().RemoveThread(current_thread); current_thread->Exit(); @@ -147,47 +145,19 @@ Result GetThreadContext3(Core::System& system, u64 out_context, Handle thread_ha R_UNLESS(thread.IsNotNull(), ResultInvalidHandle); // Require the handle be to a non-current thread in the current process. - const auto* current_process = GetCurrentProcessPointer(kernel); - R_UNLESS(current_process == thread->GetOwnerProcess(), ResultInvalidId); - - // Verify that the thread isn't terminated. - R_UNLESS(thread->GetState() != ThreadState::Terminated, ResultTerminationRequested); - - /// Check that the thread is not the current one. - /// NOTE: Nintendo does not check this, and thus the following loop will deadlock. - R_UNLESS(thread.GetPointerUnsafe() != GetCurrentThreadPointer(kernel), ResultInvalidId); - - // Try to get the thread context until the thread isn't current on any core. - while (true) { - KScopedSchedulerLock sl{kernel}; - - // TODO(bunnei): Enforce that thread is suspended for debug here. - - // If the thread's raw state isn't runnable, check if it's current on some core. - if (thread->GetRawState() != ThreadState::Runnable) { - bool current = false; - for (auto i = 0; i < static_cast<s32>(Core::Hardware::NUM_CPU_CORES); ++i) { - if (thread.GetPointerUnsafe() == kernel.Scheduler(i).GetSchedulerCurrentThread()) { - current = true; - break; - } - } + R_UNLESS(thread->GetOwnerProcess() == GetCurrentProcessPointer(kernel), ResultInvalidHandle); + R_UNLESS(thread.GetPointerUnsafe() != GetCurrentThreadPointer(kernel), ResultBusy); - // If the thread is current, retry until it isn't. - if (current) { - continue; - } - } + // Get the thread context. + Svc::ThreadContext context{}; + R_TRY(thread->GetThreadContext3(std::addressof(context))); - // Get the thread context. - static thread_local Common::ScratchBuffer<u8> context; - R_TRY(thread->GetThreadContext3(context)); + // Copy the thread context to user space. + R_UNLESS( + GetCurrentMemory(kernel).WriteBlock(out_context, std::addressof(context), sizeof(context)), + ResultInvalidPointer); - // Copy the thread context to user space. - GetCurrentMemory(kernel).WriteBlock(out_context, context.data(), context.size()); - - R_SUCCEED(); - } + R_SUCCEED(); } /// Gets the priority for the specified thread diff --git a/src/core/hle/kernel/svc_generator.py b/src/core/hle/kernel/svc_generator.py index 5531faac6..786189ab7 100644 --- a/src/core/hle/kernel/svc_generator.py +++ b/src/core/hle/kernel/svc_generator.py @@ -374,11 +374,11 @@ def get_registers(parse_result, bitness): # Collects possibly multiple source registers into the named C++ value. def emit_gather(sources, name, type_name, reg_size): - get_fn = f"GetReg{reg_size*8}" + get_fn = f"GetArg{reg_size*8}" if len(sources) == 1: s, = sources - line = f"{name} = Convert<{type_name}>({get_fn}(system, {s}));" + line = f"{name} = Convert<{type_name}>({get_fn}(args, {s}));" return [line] var_type = f"std::array<uint{reg_size*8}_t, {len(sources)}>" @@ -387,7 +387,7 @@ def emit_gather(sources, name, type_name, reg_size): ] for i in range(0, len(sources)): lines.append( - f"{name}_gather[{i}] = {get_fn}(system, {sources[i]});") + f"{name}_gather[{i}] = {get_fn}(args, {sources[i]});") lines.append(f"{name} = Convert<{type_name}>({name}_gather);") return lines @@ -396,12 +396,12 @@ def emit_gather(sources, name, type_name, reg_size): # Produces one or more statements which assign the named C++ value # into possibly multiple registers. def emit_scatter(destinations, name, reg_size): - set_fn = f"SetReg{reg_size*8}" + set_fn = f"SetArg{reg_size*8}" reg_type = f"uint{reg_size*8}_t" if len(destinations) == 1: d, = destinations - line = f"{set_fn}(system, {d}, Convert<{reg_type}>({name}));" + line = f"{set_fn}(args, {d}, Convert<{reg_type}>({name}));" return [line] var_type = f"std::array<{reg_type}, {len(destinations)}>" @@ -411,7 +411,7 @@ def emit_scatter(destinations, name, reg_size): for i in range(0, len(destinations)): lines.append( - f"{set_fn}(system, {destinations[i]}, {name}_scatter[{i}]);") + f"{set_fn}(args, {destinations[i]}, {name}_scatter[{i}]);") return lines @@ -433,7 +433,7 @@ def emit_lines(lines, indent=' '): def emit_wrapper(wrapped_fn, suffix, register_info, arguments, byte_size): return_write, output_writes, input_reads = register_info lines = [ - f"static void SvcWrap_{wrapped_fn}{suffix}(Core::System& system) {{" + f"static void SvcWrap_{wrapped_fn}{suffix}(Core::System& system, std::span<uint64_t, 8> args) {{" ] # Get everything ready. @@ -498,6 +498,8 @@ namespace Core { class System; } +#include <span> + #include "common/common_types.h" #include "core/hle/kernel/svc_types.h" #include "core/hle/result.h" @@ -524,15 +526,15 @@ void CallSecureMonitor64From32(Core::System& system, ilp32::SecureMonitorArgumen void CallSecureMonitor64(Core::System& system, lp64::SecureMonitorArguments* args); // Defined in svc_light_ipc.cpp. -void SvcWrap_ReplyAndReceiveLight64From32(Core::System& system); -void SvcWrap_ReplyAndReceiveLight64(Core::System& system); +void SvcWrap_ReplyAndReceiveLight64From32(Core::System& system, std::span<uint64_t, 8> args); +void SvcWrap_ReplyAndReceiveLight64(Core::System& system, std::span<uint64_t, 8> args); -void SvcWrap_SendSyncRequestLight64From32(Core::System& system); -void SvcWrap_SendSyncRequestLight64(Core::System& system); +void SvcWrap_SendSyncRequestLight64From32(Core::System& system, std::span<uint64_t, 8> args); +void SvcWrap_SendSyncRequestLight64(Core::System& system, std::span<uint64_t, 8> args); // Defined in svc_secure_monitor_call.cpp. -void SvcWrap_CallSecureMonitor64From32(Core::System& system); -void SvcWrap_CallSecureMonitor64(Core::System& system); +void SvcWrap_CallSecureMonitor64From32(Core::System& system, std::span<uint64_t, 8> args); +void SvcWrap_CallSecureMonitor64(Core::System& system, std::span<uint64_t, 8> args); // Perform a supervisor call by index. void Call(Core::System& system, u32 imm); @@ -550,20 +552,20 @@ PROLOGUE_CPP = """ namespace Kernel::Svc { -static uint32_t GetReg32(Core::System& system, int n) { - return static_cast<uint32_t>(system.CurrentArmInterface().GetReg(n)); +static uint32_t GetArg32(std::span<uint64_t, 8> args, int n) { + return static_cast<uint32_t>(args[n]); } -static void SetReg32(Core::System& system, int n, uint32_t result) { - system.CurrentArmInterface().SetReg(n, static_cast<uint64_t>(result)); +static void SetArg32(std::span<uint64_t, 8> args, int n, uint32_t result) { + args[n] = result; } -static uint64_t GetReg64(Core::System& system, int n) { - return system.CurrentArmInterface().GetReg(n); +static uint64_t GetArg64(std::span<uint64_t, 8> args, int n) { + return args[n]; } -static void SetReg64(Core::System& system, int n, uint64_t result) { - system.CurrentArmInterface().SetReg(n, result); +static void SetArg64(std::span<uint64_t, 8> args, int n, uint64_t result) { + args[n] = result; } // Like bit_cast, but handles the case when the source and dest @@ -590,15 +592,20 @@ EPILOGUE_CPP = """ void Call(Core::System& system, u32 imm) { auto& kernel = system.Kernel(); + auto& process = GetCurrentProcess(kernel); + + std::array<uint64_t, 8> args; + kernel.CurrentPhysicalCore().SaveSvcArguments(process, args); kernel.EnterSVCProfile(); - if (GetCurrentProcess(system.Kernel()).Is64Bit()) { - Call64(system, imm); + if (process.Is64Bit()) { + Call64(system, imm, args); } else { - Call32(system, imm); + Call32(system, imm, args); } kernel.ExitSVCProfile(); + kernel.CurrentPhysicalCore().LoadSvcArguments(process, args); } } // namespace Kernel::Svc @@ -609,13 +616,13 @@ def emit_call(bitness, names, suffix): bit_size = REG_SIZES[bitness]*8 indent = " " lines = [ - f"static void Call{bit_size}(Core::System& system, u32 imm) {{", + f"static void Call{bit_size}(Core::System& system, u32 imm, std::span<uint64_t, 8> args) {{", f"{indent}switch (static_cast<SvcId>(imm)) {{" ] for _, name in names: lines.append(f"{indent}case SvcId::{name}:") - lines.append(f"{indent*2}return SvcWrap_{name}{suffix}(system);") + lines.append(f"{indent*2}return SvcWrap_{name}{suffix}(system, args);") lines.append(f"{indent}default:") lines.append( |