yuzu-emu
/
yuzu-android
Archived
1
0
Fork 0
Code

kernel: prefer std::addressof

This commit is contained in:
Liam 2023-03-07 12:01:07 -05:00
parent 641783df8f
commit ac6cbb7134
21 changed files with 139 additions and 134 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
src/core/hle/kernel/k_address_arbiter.cpp
View File

@ -141,7 +141,7 @@ Result KAddressArbiter::SignalAndIncrementIfEqual(VAddr addr, s32 value, s32 cou
// Check the userspace value. // Check the userspace value.
s32 user_value{}; s32 user_value{};
R_UNLESS(UpdateIfEqual(m_system, &user_value, addr, value, value + 1), R_UNLESS(UpdateIfEqual(m_system, std::addressof(user_value), addr, value, value + 1),
ResultInvalidCurrentMemory); ResultInvalidCurrentMemory);
R_UNLESS(user_value == value, ResultInvalidState); R_UNLESS(user_value == value, ResultInvalidState);
@ -201,9 +201,9 @@ Result KAddressArbiter::SignalAndModifyByWaitingCountIfEqual(VAddr addr, s32 val
s32 user_value{}; s32 user_value{};
bool succeeded{}; bool succeeded{};
if (value != new_value) { if (value != new_value) {
succeeded = UpdateIfEqual(m_system, &user_value, addr, value, new_value); succeeded = UpdateIfEqual(m_system, std::addressof(user_value), addr, value, new_value);
} else { } else {
succeeded = ReadFromUser(m_system, &user_value, addr); succeeded = ReadFromUser(m_system, std::addressof(user_value), addr);
} }
R_UNLESS(succeeded, ResultInvalidCurrentMemory); R_UNLESS(succeeded, ResultInvalidCurrentMemory);
@ -244,9 +244,9 @@ Result KAddressArbiter::WaitIfLessThan(VAddr addr, s32 value, bool decrement, s6
s32 user_value{}; s32 user_value{};
bool succeeded{}; bool succeeded{};
if (decrement) { if (decrement) {
succeeded = DecrementIfLessThan(m_system, &user_value, addr, value); succeeded = DecrementIfLessThan(m_system, std::addressof(user_value), addr, value);
} else { } else {
succeeded = ReadFromUser(m_system, &user_value, addr); succeeded = ReadFromUser(m_system, std::addressof(user_value), addr);
} }
if (!succeeded) { if (!succeeded) {
@ -297,7 +297,7 @@ Result KAddressArbiter::WaitIfEqual(VAddr addr, s32 value, s64 timeout) {
// Read the value from userspace. // Read the value from userspace.
s32 user_value{}; s32 user_value{};
if (!ReadFromUser(m_system, &user_value, addr)) { if (!ReadFromUser(m_system, std::addressof(user_value), addr)) {
slp.CancelSleep(); slp.CancelSleep();
R_THROW(ResultInvalidCurrentMemory); R_THROW(ResultInvalidCurrentMemory);
} }

2
src/core/hle/kernel/k_auto_object.h
View File

@ -195,7 +195,7 @@ public:
} }
friend bool operator<(const KAutoObjectWithList& left, const KAutoObjectWithList& right) { friend bool operator<(const KAutoObjectWithList& left, const KAutoObjectWithList& right) {
return &left < &right; return KAutoObjectWithList::Compare(left, right) < 0;
} }
public: public:

2
src/core/hle/kernel/k_page_table.h
View File

@ -484,7 +484,7 @@ private:
} }
PageLinkedList* GetPageList() { PageLinkedList* GetPageList() {
return &m_ll; return std::addressof(m_ll);
} }
}; };

7
src/core/hle/kernel/k_process.cpp
View File

@ -44,12 +44,13 @@ void SetupMainThread(Core::System& system, KProcess& owner_process, u32 priority
SCOPE_EXIT({ thread->Close(); }); SCOPE_EXIT({ thread->Close(); });
ASSERT(KThread::InitializeUserThread(system, thread, entry_point, 0, stack_top, priority, ASSERT(KThread::InitializeUserThread(system, thread, entry_point, 0, stack_top, priority,
owner_process.GetIdealCoreId(), &owner_process) owner_process.GetIdealCoreId(),
std::addressof(owner_process))
.IsSuccess()); .IsSuccess());
// Register 1 must be a handle to the main thread // Register 1 must be a handle to the main thread
Handle thread_handle{}; Handle thread_handle{};
owner_process.GetHandleTable().Add(&thread_handle, thread); owner_process.GetHandleTable().Add(std::addressof(thread_handle), thread);
thread->SetName("main"); thread->SetName("main");
thread->GetContext32().cpu_registers[0] = 0; thread->GetContext32().cpu_registers[0] = 0;
@ -366,7 +367,7 @@ Result KProcess::LoadFromMetadata(const FileSys::ProgramMetadata& metadata, std:
// Initialize process address space // Initialize process address space
if (const Result result{page_table.InitializeForProcess( if (const Result result{page_table.InitializeForProcess(
metadata.GetAddressSpaceType(), false, false, false, KMemoryManager::Pool::Application, metadata.GetAddressSpaceType(), false, false, false, KMemoryManager::Pool::Application,
0x8000000, code_size, &m_kernel.GetAppSystemResource(), resource_limit)}; 0x8000000, code_size, std::addressof(m_kernel.GetAppSystemResource()), resource_limit)};
result.IsError()) { result.IsError()) {
R_RETURN(result); R_RETURN(result);
} }

4
src/core/hle/kernel/k_resource_limit.cpp
View File

@ -119,7 +119,7 @@ bool KResourceLimit::Reserve(LimitableResource which, s64 value, s64 timeout) {
if (m_current_hints[index] + value <= m_limit_values[index] && if (m_current_hints[index] + value <= m_limit_values[index] &&
(timeout < 0 || m_core_timing->GetGlobalTimeNs().count() < timeout)) { (timeout < 0 || m_core_timing->GetGlobalTimeNs().count() < timeout)) {
m_waiter_count++; m_waiter_count++;
m_cond_var.Wait(&m_lock, timeout, false); m_cond_var.Wait(std::addressof(m_lock), timeout, false);
m_waiter_count--; m_waiter_count--;
} else { } else {
break; break;
@ -154,7 +154,7 @@ void KResourceLimit::Release(LimitableResource which, s64 value, s64 hint) {
KResourceLimit* CreateResourceLimitForProcess(Core::System& system, s64 physical_memory_size) { KResourceLimit* CreateResourceLimitForProcess(Core::System& system, s64 physical_memory_size) {
auto* resource_limit = KResourceLimit::Create(system.Kernel()); auto* resource_limit = KResourceLimit::Create(system.Kernel());
resource_limit->Initialize(&system.CoreTiming()); resource_limit->Initialize(std::addressof(system.CoreTiming()));
// Initialize default resource limit values. // Initialize default resource limit values.
// TODO(bunnei): These values are the system defaults, the limits for service processes are // TODO(bunnei): These values are the system defaults, the limits for service processes are

2
src/core/hle/kernel/k_scheduler.cpp
View File

@ -149,7 +149,7 @@ void KScheduler::Initialize(KThread* main_thread, KThread* idle_thread, s32 core
m_core_id = core_id; m_core_id = core_id;
m_idle_thread = idle_thread; m_idle_thread = idle_thread;
// m_state.idle_thread_stack = m_idle_thread->GetStackTop(); // m_state.idle_thread_stack = m_idle_thread->GetStackTop();
// m_state.interrupt_task_manager = &kernel.GetInterruptTaskManager(); // m_state.interrupt_task_manager = std::addressof(kernel.GetInterruptTaskManager());
// Insert the main thread into the priority queue. // Insert the main thread into the priority queue.
// { // {

13
src/core/hle/kernel/k_server_session.cpp
View File

@ -115,7 +115,7 @@ void KServerSession::OnClientClosed() {
// // Get the process and page table. // // Get the process and page table.
// KProcess *client_process = thread->GetOwnerProcess(); // KProcess *client_process = thread->GetOwnerProcess();
// auto &client_pt = client_process->GetPageTable(); // auto& client_pt = client_process->GetPageTable();
// // Reply to the request. // // Reply to the request.
// ReplyAsyncError(client_process, request->GetAddress(), request->GetSize(), // ReplyAsyncError(client_process, request->GetAddress(), request->GetSize(),
@ -177,7 +177,7 @@ Result KServerSession::OnRequest(KSessionRequest* request) {
// This is a synchronous request, so we should wait for our request to complete. // This is a synchronous request, so we should wait for our request to complete.
GetCurrentThread(m_kernel).SetWaitReasonForDebugging(ThreadWaitReasonForDebugging::IPC); GetCurrentThread(m_kernel).SetWaitReasonForDebugging(ThreadWaitReasonForDebugging::IPC);
GetCurrentThread(m_kernel).BeginWait(&wait_queue); GetCurrentThread(m_kernel).BeginWait(std::addressof(wait_queue));
} }
return GetCurrentThread(m_kernel).GetWaitResult(); return GetCurrentThread(m_kernel).GetWaitResult();
@ -248,7 +248,7 @@ Result KServerSession::SendReply(bool is_hle) {
if (event != nullptr) { if (event != nullptr) {
// // Get the client process/page table. // // Get the client process/page table.
// KProcess *client_process = client_thread->GetOwnerProcess(); // KProcess *client_process = client_thread->GetOwnerProcess();
// KPageTable *client_page_table = &client_process->PageTable(); // KPageTable *client_page_table = std::addressof(client_process->PageTable());
// // If we need to, reply with an async error. // // If we need to, reply with an async error.
// if (R_FAILED(client_result)) { // if (R_FAILED(client_result)) {
@ -297,7 +297,7 @@ Result KServerSession::ReceiveRequest(std::shared_ptr<Service::HLERequestContext
R_UNLESS(!m_request_list.empty(), ResultNotFound); R_UNLESS(!m_request_list.empty(), ResultNotFound);
// Pop the first request from the list. // Pop the first request from the list.
request = &m_request_list.front(); request = std::addressof(m_request_list.front());
m_request_list.pop_front(); m_request_list.pop_front();
// Get the thread for the request. // Get the thread for the request.
@ -358,7 +358,7 @@ void KServerSession::CleanupRequests() {
m_current_request = nullptr; m_current_request = nullptr;
} else if (!m_request_list.empty()) { } else if (!m_request_list.empty()) {
// Pop the request from the front of the list. // Pop the request from the front of the list.
request = &m_request_list.front(); request = std::addressof(m_request_list.front());
m_request_list.pop_front(); m_request_list.pop_front();
} }
} }
@ -381,7 +381,8 @@ void KServerSession::CleanupRequests() {
// KProcess *client_process = (client_thread != nullptr) ? // KProcess *client_process = (client_thread != nullptr) ?
// client_thread->GetOwnerProcess() : nullptr; // client_thread->GetOwnerProcess() : nullptr;
// KProcessPageTable *client_page_table = (client_process != nullptr) ? // KProcessPageTable *client_page_table = (client_process != nullptr) ?
// &client_process->GetPageTable() : nullptr; // std::addressof(client_process->GetPageTable())
// : nullptr;
// Cleanup the mappings. // Cleanup the mappings.
// Result result = CleanupMap(request, server_process, client_page_table); // Result result = CleanupMap(request, server_process, client_page_table);

3
src/core/hle/kernel/k_shared_memory.cpp
View File

@ -44,7 +44,8 @@ Result KSharedMemory::Initialize(Core::DeviceMemory& device_memory, KProcess* ow
R_UNLESS(m_physical_address != 0, ResultOutOfMemory); R_UNLESS(m_physical_address != 0, ResultOutOfMemory);
//! Insert the result into our page group. //! Insert the result into our page group.
m_page_group.emplace(m_kernel, &m_kernel.GetSystemSystemResource().GetBlockInfoManager()); m_page_group.emplace(m_kernel,
std::addressof(m_kernel.GetSystemSystemResource().GetBlockInfoManager()));
m_page_group->AddBlock(m_physical_address, num_pages); m_page_group->AddBlock(m_physical_address, num_pages);
// Commit our reservation. // Commit our reservation.

3
src/core/hle/kernel/k_slab_heap.h
View File

@ -89,7 +89,8 @@ private:
if (alloc_peak <= cur_peak) { if (alloc_peak <= cur_peak) {
break; break;
} }
} while (!Common::AtomicCompareAndSwap(&m_peak, alloc_peak, cur_peak, cur_peak)); } while (
!Common::AtomicCompareAndSwap(std::addressof(m_peak), alloc_peak, cur_peak, cur_peak));
} }
public: public:

4
src/core/hle/kernel/k_thread.cpp
View File

@ -930,14 +930,14 @@ Result KThread::GetThreadContext3(std::vector<u8>& out) {
context.pstate &= 0xFF0FFE20; context.pstate &= 0xFF0FFE20;
out.resize(sizeof(context)); out.resize(sizeof(context));
std::memcpy(out.data(), &context, sizeof(context)); std::memcpy(out.data(), std::addressof(context), sizeof(context));
} else { } else {
// Mask away mode bits, interrupt bits, IL bit, and other reserved bits. // Mask away mode bits, interrupt bits, IL bit, and other reserved bits.
auto context = GetContext32(); auto context = GetContext32();
context.cpsr &= 0xFF0FFE20; context.cpsr &= 0xFF0FFE20;
out.resize(sizeof(context)); out.resize(sizeof(context));
std::memcpy(out.data(), &context, sizeof(context)); std::memcpy(out.data(), std::addressof(context), sizeof(context));
} }
} }
} }

2
src/core/hle/kernel/k_thread_local_page.cpp
View File

@ -16,7 +16,7 @@ namespace Kernel {
Result KThreadLocalPage::Initialize(KernelCore& kernel, KProcess* process) { Result KThreadLocalPage::Initialize(KernelCore& kernel, KProcess* process) {
// Set that this process owns us. // Set that this process owns us.
m_owner = process; m_owner = process;
m_kernel = &kernel; m_kernel = std::addressof(kernel);
// Allocate a new page. // Allocate a new page.
KPageBuffer* page_buf = KPageBuffer::Allocate(kernel); KPageBuffer* page_buf = KPageBuffer::Allocate(kernel);

180
src/core/hle/kernel/svc.cpp
View File

@ -36,9 +36,9 @@ static To Convert(const From& from) {
To to{}; To to{};
if constexpr (sizeof(To) >= sizeof(From)) { if constexpr (sizeof(To) >= sizeof(From)) {
std::memcpy(&to, &from, sizeof(From)); std::memcpy(std::addressof(to), std::addressof(from), sizeof(From));
} else { } else {
std::memcpy(&to, &from, sizeof(To)); std::memcpy(std::addressof(to), std::addressof(from), sizeof(To));
} }
return to; return to;
@ -87,7 +87,7 @@ static void SvcWrap_SetHeapSize64From32(Core::System& system) {
size = Convert<uint32_t>(GetReg32(system, 1)); size = Convert<uint32_t>(GetReg32(system, 1));
ret = SetHeapSize64From32(system, &out_address, size); ret = SetHeapSize64From32(system, std::addressof(out_address), size);
SetReg32(system, 0, Convert<uint32_t>(ret)); SetReg32(system, 0, Convert<uint32_t>(ret));
SetReg32(system, 1, Convert<uint32_t>(out_address)); SetReg32(system, 1, Convert<uint32_t>(out_address));
@ -169,7 +169,7 @@ static void SvcWrap_QueryMemory64From32(Core::System& system) {
out_memory_info = Convert<uint32_t>(GetReg32(system, 0)); out_memory_info = Convert<uint32_t>(GetReg32(system, 0));
address = Convert<uint32_t>(GetReg32(system, 2)); address = Convert<uint32_t>(GetReg32(system, 2));
ret = QueryMemory64From32(system, out_memory_info, &out_page_info, address); ret = QueryMemory64From32(system, out_memory_info, std::addressof(out_page_info), address);
SetReg32(system, 0, Convert<uint32_t>(ret)); SetReg32(system, 0, Convert<uint32_t>(ret));
SetReg32(system, 1, Convert<uint32_t>(out_page_info)); SetReg32(system, 1, Convert<uint32_t>(out_page_info));
@ -195,7 +195,7 @@ static void SvcWrap_CreateThread64From32(Core::System& system) {
priority = Convert<int32_t>(GetReg32(system, 0)); priority = Convert<int32_t>(GetReg32(system, 0));
core_id = Convert<int32_t>(GetReg32(system, 4)); core_id = Convert<int32_t>(GetReg32(system, 4));
ret = CreateThread64From32(system, &out_handle, func, arg, stack_bottom, priority, core_id); ret = CreateThread64From32(system, std::addressof(out_handle), func, arg, stack_bottom, priority, core_id);
SetReg32(system, 0, Convert<uint32_t>(ret)); SetReg32(system, 0, Convert<uint32_t>(ret));
SetReg32(system, 1, Convert<uint32_t>(out_handle)); SetReg32(system, 1, Convert<uint32_t>(out_handle));
@ -236,7 +236,7 @@ static void SvcWrap_GetThreadPriority64From32(Core::System& system) {
thread_handle = Convert<Handle>(GetReg32(system, 1)); thread_handle = Convert<Handle>(GetReg32(system, 1));
ret = GetThreadPriority64From32(system, &out_priority, thread_handle); ret = GetThreadPriority64From32(system, std::addressof(out_priority), thread_handle);
SetReg32(system, 0, Convert<uint32_t>(ret)); SetReg32(system, 0, Convert<uint32_t>(ret));
SetReg32(system, 1, Convert<uint32_t>(out_priority)); SetReg32(system, 1, Convert<uint32_t>(out_priority));
@ -265,7 +265,7 @@ static void SvcWrap_GetThreadCoreMask64From32(Core::System& system) {
thread_handle = Convert<Handle>(GetReg32(system, 2)); thread_handle = Convert<Handle>(GetReg32(system, 2));
ret = GetThreadCoreMask64From32(system, &out_core_id, &out_affinity_mask, thread_handle); ret = GetThreadCoreMask64From32(system, std::addressof(out_core_id), std::addressof(out_affinity_mask), thread_handle);
SetReg32(system, 0, Convert<uint32_t>(ret)); SetReg32(system, 0, Convert<uint32_t>(ret));
SetReg32(system, 1, Convert<uint32_t>(out_core_id)); SetReg32(system, 1, Convert<uint32_t>(out_core_id));
@ -371,7 +371,7 @@ static void SvcWrap_CreateTransferMemory64From32(Core::System& system) {
size = Convert<uint32_t>(GetReg32(system, 2)); size = Convert<uint32_t>(GetReg32(system, 2));
map_perm = Convert<MemoryPermission>(GetReg32(system, 3)); map_perm = Convert<MemoryPermission>(GetReg32(system, 3));
ret = CreateTransferMemory64From32(system, &out_handle, address, size, map_perm); ret = CreateTransferMemory64From32(system, std::addressof(out_handle), address, size, map_perm);
SetReg32(system, 0, Convert<uint32_t>(ret)); SetReg32(system, 0, Convert<uint32_t>(ret));
SetReg32(system, 1, Convert<uint32_t>(out_handle)); SetReg32(system, 1, Convert<uint32_t>(out_handle));
@ -416,7 +416,7 @@ static void SvcWrap_WaitSynchronization64From32(Core::System& system) {
timeout_ns_gather[1] = GetReg32(system, 3); timeout_ns_gather[1] = GetReg32(system, 3);
timeout_ns = Convert<int64_t>(timeout_ns_gather); timeout_ns = Convert<int64_t>(timeout_ns_gather);
ret = WaitSynchronization64From32(system, &out_index, handles, num_handles, timeout_ns); ret = WaitSynchronization64From32(system, std::addressof(out_index), handles, num_handles, timeout_ns);
SetReg32(system, 0, Convert<uint32_t>(ret)); SetReg32(system, 0, Convert<uint32_t>(ret));
SetReg32(system, 1, Convert<uint32_t>(out_index)); SetReg32(system, 1, Convert<uint32_t>(out_index));
@ -511,7 +511,7 @@ static void SvcWrap_ConnectToNamedPort64From32(Core::System& system) {
name = Convert<uint32_t>(GetReg32(system, 1)); name = Convert<uint32_t>(GetReg32(system, 1));
ret = ConnectToNamedPort64From32(system, &out_handle, name); ret = ConnectToNamedPort64From32(system, std::addressof(out_handle), name);
SetReg32(system, 0, Convert<uint32_t>(ret)); SetReg32(system, 0, Convert<uint32_t>(ret));
SetReg32(system, 1, Convert<uint32_t>(out_handle)); SetReg32(system, 1, Convert<uint32_t>(out_handle));
@ -557,7 +557,7 @@ static void SvcWrap_SendAsyncRequestWithUserBuffer64From32(Core::System& system)
message_buffer_size = Convert<uint32_t>(GetReg32(system, 2)); message_buffer_size = Convert<uint32_t>(GetReg32(system, 2));
session_handle = Convert<Handle>(GetReg32(system, 3)); session_handle = Convert<Handle>(GetReg32(system, 3));
ret = SendAsyncRequestWithUserBuffer64From32(system, &out_event_handle, message_buffer, message_buffer_size, session_handle); ret = SendAsyncRequestWithUserBuffer64From32(system, std::addressof(out_event_handle), message_buffer, message_buffer_size, session_handle);
SetReg32(system, 0, Convert<uint32_t>(ret)); SetReg32(system, 0, Convert<uint32_t>(ret));
SetReg32(system, 1, Convert<uint32_t>(out_event_handle)); SetReg32(system, 1, Convert<uint32_t>(out_event_handle));
@ -571,7 +571,7 @@ static void SvcWrap_GetProcessId64From32(Core::System& system) {
process_handle = Convert<Handle>(GetReg32(system, 1)); process_handle = Convert<Handle>(GetReg32(system, 1));
ret = GetProcessId64From32(system, &out_process_id, process_handle); ret = GetProcessId64From32(system, std::addressof(out_process_id), process_handle);
SetReg32(system, 0, Convert<uint32_t>(ret)); SetReg32(system, 0, Convert<uint32_t>(ret));
auto out_process_id_scatter = Convert<std::array<uint32_t, 2>>(out_process_id); auto out_process_id_scatter = Convert<std::array<uint32_t, 2>>(out_process_id);
@ -587,7 +587,7 @@ static void SvcWrap_GetThreadId64From32(Core::System& system) {
thread_handle = Convert<Handle>(GetReg32(system, 1)); thread_handle = Convert<Handle>(GetReg32(system, 1));
ret = GetThreadId64From32(system, &out_thread_id, thread_handle); ret = GetThreadId64From32(system, std::addressof(out_thread_id), thread_handle);
SetReg32(system, 0, Convert<uint32_t>(ret)); SetReg32(system, 0, Convert<uint32_t>(ret));
auto out_thread_id_scatter = Convert<std::array<uint32_t, 2>>(out_thread_id); auto out_thread_id_scatter = Convert<std::array<uint32_t, 2>>(out_thread_id);
@ -644,7 +644,7 @@ static void SvcWrap_GetInfo64From32(Core::System& system) {
info_subtype_gather[1] = GetReg32(system, 3); info_subtype_gather[1] = GetReg32(system, 3);
info_subtype = Convert<uint64_t>(info_subtype_gather); info_subtype = Convert<uint64_t>(info_subtype_gather);
ret = GetInfo64From32(system, &out, info_type, handle, info_subtype); ret = GetInfo64From32(system, std::addressof(out), info_type, handle, info_subtype);
SetReg32(system, 0, Convert<uint32_t>(ret)); SetReg32(system, 0, Convert<uint32_t>(ret));
auto out_scatter = Convert<std::array<uint32_t, 2>>(out); auto out_scatter = Convert<std::array<uint32_t, 2>>(out);
@ -712,7 +712,7 @@ static void SvcWrap_GetDebugFutureThreadInfo64From32(Core::System& system) {
ns_gather[1] = GetReg32(system, 1); ns_gather[1] = GetReg32(system, 1);
ns = Convert<int64_t>(ns_gather); ns = Convert<int64_t>(ns_gather);
ret = GetDebugFutureThreadInfo64From32(system, &out_context, &out_thread_id, debug_handle, ns); ret = GetDebugFutureThreadInfo64From32(system, std::addressof(out_context), std::addressof(out_thread_id), debug_handle, ns);
SetReg32(system, 0, Convert<uint32_t>(ret)); SetReg32(system, 0, Convert<uint32_t>(ret));
auto out_context_scatter = Convert<std::array<uint32_t, 4>>(out_context); auto out_context_scatter = Convert<std::array<uint32_t, 4>>(out_context);
@ -732,7 +732,7 @@ static void SvcWrap_GetLastThreadInfo64From32(Core::System& system) {
uint64_t out_tls_address{}; uint64_t out_tls_address{};
uint32_t out_flags{}; uint32_t out_flags{};
ret = GetLastThreadInfo64From32(system, &out_context, &out_tls_address, &out_flags); ret = GetLastThreadInfo64From32(system, std::addressof(out_context), std::addressof(out_tls_address), std::addressof(out_flags));
SetReg32(system, 0, Convert<uint32_t>(ret)); SetReg32(system, 0, Convert<uint32_t>(ret));
auto out_context_scatter = Convert<std::array<uint32_t, 4>>(out_context); auto out_context_scatter = Convert<std::array<uint32_t, 4>>(out_context);
@ -754,7 +754,7 @@ static void SvcWrap_GetResourceLimitLimitValue64From32(Core::System& system) {
resource_limit_handle = Convert<Handle>(GetReg32(system, 1)); resource_limit_handle = Convert<Handle>(GetReg32(system, 1));
which = Convert<LimitableResource>(GetReg32(system, 2)); which = Convert<LimitableResource>(GetReg32(system, 2));
ret = GetResourceLimitLimitValue64From32(system, &out_limit_value, resource_limit_handle, which); ret = GetResourceLimitLimitValue64From32(system, std::addressof(out_limit_value), resource_limit_handle, which);
SetReg32(system, 0, Convert<uint32_t>(ret)); SetReg32(system, 0, Convert<uint32_t>(ret));
auto out_limit_value_scatter = Convert<std::array<uint32_t, 2>>(out_limit_value); auto out_limit_value_scatter = Convert<std::array<uint32_t, 2>>(out_limit_value);
@ -772,7 +772,7 @@ static void SvcWrap_GetResourceLimitCurrentValue64From32(Core::System& system) {
resource_limit_handle = Convert<Handle>(GetReg32(system, 1)); resource_limit_handle = Convert<Handle>(GetReg32(system, 1));
which = Convert<LimitableResource>(GetReg32(system, 2)); which = Convert<LimitableResource>(GetReg32(system, 2));
ret = GetResourceLimitCurrentValue64From32(system, &out_current_value, resource_limit_handle, which); ret = GetResourceLimitCurrentValue64From32(system, std::addressof(out_current_value), resource_limit_handle, which);
SetReg32(system, 0, Convert<uint32_t>(ret)); SetReg32(system, 0, Convert<uint32_t>(ret));
auto out_current_value_scatter = Convert<std::array<uint32_t, 2>>(out_current_value); auto out_current_value_scatter = Convert<std::array<uint32_t, 2>>(out_current_value);
@ -861,7 +861,7 @@ static void SvcWrap_GetResourceLimitPeakValue64From32(Core::System& system) {
resource_limit_handle = Convert<Handle>(GetReg32(system, 1)); resource_limit_handle = Convert<Handle>(GetReg32(system, 1));
which = Convert<LimitableResource>(GetReg32(system, 2)); which = Convert<LimitableResource>(GetReg32(system, 2));
ret = GetResourceLimitPeakValue64From32(system, &out_peak_value, resource_limit_handle, which); ret = GetResourceLimitPeakValue64From32(system, std::addressof(out_peak_value), resource_limit_handle, which);
SetReg32(system, 0, Convert<uint32_t>(ret)); SetReg32(system, 0, Convert<uint32_t>(ret));
auto out_peak_value_scatter = Convert<std::array<uint32_t, 2>>(out_peak_value); auto out_peak_value_scatter = Convert<std::array<uint32_t, 2>>(out_peak_value);
@ -877,7 +877,7 @@ static void SvcWrap_CreateIoPool64From32(Core::System& system) {
which = Convert<IoPoolType>(GetReg32(system, 1)); which = Convert<IoPoolType>(GetReg32(system, 1));
ret = CreateIoPool64From32(system, &out_handle, which); ret = CreateIoPool64From32(system, std::addressof(out_handle), which);
SetReg32(system, 0, Convert<uint32_t>(ret)); SetReg32(system, 0, Convert<uint32_t>(ret));
SetReg32(system, 1, Convert<uint32_t>(out_handle)); SetReg32(system, 1, Convert<uint32_t>(out_handle));
@ -902,7 +902,7 @@ static void SvcWrap_CreateIoRegion64From32(Core::System& system) {
mapping = Convert<MemoryMapping>(GetReg32(system, 4)); mapping = Convert<MemoryMapping>(GetReg32(system, 4));
perm = Convert<MemoryPermission>(GetReg32(system, 5)); perm = Convert<MemoryPermission>(GetReg32(system, 5));
ret = CreateIoRegion64From32(system, &out_handle, io_pool, physical_address, size, mapping, perm); ret = CreateIoRegion64From32(system, std::addressof(out_handle), io_pool, physical_address, size, mapping, perm);
SetReg32(system, 0, Convert<uint32_t>(ret)); SetReg32(system, 0, Convert<uint32_t>(ret));
SetReg32(system, 1, Convert<uint32_t>(out_handle)); SetReg32(system, 1, Convert<uint32_t>(out_handle));
@ -950,7 +950,7 @@ static void SvcWrap_CreateSession64From32(Core::System& system) {
is_light = Convert<bool>(GetReg32(system, 2)); is_light = Convert<bool>(GetReg32(system, 2));
name = Convert<uint32_t>(GetReg32(system, 3)); name = Convert<uint32_t>(GetReg32(system, 3));
ret = CreateSession64From32(system, &out_server_session_handle, &out_client_session_handle, is_light, name); 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, 0, Convert<uint32_t>(ret));
SetReg32(system, 1, Convert<uint32_t>(out_server_session_handle)); SetReg32(system, 1, Convert<uint32_t>(out_server_session_handle));
@ -965,7 +965,7 @@ static void SvcWrap_AcceptSession64From32(Core::System& system) {
port = Convert<Handle>(GetReg32(system, 1)); port = Convert<Handle>(GetReg32(system, 1));
ret = AcceptSession64From32(system, &out_handle, port); ret = AcceptSession64From32(system, std::addressof(out_handle), port);
SetReg32(system, 0, Convert<uint32_t>(ret)); SetReg32(system, 0, Convert<uint32_t>(ret));
SetReg32(system, 1, Convert<uint32_t>(out_handle)); SetReg32(system, 1, Convert<uint32_t>(out_handle));
@ -988,7 +988,7 @@ static void SvcWrap_ReplyAndReceive64From32(Core::System& system) {
timeout_ns_gather[1] = GetReg32(system, 4); timeout_ns_gather[1] = GetReg32(system, 4);
timeout_ns = Convert<int64_t>(timeout_ns_gather); timeout_ns = Convert<int64_t>(timeout_ns_gather);
ret = ReplyAndReceive64From32(system, &out_index, handles, num_handles, reply_target, timeout_ns); ret = ReplyAndReceive64From32(system, std::addressof(out_index), handles, num_handles, reply_target, timeout_ns);
SetReg32(system, 0, Convert<uint32_t>(ret)); SetReg32(system, 0, Convert<uint32_t>(ret));
SetReg32(system, 1, Convert<uint32_t>(out_index)); SetReg32(system, 1, Convert<uint32_t>(out_index));
@ -1015,7 +1015,7 @@ static void SvcWrap_ReplyAndReceiveWithUserBuffer64From32(Core::System& system)
timeout_ns_gather[1] = GetReg32(system, 6); timeout_ns_gather[1] = GetReg32(system, 6);
timeout_ns = Convert<int64_t>(timeout_ns_gather); timeout_ns = Convert<int64_t>(timeout_ns_gather);
ret = ReplyAndReceiveWithUserBuffer64From32(system, &out_index, message_buffer, message_buffer_size, handles, num_handles, reply_target, timeout_ns); 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, 0, Convert<uint32_t>(ret));
SetReg32(system, 1, Convert<uint32_t>(out_index)); SetReg32(system, 1, Convert<uint32_t>(out_index));
@ -1027,7 +1027,7 @@ static void SvcWrap_CreateEvent64From32(Core::System& system) {
Handle out_write_handle{}; Handle out_write_handle{};
Handle out_read_handle{}; Handle out_read_handle{};
ret = CreateEvent64From32(system, &out_write_handle, &out_read_handle); ret = CreateEvent64From32(system, std::addressof(out_write_handle), std::addressof(out_read_handle));
SetReg32(system, 0, Convert<uint32_t>(ret)); SetReg32(system, 0, Convert<uint32_t>(ret));
SetReg32(system, 1, Convert<uint32_t>(out_write_handle)); SetReg32(system, 1, Convert<uint32_t>(out_write_handle));
@ -1118,7 +1118,7 @@ static void SvcWrap_CreateCodeMemory64From32(Core::System& system) {
address = Convert<uint32_t>(GetReg32(system, 1)); address = Convert<uint32_t>(GetReg32(system, 1));
size = Convert<uint32_t>(GetReg32(system, 2)); size = Convert<uint32_t>(GetReg32(system, 2));
ret = CreateCodeMemory64From32(system, &out_handle, address, size); ret = CreateCodeMemory64From32(system, std::addressof(out_handle), address, size);
SetReg32(system, 0, Convert<uint32_t>(ret)); SetReg32(system, 0, Convert<uint32_t>(ret));
SetReg32(system, 1, Convert<uint32_t>(out_handle)); SetReg32(system, 1, Convert<uint32_t>(out_handle));
@ -1169,7 +1169,7 @@ static void SvcWrap_ReadWriteRegister64From32(Core::System& system) {
mask = Convert<uint32_t>(GetReg32(system, 0)); mask = Convert<uint32_t>(GetReg32(system, 0));
value = Convert<uint32_t>(GetReg32(system, 1)); value = Convert<uint32_t>(GetReg32(system, 1));
ret = ReadWriteRegister64From32(system, &out_value, address, mask, value); ret = ReadWriteRegister64From32(system, std::addressof(out_value), address, mask, value);
SetReg32(system, 0, Convert<uint32_t>(ret)); SetReg32(system, 0, Convert<uint32_t>(ret));
SetReg32(system, 1, Convert<uint32_t>(out_value)); SetReg32(system, 1, Convert<uint32_t>(out_value));
@ -1201,7 +1201,7 @@ static void SvcWrap_CreateSharedMemory64From32(Core::System& system) {
owner_perm = Convert<MemoryPermission>(GetReg32(system, 2)); owner_perm = Convert<MemoryPermission>(GetReg32(system, 2));
remote_perm = Convert<MemoryPermission>(GetReg32(system, 3)); remote_perm = Convert<MemoryPermission>(GetReg32(system, 3));
ret = CreateSharedMemory64From32(system, &out_handle, size, owner_perm, remote_perm); ret = CreateSharedMemory64From32(system, std::addressof(out_handle), size, owner_perm, remote_perm);
SetReg32(system, 0, Convert<uint32_t>(ret)); SetReg32(system, 0, Convert<uint32_t>(ret));
SetReg32(system, 1, Convert<uint32_t>(out_handle)); SetReg32(system, 1, Convert<uint32_t>(out_handle));
@ -1251,7 +1251,7 @@ static void SvcWrap_CreateInterruptEvent64From32(Core::System& system) {
interrupt_id = Convert<int32_t>(GetReg32(system, 1)); interrupt_id = Convert<int32_t>(GetReg32(system, 1));
interrupt_type = Convert<InterruptType>(GetReg32(system, 2)); interrupt_type = Convert<InterruptType>(GetReg32(system, 2));
ret = CreateInterruptEvent64From32(system, &out_read_handle, interrupt_id, interrupt_type); ret = CreateInterruptEvent64From32(system, std::addressof(out_read_handle), interrupt_id, interrupt_type);
SetReg32(system, 0, Convert<uint32_t>(ret)); SetReg32(system, 0, Convert<uint32_t>(ret));
SetReg32(system, 1, Convert<uint32_t>(out_read_handle)); SetReg32(system, 1, Convert<uint32_t>(out_read_handle));
@ -1265,7 +1265,7 @@ static void SvcWrap_QueryPhysicalAddress64From32(Core::System& system) {
address = Convert<uint32_t>(GetReg32(system, 1)); address = Convert<uint32_t>(GetReg32(system, 1));
ret = QueryPhysicalAddress64From32(system, &out_info, address); ret = QueryPhysicalAddress64From32(system, std::addressof(out_info), address);
SetReg32(system, 0, Convert<uint32_t>(ret)); SetReg32(system, 0, Convert<uint32_t>(ret));
auto out_info_scatter = Convert<std::array<uint32_t, 4>>(out_info); auto out_info_scatter = Convert<std::array<uint32_t, 4>>(out_info);
@ -1289,7 +1289,7 @@ static void SvcWrap_QueryIoMapping64From32(Core::System& system) {
physical_address = Convert<uint64_t>(physical_address_gather); physical_address = Convert<uint64_t>(physical_address_gather);
size = Convert<uint32_t>(GetReg32(system, 0)); size = Convert<uint32_t>(GetReg32(system, 0));
ret = QueryIoMapping64From32(system, &out_address, &out_size, physical_address, size); ret = QueryIoMapping64From32(system, std::addressof(out_address), std::addressof(out_size), physical_address, size);
SetReg32(system, 0, Convert<uint32_t>(ret)); SetReg32(system, 0, Convert<uint32_t>(ret));
SetReg32(system, 1, Convert<uint32_t>(out_address)); SetReg32(system, 1, Convert<uint32_t>(out_address));
@ -1312,7 +1312,7 @@ static void SvcWrap_CreateDeviceAddressSpace64From32(Core::System& system) {
das_size_gather[1] = GetReg32(system, 1); das_size_gather[1] = GetReg32(system, 1);
das_size = Convert<uint64_t>(das_size_gather); das_size = Convert<uint64_t>(das_size_gather);
ret = CreateDeviceAddressSpace64From32(system, &out_handle, das_address, das_size); ret = CreateDeviceAddressSpace64From32(system, std::addressof(out_handle), das_address, das_size);
SetReg32(system, 0, Convert<uint32_t>(ret)); SetReg32(system, 0, Convert<uint32_t>(ret));
SetReg32(system, 1, Convert<uint32_t>(out_handle)); SetReg32(system, 1, Convert<uint32_t>(out_handle));
@ -1505,7 +1505,7 @@ static void SvcWrap_DebugActiveProcess64From32(Core::System& system) {
process_id_gather[1] = GetReg32(system, 3); process_id_gather[1] = GetReg32(system, 3);
process_id = Convert<uint64_t>(process_id_gather); process_id = Convert<uint64_t>(process_id_gather);
ret = DebugActiveProcess64From32(system, &out_handle, process_id); ret = DebugActiveProcess64From32(system, std::addressof(out_handle), process_id);
SetReg32(system, 0, Convert<uint32_t>(ret)); SetReg32(system, 0, Convert<uint32_t>(ret));
SetReg32(system, 1, Convert<uint32_t>(out_handle)); SetReg32(system, 1, Convert<uint32_t>(out_handle));
@ -1577,7 +1577,7 @@ static void SvcWrap_GetProcessList64From32(Core::System& system) {
out_process_ids = Convert<uint32_t>(GetReg32(system, 1)); out_process_ids = Convert<uint32_t>(GetReg32(system, 1));
max_out_count = Convert<int32_t>(GetReg32(system, 2)); max_out_count = Convert<int32_t>(GetReg32(system, 2));
ret = GetProcessList64From32(system, &out_num_processes, out_process_ids, max_out_count); ret = GetProcessList64From32(system, std::addressof(out_num_processes), out_process_ids, max_out_count);
SetReg32(system, 0, Convert<uint32_t>(ret)); SetReg32(system, 0, Convert<uint32_t>(ret));
SetReg32(system, 1, Convert<uint32_t>(out_num_processes)); SetReg32(system, 1, Convert<uint32_t>(out_num_processes));
@ -1595,7 +1595,7 @@ static void SvcWrap_GetThreadList64From32(Core::System& system) {
max_out_count = Convert<int32_t>(GetReg32(system, 2)); max_out_count = Convert<int32_t>(GetReg32(system, 2));
debug_handle = Convert<Handle>(GetReg32(system, 3)); debug_handle = Convert<Handle>(GetReg32(system, 3));
ret = GetThreadList64From32(system, &out_num_threads, out_thread_ids, max_out_count, debug_handle); 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, 0, Convert<uint32_t>(ret));
SetReg32(system, 1, Convert<uint32_t>(out_num_threads)); SetReg32(system, 1, Convert<uint32_t>(out_num_threads));
@ -1655,7 +1655,7 @@ static void SvcWrap_QueryDebugProcessMemory64From32(Core::System& system) {
process_handle = Convert<Handle>(GetReg32(system, 2)); process_handle = Convert<Handle>(GetReg32(system, 2));
address = Convert<uint32_t>(GetReg32(system, 3)); address = Convert<uint32_t>(GetReg32(system, 3));
ret = QueryDebugProcessMemory64From32(system, out_memory_info, &out_page_info, process_handle, address); ret = QueryDebugProcessMemory64From32(system, out_memory_info, std::addressof(out_page_info), process_handle, address);
SetReg32(system, 0, Convert<uint32_t>(ret)); SetReg32(system, 0, Convert<uint32_t>(ret));
SetReg32(system, 1, Convert<uint32_t>(out_page_info)); SetReg32(system, 1, Convert<uint32_t>(out_page_info));
@ -1735,7 +1735,7 @@ static void SvcWrap_GetDebugThreadParam64From32(Core::System& system) {
thread_id = Convert<uint64_t>(thread_id_gather); thread_id = Convert<uint64_t>(thread_id_gather);
param = Convert<DebugThreadParam>(GetReg32(system, 3)); param = Convert<DebugThreadParam>(GetReg32(system, 3));
ret = GetDebugThreadParam64From32(system, &out_64, &out_32, debug_handle, thread_id, param); ret = GetDebugThreadParam64From32(system, std::addressof(out_64), std::addressof(out_32), debug_handle, thread_id, param);
SetReg32(system, 0, Convert<uint32_t>(ret)); SetReg32(system, 0, Convert<uint32_t>(ret));
auto out_64_scatter = Convert<std::array<uint32_t, 2>>(out_64); auto out_64_scatter = Convert<std::array<uint32_t, 2>>(out_64);
@ -1759,7 +1759,7 @@ static void SvcWrap_GetSystemInfo64From32(Core::System& system) {
info_subtype_gather[1] = GetReg32(system, 3); info_subtype_gather[1] = GetReg32(system, 3);
info_subtype = Convert<uint64_t>(info_subtype_gather); info_subtype = Convert<uint64_t>(info_subtype_gather);
ret = GetSystemInfo64From32(system, &out, info_type, handle, info_subtype); ret = GetSystemInfo64From32(system, std::addressof(out), info_type, handle, info_subtype);
SetReg32(system, 0, Convert<uint32_t>(ret)); SetReg32(system, 0, Convert<uint32_t>(ret));
auto out_scatter = Convert<std::array<uint32_t, 2>>(out); auto out_scatter = Convert<std::array<uint32_t, 2>>(out);
@ -1780,7 +1780,7 @@ static void SvcWrap_CreatePort64From32(Core::System& system) {
is_light = Convert<bool>(GetReg32(system, 3)); is_light = Convert<bool>(GetReg32(system, 3));
name = Convert<uint32_t>(GetReg32(system, 0)); name = Convert<uint32_t>(GetReg32(system, 0));
ret = CreatePort64From32(system, &out_server_handle, &out_client_handle, max_sessions, is_light, name); 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, 0, Convert<uint32_t>(ret));
SetReg32(system, 1, Convert<uint32_t>(out_server_handle)); SetReg32(system, 1, Convert<uint32_t>(out_server_handle));
@ -1797,7 +1797,7 @@ static void SvcWrap_ManageNamedPort64From32(Core::System& system) {
name = Convert<uint32_t>(GetReg32(system, 1)); name = Convert<uint32_t>(GetReg32(system, 1));
max_sessions = Convert<int32_t>(GetReg32(system, 2)); max_sessions = Convert<int32_t>(GetReg32(system, 2));
ret = ManageNamedPort64From32(system, &out_server_handle, name, max_sessions); ret = ManageNamedPort64From32(system, std::addressof(out_server_handle), name, max_sessions);
SetReg32(system, 0, Convert<uint32_t>(ret)); SetReg32(system, 0, Convert<uint32_t>(ret));
SetReg32(system, 1, Convert<uint32_t>(out_server_handle)); SetReg32(system, 1, Convert<uint32_t>(out_server_handle));
@ -1811,7 +1811,7 @@ static void SvcWrap_ConnectToPort64From32(Core::System& system) {
port = Convert<Handle>(GetReg32(system, 1)); port = Convert<Handle>(GetReg32(system, 1));
ret = ConnectToPort64From32(system, &out_handle, port); ret = ConnectToPort64From32(system, std::addressof(out_handle), port);
SetReg32(system, 0, Convert<uint32_t>(ret)); SetReg32(system, 0, Convert<uint32_t>(ret));
SetReg32(system, 1, Convert<uint32_t>(out_handle)); SetReg32(system, 1, Convert<uint32_t>(out_handle));
@ -1898,7 +1898,7 @@ static void SvcWrap_QueryProcessMemory64From32(Core::System& system) {
address_gather[1] = GetReg32(system, 3); address_gather[1] = GetReg32(system, 3);
address = Convert<uint64_t>(address_gather); address = Convert<uint64_t>(address_gather);
ret = QueryProcessMemory64From32(system, out_memory_info, &out_page_info, process_handle, address); ret = QueryProcessMemory64From32(system, out_memory_info, std::addressof(out_page_info), process_handle, address);
SetReg32(system, 0, Convert<uint32_t>(ret)); SetReg32(system, 0, Convert<uint32_t>(ret));
SetReg32(system, 1, Convert<uint32_t>(out_page_info)); SetReg32(system, 1, Convert<uint32_t>(out_page_info));
@ -1970,7 +1970,7 @@ static void SvcWrap_CreateProcess64From32(Core::System& system) {
caps = Convert<uint32_t>(GetReg32(system, 2)); caps = Convert<uint32_t>(GetReg32(system, 2));
num_caps = Convert<int32_t>(GetReg32(system, 3)); num_caps = Convert<int32_t>(GetReg32(system, 3));
ret = CreateProcess64From32(system, &out_handle, parameters, caps, num_caps); ret = CreateProcess64From32(system, std::addressof(out_handle), parameters, caps, num_caps);
SetReg32(system, 0, Convert<uint32_t>(ret)); SetReg32(system, 0, Convert<uint32_t>(ret));
SetReg32(system, 1, Convert<uint32_t>(out_handle)); SetReg32(system, 1, Convert<uint32_t>(out_handle));
@ -2019,7 +2019,7 @@ static void SvcWrap_GetProcessInfo64From32(Core::System& system) {
process_handle = Convert<Handle>(GetReg32(system, 1)); process_handle = Convert<Handle>(GetReg32(system, 1));
info_type = Convert<ProcessInfoType>(GetReg32(system, 2)); info_type = Convert<ProcessInfoType>(GetReg32(system, 2));
ret = GetProcessInfo64From32(system, &out_info, process_handle, info_type); ret = GetProcessInfo64From32(system, std::addressof(out_info), process_handle, info_type);
SetReg32(system, 0, Convert<uint32_t>(ret)); SetReg32(system, 0, Convert<uint32_t>(ret));
auto out_info_scatter = Convert<std::array<uint32_t, 2>>(out_info); auto out_info_scatter = Convert<std::array<uint32_t, 2>>(out_info);
@ -2032,7 +2032,7 @@ static void SvcWrap_CreateResourceLimit64From32(Core::System& system) {
Handle out_handle{}; Handle out_handle{};
ret = CreateResourceLimit64From32(system, &out_handle); ret = CreateResourceLimit64From32(system, std::addressof(out_handle));
SetReg32(system, 0, Convert<uint32_t>(ret)); SetReg32(system, 0, Convert<uint32_t>(ret));
SetReg32(system, 1, Convert<uint32_t>(out_handle)); SetReg32(system, 1, Convert<uint32_t>(out_handle));
@ -2093,7 +2093,7 @@ static void SvcWrap_SetHeapSize64(Core::System& system) {
size = Convert<uint64_t>(GetReg64(system, 1)); size = Convert<uint64_t>(GetReg64(system, 1));
ret = SetHeapSize64(system, &out_address, size); ret = SetHeapSize64(system, std::addressof(out_address), size);
SetReg64(system, 0, Convert<uint64_t>(ret)); SetReg64(system, 0, Convert<uint64_t>(ret));
SetReg64(system, 1, Convert<uint64_t>(out_address)); SetReg64(system, 1, Convert<uint64_t>(out_address));
@ -2175,7 +2175,7 @@ static void SvcWrap_QueryMemory64(Core::System& system) {
out_memory_info = Convert<uint64_t>(GetReg64(system, 0)); out_memory_info = Convert<uint64_t>(GetReg64(system, 0));
address = Convert<uint64_t>(GetReg64(system, 2)); address = Convert<uint64_t>(GetReg64(system, 2));
ret = QueryMemory64(system, out_memory_info, &out_page_info, address); ret = QueryMemory64(system, out_memory_info, std::addressof(out_page_info), address);
SetReg64(system, 0, Convert<uint64_t>(ret)); SetReg64(system, 0, Convert<uint64_t>(ret));
SetReg64(system, 1, Convert<uint64_t>(out_page_info)); SetReg64(system, 1, Convert<uint64_t>(out_page_info));
@ -2201,7 +2201,7 @@ static void SvcWrap_CreateThread64(Core::System& system) {
priority = Convert<int32_t>(GetReg64(system, 4)); priority = Convert<int32_t>(GetReg64(system, 4));
core_id = Convert<int32_t>(GetReg64(system, 5)); core_id = Convert<int32_t>(GetReg64(system, 5));
ret = CreateThread64(system, &out_handle, func, arg, stack_bottom, priority, core_id); ret = CreateThread64(system, std::addressof(out_handle), func, arg, stack_bottom, priority, core_id);
SetReg64(system, 0, Convert<uint64_t>(ret)); SetReg64(system, 0, Convert<uint64_t>(ret));
SetReg64(system, 1, Convert<uint64_t>(out_handle)); SetReg64(system, 1, Convert<uint64_t>(out_handle));
@ -2239,7 +2239,7 @@ static void SvcWrap_GetThreadPriority64(Core::System& system) {
thread_handle = Convert<Handle>(GetReg64(system, 1)); thread_handle = Convert<Handle>(GetReg64(system, 1));
ret = GetThreadPriority64(system, &out_priority, thread_handle); ret = GetThreadPriority64(system, std::addressof(out_priority), thread_handle);
SetReg64(system, 0, Convert<uint64_t>(ret)); SetReg64(system, 0, Convert<uint64_t>(ret));
SetReg64(system, 1, Convert<uint64_t>(out_priority)); SetReg64(system, 1, Convert<uint64_t>(out_priority));
@ -2268,7 +2268,7 @@ static void SvcWrap_GetThreadCoreMask64(Core::System& system) {
thread_handle = Convert<Handle>(GetReg64(system, 2)); thread_handle = Convert<Handle>(GetReg64(system, 2));
ret = GetThreadCoreMask64(system, &out_core_id, &out_affinity_mask, thread_handle); ret = GetThreadCoreMask64(system, std::addressof(out_core_id), std::addressof(out_affinity_mask), thread_handle);
SetReg64(system, 0, Convert<uint64_t>(ret)); SetReg64(system, 0, Convert<uint64_t>(ret));
SetReg64(system, 1, Convert<uint64_t>(out_core_id)); SetReg64(system, 1, Convert<uint64_t>(out_core_id));
@ -2369,7 +2369,7 @@ static void SvcWrap_CreateTransferMemory64(Core::System& system) {
size = Convert<uint64_t>(GetReg64(system, 2)); size = Convert<uint64_t>(GetReg64(system, 2));
map_perm = Convert<MemoryPermission>(GetReg64(system, 3)); map_perm = Convert<MemoryPermission>(GetReg64(system, 3));
ret = CreateTransferMemory64(system, &out_handle, address, size, map_perm); ret = CreateTransferMemory64(system, std::addressof(out_handle), address, size, map_perm);
SetReg64(system, 0, Convert<uint64_t>(ret)); SetReg64(system, 0, Convert<uint64_t>(ret));
SetReg64(system, 1, Convert<uint64_t>(out_handle)); SetReg64(system, 1, Convert<uint64_t>(out_handle));
@ -2411,7 +2411,7 @@ static void SvcWrap_WaitSynchronization64(Core::System& system) {
num_handles = Convert<int32_t>(GetReg64(system, 2)); num_handles = Convert<int32_t>(GetReg64(system, 2));
timeout_ns = Convert<int64_t>(GetReg64(system, 3)); timeout_ns = Convert<int64_t>(GetReg64(system, 3));
ret = WaitSynchronization64(system, &out_index, handles, num_handles, timeout_ns); ret = WaitSynchronization64(system, std::addressof(out_index), handles, num_handles, timeout_ns);
SetReg64(system, 0, Convert<uint64_t>(ret)); SetReg64(system, 0, Convert<uint64_t>(ret));
SetReg64(system, 1, Convert<uint64_t>(out_index)); SetReg64(system, 1, Convert<uint64_t>(out_index));
@ -2501,7 +2501,7 @@ static void SvcWrap_ConnectToNamedPort64(Core::System& system) {
name = Convert<uint64_t>(GetReg64(system, 1)); name = Convert<uint64_t>(GetReg64(system, 1));
ret = ConnectToNamedPort64(system, &out_handle, name); ret = ConnectToNamedPort64(system, std::addressof(out_handle), name);
SetReg64(system, 0, Convert<uint64_t>(ret)); SetReg64(system, 0, Convert<uint64_t>(ret));
SetReg64(system, 1, Convert<uint64_t>(out_handle)); SetReg64(system, 1, Convert<uint64_t>(out_handle));
@ -2547,7 +2547,7 @@ static void SvcWrap_SendAsyncRequestWithUserBuffer64(Core::System& system) {
message_buffer_size = Convert<uint64_t>(GetReg64(system, 2)); message_buffer_size = Convert<uint64_t>(GetReg64(system, 2));
session_handle = Convert<Handle>(GetReg64(system, 3)); session_handle = Convert<Handle>(GetReg64(system, 3));
ret = SendAsyncRequestWithUserBuffer64(system, &out_event_handle, message_buffer, message_buffer_size, session_handle); ret = SendAsyncRequestWithUserBuffer64(system, std::addressof(out_event_handle), message_buffer, message_buffer_size, session_handle);
SetReg64(system, 0, Convert<uint64_t>(ret)); SetReg64(system, 0, Convert<uint64_t>(ret));
SetReg64(system, 1, Convert<uint64_t>(out_event_handle)); SetReg64(system, 1, Convert<uint64_t>(out_event_handle));
@ -2561,7 +2561,7 @@ static void SvcWrap_GetProcessId64(Core::System& system) {
process_handle = Convert<Handle>(GetReg64(system, 1)); process_handle = Convert<Handle>(GetReg64(system, 1));
ret = GetProcessId64(system, &out_process_id, process_handle); ret = GetProcessId64(system, std::addressof(out_process_id), process_handle);
SetReg64(system, 0, Convert<uint64_t>(ret)); SetReg64(system, 0, Convert<uint64_t>(ret));
SetReg64(system, 1, Convert<uint64_t>(out_process_id)); SetReg64(system, 1, Convert<uint64_t>(out_process_id));
@ -2575,7 +2575,7 @@ static void SvcWrap_GetThreadId64(Core::System& system) {
thread_handle = Convert<Handle>(GetReg64(system, 1)); thread_handle = Convert<Handle>(GetReg64(system, 1));
ret = GetThreadId64(system, &out_thread_id, thread_handle); ret = GetThreadId64(system, std::addressof(out_thread_id), thread_handle);
SetReg64(system, 0, Convert<uint64_t>(ret)); SetReg64(system, 0, Convert<uint64_t>(ret));
SetReg64(system, 1, Convert<uint64_t>(out_thread_id)); SetReg64(system, 1, Convert<uint64_t>(out_thread_id));
@ -2627,7 +2627,7 @@ static void SvcWrap_GetInfo64(Core::System& system) {
handle = Convert<Handle>(GetReg64(system, 2)); handle = Convert<Handle>(GetReg64(system, 2));
info_subtype = Convert<uint64_t>(GetReg64(system, 3)); info_subtype = Convert<uint64_t>(GetReg64(system, 3));
ret = GetInfo64(system, &out, info_type, handle, info_subtype); ret = GetInfo64(system, std::addressof(out), info_type, handle, info_subtype);
SetReg64(system, 0, Convert<uint64_t>(ret)); SetReg64(system, 0, Convert<uint64_t>(ret));
SetReg64(system, 1, Convert<uint64_t>(out)); SetReg64(system, 1, Convert<uint64_t>(out));
@ -2690,7 +2690,7 @@ static void SvcWrap_GetDebugFutureThreadInfo64(Core::System& system) {
debug_handle = Convert<Handle>(GetReg64(system, 2)); debug_handle = Convert<Handle>(GetReg64(system, 2));
ns = Convert<int64_t>(GetReg64(system, 3)); ns = Convert<int64_t>(GetReg64(system, 3));
ret = GetDebugFutureThreadInfo64(system, &out_context, &out_thread_id, debug_handle, ns); ret = GetDebugFutureThreadInfo64(system, std::addressof(out_context), std::addressof(out_thread_id), debug_handle, ns);
SetReg64(system, 0, Convert<uint64_t>(ret)); SetReg64(system, 0, Convert<uint64_t>(ret));
auto out_context_scatter = Convert<std::array<uint64_t, 4>>(out_context); auto out_context_scatter = Convert<std::array<uint64_t, 4>>(out_context);
@ -2708,7 +2708,7 @@ static void SvcWrap_GetLastThreadInfo64(Core::System& system) {
uint64_t out_tls_address{}; uint64_t out_tls_address{};
uint32_t out_flags{}; uint32_t out_flags{};
ret = GetLastThreadInfo64(system, &out_context, &out_tls_address, &out_flags); ret = GetLastThreadInfo64(system, std::addressof(out_context), std::addressof(out_tls_address), std::addressof(out_flags));
SetReg64(system, 0, Convert<uint64_t>(ret)); SetReg64(system, 0, Convert<uint64_t>(ret));
auto out_context_scatter = Convert<std::array<uint64_t, 4>>(out_context); auto out_context_scatter = Convert<std::array<uint64_t, 4>>(out_context);
@ -2730,7 +2730,7 @@ static void SvcWrap_GetResourceLimitLimitValue64(Core::System& system) {
resource_limit_handle = Convert<Handle>(GetReg64(system, 1)); resource_limit_handle = Convert<Handle>(GetReg64(system, 1));
which = Convert<LimitableResource>(GetReg64(system, 2)); which = Convert<LimitableResource>(GetReg64(system, 2));
ret = GetResourceLimitLimitValue64(system, &out_limit_value, resource_limit_handle, which); ret = GetResourceLimitLimitValue64(system, std::addressof(out_limit_value), resource_limit_handle, which);
SetReg64(system, 0, Convert<uint64_t>(ret)); SetReg64(system, 0, Convert<uint64_t>(ret));
SetReg64(system, 1, Convert<uint64_t>(out_limit_value)); SetReg64(system, 1, Convert<uint64_t>(out_limit_value));
@ -2746,7 +2746,7 @@ static void SvcWrap_GetResourceLimitCurrentValue64(Core::System& system) {
resource_limit_handle = Convert<Handle>(GetReg64(system, 1)); resource_limit_handle = Convert<Handle>(GetReg64(system, 1));
which = Convert<LimitableResource>(GetReg64(system, 2)); which = Convert<LimitableResource>(GetReg64(system, 2));
ret = GetResourceLimitCurrentValue64(system, &out_current_value, resource_limit_handle, which); ret = GetResourceLimitCurrentValue64(system, std::addressof(out_current_value), resource_limit_handle, which);
SetReg64(system, 0, Convert<uint64_t>(ret)); SetReg64(system, 0, Convert<uint64_t>(ret));
SetReg64(system, 1, Convert<uint64_t>(out_current_value)); SetReg64(system, 1, Convert<uint64_t>(out_current_value));
@ -2830,7 +2830,7 @@ static void SvcWrap_GetResourceLimitPeakValue64(Core::System& system) {
resource_limit_handle = Convert<Handle>(GetReg64(system, 1)); resource_limit_handle = Convert<Handle>(GetReg64(system, 1));
which = Convert<LimitableResource>(GetReg64(system, 2)); which = Convert<LimitableResource>(GetReg64(system, 2));
ret = GetResourceLimitPeakValue64(system, &out_peak_value, resource_limit_handle, which); ret = GetResourceLimitPeakValue64(system, std::addressof(out_peak_value), resource_limit_handle, which);
SetReg64(system, 0, Convert<uint64_t>(ret)); SetReg64(system, 0, Convert<uint64_t>(ret));
SetReg64(system, 1, Convert<uint64_t>(out_peak_value)); SetReg64(system, 1, Convert<uint64_t>(out_peak_value));
@ -2844,7 +2844,7 @@ static void SvcWrap_CreateIoPool64(Core::System& system) {
which = Convert<IoPoolType>(GetReg64(system, 1)); which = Convert<IoPoolType>(GetReg64(system, 1));
ret = CreateIoPool64(system, &out_handle, which); ret = CreateIoPool64(system, std::addressof(out_handle), which);
SetReg64(system, 0, Convert<uint64_t>(ret)); SetReg64(system, 0, Convert<uint64_t>(ret));
SetReg64(system, 1, Convert<uint64_t>(out_handle)); SetReg64(system, 1, Convert<uint64_t>(out_handle));
@ -2866,7 +2866,7 @@ static void SvcWrap_CreateIoRegion64(Core::System& system) {
mapping = Convert<MemoryMapping>(GetReg64(system, 4)); mapping = Convert<MemoryMapping>(GetReg64(system, 4));
perm = Convert<MemoryPermission>(GetReg64(system, 5)); perm = Convert<MemoryPermission>(GetReg64(system, 5));
ret = CreateIoRegion64(system, &out_handle, io_pool, physical_address, size, mapping, perm); ret = CreateIoRegion64(system, std::addressof(out_handle), io_pool, physical_address, size, mapping, perm);
SetReg64(system, 0, Convert<uint64_t>(ret)); SetReg64(system, 0, Convert<uint64_t>(ret));
SetReg64(system, 1, Convert<uint64_t>(out_handle)); SetReg64(system, 1, Convert<uint64_t>(out_handle));
@ -2905,7 +2905,7 @@ static void SvcWrap_CreateSession64(Core::System& system) {
is_light = Convert<bool>(GetReg64(system, 2)); is_light = Convert<bool>(GetReg64(system, 2));
name = Convert<uint64_t>(GetReg64(system, 3)); name = Convert<uint64_t>(GetReg64(system, 3));
ret = CreateSession64(system, &out_server_session_handle, &out_client_session_handle, is_light, name); 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, 0, Convert<uint64_t>(ret));
SetReg64(system, 1, Convert<uint64_t>(out_server_session_handle)); SetReg64(system, 1, Convert<uint64_t>(out_server_session_handle));
@ -2920,7 +2920,7 @@ static void SvcWrap_AcceptSession64(Core::System& system) {
port = Convert<Handle>(GetReg64(system, 1)); port = Convert<Handle>(GetReg64(system, 1));
ret = AcceptSession64(system, &out_handle, port); ret = AcceptSession64(system, std::addressof(out_handle), port);
SetReg64(system, 0, Convert<uint64_t>(ret)); SetReg64(system, 0, Convert<uint64_t>(ret));
SetReg64(system, 1, Convert<uint64_t>(out_handle)); SetReg64(system, 1, Convert<uint64_t>(out_handle));
@ -2940,7 +2940,7 @@ static void SvcWrap_ReplyAndReceive64(Core::System& system) {
reply_target = Convert<Handle>(GetReg64(system, 3)); reply_target = Convert<Handle>(GetReg64(system, 3));
timeout_ns = Convert<int64_t>(GetReg64(system, 4)); timeout_ns = Convert<int64_t>(GetReg64(system, 4));
ret = ReplyAndReceive64(system, &out_index, handles, num_handles, reply_target, timeout_ns); ret = ReplyAndReceive64(system, std::addressof(out_index), handles, num_handles, reply_target, timeout_ns);
SetReg64(system, 0, Convert<uint64_t>(ret)); SetReg64(system, 0, Convert<uint64_t>(ret));
SetReg64(system, 1, Convert<uint64_t>(out_index)); SetReg64(system, 1, Convert<uint64_t>(out_index));
@ -2964,7 +2964,7 @@ static void SvcWrap_ReplyAndReceiveWithUserBuffer64(Core::System& system) {
reply_target = Convert<Handle>(GetReg64(system, 5)); reply_target = Convert<Handle>(GetReg64(system, 5));
timeout_ns = Convert<int64_t>(GetReg64(system, 6)); timeout_ns = Convert<int64_t>(GetReg64(system, 6));
ret = ReplyAndReceiveWithUserBuffer64(system, &out_index, message_buffer, message_buffer_size, handles, num_handles, reply_target, timeout_ns); 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, 0, Convert<uint64_t>(ret));
SetReg64(system, 1, Convert<uint64_t>(out_index)); SetReg64(system, 1, Convert<uint64_t>(out_index));
@ -2976,7 +2976,7 @@ static void SvcWrap_CreateEvent64(Core::System& system) {
Handle out_write_handle{}; Handle out_write_handle{};
Handle out_read_handle{}; Handle out_read_handle{};
ret = CreateEvent64(system, &out_write_handle, &out_read_handle); ret = CreateEvent64(system, std::addressof(out_write_handle), std::addressof(out_read_handle));
SetReg64(system, 0, Convert<uint64_t>(ret)); SetReg64(system, 0, Convert<uint64_t>(ret));
SetReg64(system, 1, Convert<uint64_t>(out_write_handle)); SetReg64(system, 1, Convert<uint64_t>(out_write_handle));
@ -3067,7 +3067,7 @@ static void SvcWrap_CreateCodeMemory64(Core::System& system) {
address = Convert<uint64_t>(GetReg64(system, 1)); address = Convert<uint64_t>(GetReg64(system, 1));
size = Convert<uint64_t>(GetReg64(system, 2)); size = Convert<uint64_t>(GetReg64(system, 2));
ret = CreateCodeMemory64(system, &out_handle, address, size); ret = CreateCodeMemory64(system, std::addressof(out_handle), address, size);
SetReg64(system, 0, Convert<uint64_t>(ret)); SetReg64(system, 0, Convert<uint64_t>(ret));
SetReg64(system, 1, Convert<uint64_t>(out_handle)); SetReg64(system, 1, Convert<uint64_t>(out_handle));
@ -3109,7 +3109,7 @@ static void SvcWrap_ReadWriteRegister64(Core::System& system) {
mask = Convert<uint32_t>(GetReg64(system, 2)); mask = Convert<uint32_t>(GetReg64(system, 2));
value = Convert<uint32_t>(GetReg64(system, 3)); value = Convert<uint32_t>(GetReg64(system, 3));
ret = ReadWriteRegister64(system, &out_value, address, mask, value); ret = ReadWriteRegister64(system, std::addressof(out_value), address, mask, value);
SetReg64(system, 0, Convert<uint64_t>(ret)); SetReg64(system, 0, Convert<uint64_t>(ret));
SetReg64(system, 1, Convert<uint64_t>(out_value)); SetReg64(system, 1, Convert<uint64_t>(out_value));
@ -3141,7 +3141,7 @@ static void SvcWrap_CreateSharedMemory64(Core::System& system) {
owner_perm = Convert<MemoryPermission>(GetReg64(system, 2)); owner_perm = Convert<MemoryPermission>(GetReg64(system, 2));
remote_perm = Convert<MemoryPermission>(GetReg64(system, 3)); remote_perm = Convert<MemoryPermission>(GetReg64(system, 3));
ret = CreateSharedMemory64(system, &out_handle, size, owner_perm, remote_perm); ret = CreateSharedMemory64(system, std::addressof(out_handle), size, owner_perm, remote_perm);
SetReg64(system, 0, Convert<uint64_t>(ret)); SetReg64(system, 0, Convert<uint64_t>(ret));
SetReg64(system, 1, Convert<uint64_t>(out_handle)); SetReg64(system, 1, Convert<uint64_t>(out_handle));
@ -3191,7 +3191,7 @@ static void SvcWrap_CreateInterruptEvent64(Core::System& system) {
interrupt_id = Convert<int32_t>(GetReg64(system, 1)); interrupt_id = Convert<int32_t>(GetReg64(system, 1));
interrupt_type = Convert<InterruptType>(GetReg64(system, 2)); interrupt_type = Convert<InterruptType>(GetReg64(system, 2));
ret = CreateInterruptEvent64(system, &out_read_handle, interrupt_id, interrupt_type); ret = CreateInterruptEvent64(system, std::addressof(out_read_handle), interrupt_id, interrupt_type);
SetReg64(system, 0, Convert<uint64_t>(ret)); SetReg64(system, 0, Convert<uint64_t>(ret));
SetReg64(system, 1, Convert<uint64_t>(out_read_handle)); SetReg64(system, 1, Convert<uint64_t>(out_read_handle));
@ -3205,7 +3205,7 @@ static void SvcWrap_QueryPhysicalAddress64(Core::System& system) {
address = Convert<uint64_t>(GetReg64(system, 1)); address = Convert<uint64_t>(GetReg64(system, 1));
ret = QueryPhysicalAddress64(system, &out_info, address); ret = QueryPhysicalAddress64(system, std::addressof(out_info), address);
SetReg64(system, 0, Convert<uint64_t>(ret)); SetReg64(system, 0, Convert<uint64_t>(ret));
auto out_info_scatter = Convert<std::array<uint64_t, 3>>(out_info); auto out_info_scatter = Convert<std::array<uint64_t, 3>>(out_info);
@ -3225,7 +3225,7 @@ static void SvcWrap_QueryIoMapping64(Core::System& system) {
physical_address = Convert<uint64_t>(GetReg64(system, 2)); physical_address = Convert<uint64_t>(GetReg64(system, 2));
size = Convert<uint64_t>(GetReg64(system, 3)); size = Convert<uint64_t>(GetReg64(system, 3));
ret = QueryIoMapping64(system, &out_address, &out_size, physical_address, size); ret = QueryIoMapping64(system, std::addressof(out_address), std::addressof(out_size), physical_address, size);
SetReg64(system, 0, Convert<uint64_t>(ret)); SetReg64(system, 0, Convert<uint64_t>(ret));
SetReg64(system, 1, Convert<uint64_t>(out_address)); SetReg64(system, 1, Convert<uint64_t>(out_address));
@ -3242,7 +3242,7 @@ static void SvcWrap_CreateDeviceAddressSpace64(Core::System& system) {
das_address = Convert<uint64_t>(GetReg64(system, 1)); das_address = Convert<uint64_t>(GetReg64(system, 1));
das_size = Convert<uint64_t>(GetReg64(system, 2)); das_size = Convert<uint64_t>(GetReg64(system, 2));
ret = CreateDeviceAddressSpace64(system, &out_handle, das_address, das_size); ret = CreateDeviceAddressSpace64(system, std::addressof(out_handle), das_address, das_size);
SetReg64(system, 0, Convert<uint64_t>(ret)); SetReg64(system, 0, Convert<uint64_t>(ret));
SetReg64(system, 1, Convert<uint64_t>(out_handle)); SetReg64(system, 1, Convert<uint64_t>(out_handle));
@ -3396,7 +3396,7 @@ static void SvcWrap_DebugActiveProcess64(Core::System& system) {
process_id = Convert<uint64_t>(GetReg64(system, 1)); process_id = Convert<uint64_t>(GetReg64(system, 1));
ret = DebugActiveProcess64(system, &out_handle, process_id); ret = DebugActiveProcess64(system, std::addressof(out_handle), process_id);
SetReg64(system, 0, Convert<uint64_t>(ret)); SetReg64(system, 0, Convert<uint64_t>(ret));
SetReg64(system, 1, Convert<uint64_t>(out_handle)); SetReg64(system, 1, Convert<uint64_t>(out_handle));
@ -3468,7 +3468,7 @@ static void SvcWrap_GetProcessList64(Core::System& system) {
out_process_ids = Convert<uint64_t>(GetReg64(system, 1)); out_process_ids = Convert<uint64_t>(GetReg64(system, 1));
max_out_count = Convert<int32_t>(GetReg64(system, 2)); max_out_count = Convert<int32_t>(GetReg64(system, 2));
ret = GetProcessList64(system, &out_num_processes, out_process_ids, max_out_count); ret = GetProcessList64(system, std::addressof(out_num_processes), out_process_ids, max_out_count);
SetReg64(system, 0, Convert<uint64_t>(ret)); SetReg64(system, 0, Convert<uint64_t>(ret));
SetReg64(system, 1, Convert<uint64_t>(out_num_processes)); SetReg64(system, 1, Convert<uint64_t>(out_num_processes));
@ -3486,7 +3486,7 @@ static void SvcWrap_GetThreadList64(Core::System& system) {
max_out_count = Convert<int32_t>(GetReg64(system, 2)); max_out_count = Convert<int32_t>(GetReg64(system, 2));
debug_handle = Convert<Handle>(GetReg64(system, 3)); debug_handle = Convert<Handle>(GetReg64(system, 3));
ret = GetThreadList64(system, &out_num_threads, out_thread_ids, max_out_count, debug_handle); 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, 0, Convert<uint64_t>(ret));
SetReg64(system, 1, Convert<uint64_t>(out_num_threads)); SetReg64(system, 1, Convert<uint64_t>(out_num_threads));
@ -3540,7 +3540,7 @@ static void SvcWrap_QueryDebugProcessMemory64(Core::System& system) {
process_handle = Convert<Handle>(GetReg64(system, 2)); process_handle = Convert<Handle>(GetReg64(system, 2));
address = Convert<uint64_t>(GetReg64(system, 3)); address = Convert<uint64_t>(GetReg64(system, 3));
ret = QueryDebugProcessMemory64(system, out_memory_info, &out_page_info, process_handle, address); ret = QueryDebugProcessMemory64(system, out_memory_info, std::addressof(out_page_info), process_handle, address);
SetReg64(system, 0, Convert<uint64_t>(ret)); SetReg64(system, 0, Convert<uint64_t>(ret));
SetReg64(system, 1, Convert<uint64_t>(out_page_info)); SetReg64(system, 1, Convert<uint64_t>(out_page_info));
@ -3611,7 +3611,7 @@ static void SvcWrap_GetDebugThreadParam64(Core::System& system) {
thread_id = Convert<uint64_t>(GetReg64(system, 3)); thread_id = Convert<uint64_t>(GetReg64(system, 3));
param = Convert<DebugThreadParam>(GetReg64(system, 4)); param = Convert<DebugThreadParam>(GetReg64(system, 4));
ret = GetDebugThreadParam64(system, &out_64, &out_32, debug_handle, thread_id, param); 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, 0, Convert<uint64_t>(ret));
SetReg64(system, 1, Convert<uint64_t>(out_64)); SetReg64(system, 1, Convert<uint64_t>(out_64));
@ -3630,7 +3630,7 @@ static void SvcWrap_GetSystemInfo64(Core::System& system) {
handle = Convert<Handle>(GetReg64(system, 2)); handle = Convert<Handle>(GetReg64(system, 2));
info_subtype = Convert<uint64_t>(GetReg64(system, 3)); info_subtype = Convert<uint64_t>(GetReg64(system, 3));
ret = GetSystemInfo64(system, &out, info_type, handle, info_subtype); ret = GetSystemInfo64(system, std::addressof(out), info_type, handle, info_subtype);
SetReg64(system, 0, Convert<uint64_t>(ret)); SetReg64(system, 0, Convert<uint64_t>(ret));
SetReg64(system, 1, Convert<uint64_t>(out)); SetReg64(system, 1, Convert<uint64_t>(out));
@ -3649,7 +3649,7 @@ static void SvcWrap_CreatePort64(Core::System& system) {
is_light = Convert<bool>(GetReg64(system, 3)); is_light = Convert<bool>(GetReg64(system, 3));
name = Convert<uint64_t>(GetReg64(system, 4)); name = Convert<uint64_t>(GetReg64(system, 4));
ret = CreatePort64(system, &out_server_handle, &out_client_handle, max_sessions, is_light, name); 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, 0, Convert<uint64_t>(ret));
SetReg64(system, 1, Convert<uint64_t>(out_server_handle)); SetReg64(system, 1, Convert<uint64_t>(out_server_handle));
@ -3666,7 +3666,7 @@ static void SvcWrap_ManageNamedPort64(Core::System& system) {
name = Convert<uint64_t>(GetReg64(system, 1)); name = Convert<uint64_t>(GetReg64(system, 1));
max_sessions = Convert<int32_t>(GetReg64(system, 2)); max_sessions = Convert<int32_t>(GetReg64(system, 2));
ret = ManageNamedPort64(system, &out_server_handle, name, max_sessions); ret = ManageNamedPort64(system, std::addressof(out_server_handle), name, max_sessions);
SetReg64(system, 0, Convert<uint64_t>(ret)); SetReg64(system, 0, Convert<uint64_t>(ret));
SetReg64(system, 1, Convert<uint64_t>(out_server_handle)); SetReg64(system, 1, Convert<uint64_t>(out_server_handle));
@ -3680,7 +3680,7 @@ static void SvcWrap_ConnectToPort64(Core::System& system) {
port = Convert<Handle>(GetReg64(system, 1)); port = Convert<Handle>(GetReg64(system, 1));
ret = ConnectToPort64(system, &out_handle, port); ret = ConnectToPort64(system, std::addressof(out_handle), port);
SetReg64(system, 0, Convert<uint64_t>(ret)); SetReg64(system, 0, Convert<uint64_t>(ret));
SetReg64(system, 1, Convert<uint64_t>(out_handle)); SetReg64(system, 1, Convert<uint64_t>(out_handle));
@ -3752,7 +3752,7 @@ static void SvcWrap_QueryProcessMemory64(Core::System& system) {
process_handle = Convert<Handle>(GetReg64(system, 2)); process_handle = Convert<Handle>(GetReg64(system, 2));
address = Convert<uint64_t>(GetReg64(system, 3)); address = Convert<uint64_t>(GetReg64(system, 3));
ret = QueryProcessMemory64(system, out_memory_info, &out_page_info, process_handle, address); ret = QueryProcessMemory64(system, out_memory_info, std::addressof(out_page_info), process_handle, address);
SetReg64(system, 0, Convert<uint64_t>(ret)); SetReg64(system, 0, Convert<uint64_t>(ret));
SetReg64(system, 1, Convert<uint64_t>(out_page_info)); SetReg64(system, 1, Convert<uint64_t>(out_page_info));
@ -3806,7 +3806,7 @@ static void SvcWrap_CreateProcess64(Core::System& system) {
caps = Convert<uint64_t>(GetReg64(system, 2)); caps = Convert<uint64_t>(GetReg64(system, 2));
num_caps = Convert<int32_t>(GetReg64(system, 3)); num_caps = Convert<int32_t>(GetReg64(system, 3));
ret = CreateProcess64(system, &out_handle, parameters, caps, num_caps); ret = CreateProcess64(system, std::addressof(out_handle), parameters, caps, num_caps);
SetReg64(system, 0, Convert<uint64_t>(ret)); SetReg64(system, 0, Convert<uint64_t>(ret));
SetReg64(system, 1, Convert<uint64_t>(out_handle)); SetReg64(system, 1, Convert<uint64_t>(out_handle));
@ -3852,7 +3852,7 @@ static void SvcWrap_GetProcessInfo64(Core::System& system) {
process_handle = Convert<Handle>(GetReg64(system, 1)); process_handle = Convert<Handle>(GetReg64(system, 1));
info_type = Convert<ProcessInfoType>(GetReg64(system, 2)); info_type = Convert<ProcessInfoType>(GetReg64(system, 2));
ret = GetProcessInfo64(system, &out_info, process_handle, info_type); ret = GetProcessInfo64(system, std::addressof(out_info), process_handle, info_type);
SetReg64(system, 0, Convert<uint64_t>(ret)); SetReg64(system, 0, Convert<uint64_t>(ret));
SetReg64(system, 1, Convert<uint64_t>(out_info)); SetReg64(system, 1, Convert<uint64_t>(out_info));
@ -3863,7 +3863,7 @@ static void SvcWrap_CreateResourceLimit64(Core::System& system) {
Handle out_handle{}; Handle out_handle{};
ret = CreateResourceLimit64(system, &out_handle); ret = CreateResourceLimit64(system, std::addressof(out_handle));
SetReg64(system, 0, Convert<uint64_t>(ret)); SetReg64(system, 0, Convert<uint64_t>(ret));
SetReg64(system, 1, Convert<uint64_t>(out_handle)); SetReg64(system, 1, Convert<uint64_t>(out_handle));

4
src/core/hle/kernel/svc/svc_info.cpp
View File

@ -153,7 +153,7 @@ Result GetInfo(Core::System& system, u64* result, InfoType info_id_type, Handle
} }
Handle resource_handle{}; Handle resource_handle{};
R_TRY(handle_table.Add(&resource_handle, resource_limit)); R_TRY(handle_table.Add(std::addressof(resource_handle), resource_limit));
*result = resource_handle; *result = resource_handle;
R_SUCCEED(); R_SUCCEED();
@ -234,7 +234,7 @@ Result GetInfo(Core::System& system, u64* result, InfoType info_id_type, Handle
// Get a new handle for the current process. // Get a new handle for the current process.
Handle tmp; Handle tmp;
R_TRY(handle_table.Add(&tmp, current_process)); R_TRY(handle_table.Add(std::addressof(tmp), current_process));
// Set the output. // Set the output.
*result = tmp; *result = tmp;

2
src/core/hle/kernel/svc/svc_ipc.cpp
View File

@ -79,7 +79,7 @@ Result ReplyAndReceive(Core::System& system, s32* out_index, uint64_t handles_ad
while (true) { while (true) {
// Wait for an object. // Wait for an object.
s32 index; s32 index;
Result result = KSynchronizationObject::Wait(kernel, &index, objs.data(), Result result = KSynchronizationObject::Wait(kernel, std::addressof(index), objs.data(),
static_cast<s32>(objs.size()), timeout_ns); static_cast<s32>(objs.size()), timeout_ns);
if (result == ResultTimedOut) { if (result == ResultTimedOut) {
R_RETURN(result); R_RETURN(result);

2
src/core/hle/kernel/svc/svc_query_memory.cpp
View File

@ -33,7 +33,7 @@ Result QueryProcessMemory(Core::System& system, uint64_t out_memory_info, PageIn
auto& memory{system.Memory()}; auto& memory{system.Memory()};
const auto memory_info{process->PageTable().QueryInfo(address).GetSvcMemoryInfo()}; const auto memory_info{process->PageTable().QueryInfo(address).GetSvcMemoryInfo()};
memory.WriteBlock(out_memory_info, &memory_info, sizeof(memory_info)); memory.WriteBlock(out_memory_info, std::addressof(memory_info), sizeof(memory_info));
//! This is supposed to be part of the QueryInfo call. //! This is supposed to be part of the QueryInfo call.
*out_page_info = {}; *out_page_info = {};

2
src/core/hle/kernel/svc/svc_resource_limit.cpp
View File

@ -21,7 +21,7 @@ Result CreateResourceLimit(Core::System& system, Handle* out_handle) {
SCOPE_EXIT({ resource_limit->Close(); }); SCOPE_EXIT({ resource_limit->Close(); });
// Initialize the resource limit. // Initialize the resource limit.
resource_limit->Initialize(&system.CoreTiming()); resource_limit->Initialize(std::addressof(system.CoreTiming()));
// Register the limit. // Register the limit.
KResourceLimit::Register(kernel, resource_limit); KResourceLimit::Register(kernel, resource_limit);

4
src/core/hle/kernel/svc/svc_secure_monitor_call.cpp
View File

@ -29,7 +29,7 @@ void SvcWrap_CallSecureMonitor64(Core::System& system) {
args.r[i] = core.GetReg(i); args.r[i] = core.GetReg(i);
} }
CallSecureMonitor64(system, &args); CallSecureMonitor64(system, std::addressof(args));
for (int i = 0; i < 8; i++) { for (int i = 0; i < 8; i++) {
core.SetReg(i, args.r[i]); core.SetReg(i, args.r[i]);
@ -43,7 +43,7 @@ void SvcWrap_CallSecureMonitor64From32(Core::System& system) {
args.r[i] = static_cast<u32>(core.GetReg(i)); args.r[i] = static_cast<u32>(core.GetReg(i));
} }
CallSecureMonitor64From32(system, &args); CallSecureMonitor64From32(system, std::addressof(args));
for (int i = 0; i < 8; i++) { for (int i = 0; i < 8; i++) {
core.SetReg(i, args.r[i]); core.SetReg(i, args.r[i]);

9
src/core/hle/kernel/svc/svc_session.cpp
View File

@ -21,7 +21,8 @@ Result CreateSession(Core::System& system, Handle* out_server, Handle* out_clien
// Reserve a new session from the process resource limit. // Reserve a new session from the process resource limit.
// FIXME: LimitableResource_SessionCountMax // FIXME: LimitableResource_SessionCountMax
KScopedResourceReservation session_reservation(&process, LimitableResource::SessionCountMax); KScopedResourceReservation session_reservation(std::addressof(process),
LimitableResource::SessionCountMax);
if (session_reservation.Succeeded()) { if (session_reservation.Succeeded()) {
session = T::Create(system.Kernel()); session = T::Create(system.Kernel());
} else { } else {
@ -30,7 +31,7 @@ Result CreateSession(Core::System& system, Handle* out_server, Handle* out_clien
// // We couldn't reserve a session. Check that we support dynamically expanding the // // We couldn't reserve a session. Check that we support dynamically expanding the
// // resource limit. // // resource limit.
// R_UNLESS(process.GetResourceLimit() == // R_UNLESS(process.GetResourceLimit() ==
// &system.Kernel().GetSystemResourceLimit(), ResultLimitReached); // std::addressof(system.Kernel().GetSystemResourceLimit()), ResultLimitReached);
// R_UNLESS(KTargetSystem::IsDynamicResourceLimitsEnabled(), ResultLimitReached()); // R_UNLESS(KTargetSystem::IsDynamicResourceLimitsEnabled(), ResultLimitReached());
// // Try to allocate a session from unused slab memory. // // Try to allocate a session from unused slab memory.
@ -75,7 +76,7 @@ Result CreateSession(Core::System& system, Handle* out_server, Handle* out_clien
T::Register(system.Kernel(), session); T::Register(system.Kernel(), session);
// Add the server session to the handle table. // Add the server session to the handle table.
R_TRY(handle_table.Add(out_server, &session->GetServerSession())); R_TRY(handle_table.Add(out_server, std::addressof(session->GetServerSession())));
// Ensure that we maintain a clean handle state on exit. // Ensure that we maintain a clean handle state on exit.
ON_RESULT_FAILURE { ON_RESULT_FAILURE {
@ -83,7 +84,7 @@ Result CreateSession(Core::System& system, Handle* out_server, Handle* out_clien
}; };
// Add the client session to the handle table. // Add the client session to the handle table.
R_RETURN(handle_table.Add(out_client, &session->GetClientSession())); R_RETURN(handle_table.Add(out_client, std::addressof(session->GetClientSession())));
} }
} // namespace } // namespace

8
src/core/hle/kernel/svc/svc_thread.cpp
View File

@ -42,9 +42,9 @@ Result CreateThread(Core::System& system, Handle* out_handle, VAddr entry_point,
R_UNLESS(process.CheckThreadPriority(priority), ResultInvalidPriority); R_UNLESS(process.CheckThreadPriority(priority), ResultInvalidPriority);
// Reserve a new thread from the process resource limit (waiting up to 100ms). // Reserve a new thread from the process resource limit (waiting up to 100ms).
KScopedResourceReservation thread_reservation(&process, LimitableResource::ThreadCountMax, 1, KScopedResourceReservation thread_reservation(
system.CoreTiming().GetGlobalTimeNs().count() + std::addressof(process), LimitableResource::ThreadCountMax, 1,
100000000); system.CoreTiming().GetGlobalTimeNs().count() + 100000000);
R_UNLESS(thread_reservation.Succeeded(), ResultLimitReached); R_UNLESS(thread_reservation.Succeeded(), ResultLimitReached);
// Create the thread. // Create the thread.
@ -56,7 +56,7 @@ Result CreateThread(Core::System& system, Handle* out_handle, VAddr entry_point,
{ {
KScopedLightLock lk{process.GetStateLock()}; KScopedLightLock lk{process.GetStateLock()};
R_TRY(KThread::InitializeUserThread(system, thread, entry_point, arg, stack_bottom, R_TRY(KThread::InitializeUserThread(system, thread, entry_point, arg, stack_bottom,
priority, core_id, &process)); priority, core_id, std::addressof(process)));
} }
// Set the thread name for debugging purposes. // Set the thread name for debugging purposes.

2
src/core/hle/kernel/svc/svc_transfer_memory.cpp
View File

@ -43,7 +43,7 @@ Result CreateTransferMemory(Core::System& system, Handle* out, VAddr address, u6
auto& handle_table = process.GetHandleTable(); auto& handle_table = process.GetHandleTable();
// Reserve a new transfer memory from the process resource limit. // Reserve a new transfer memory from the process resource limit.
KScopedResourceReservation trmem_reservation(&process, KScopedResourceReservation trmem_reservation(std::addressof(process),
LimitableResource::TransferMemoryCountMax); LimitableResource::TransferMemoryCountMax);
R_UNLESS(trmem_reservation.Succeeded(), ResultLimitReached); R_UNLESS(trmem_reservation.Succeeded(), ResultLimitReached);

6
src/core/hle/kernel/svc_generator.py
View File

@ -460,7 +460,7 @@ def emit_wrapper(wrapped_fn, suffix, register_info, arguments, byte_size):
call_arguments = ["system"] call_arguments = ["system"]
for arg in arguments: for arg in arguments:
if arg.is_output and not arg.is_outptr: if arg.is_output and not arg.is_outptr:
call_arguments.append(f"&{arg.var_name}") call_arguments.append(f"std::addressof({arg.var_name})")
else: else:
call_arguments.append(arg.var_name) call_arguments.append(arg.var_name)
@ -574,9 +574,9 @@ static To Convert(const From& from) {
To to{}; To to{};
if constexpr (sizeof(To) >= sizeof(From)) { if constexpr (sizeof(To) >= sizeof(From)) {
std::memcpy(&to, &from, sizeof(From)); std::memcpy(std::addressof(to), std::addressof(from), sizeof(From));
} else { } else {
std::memcpy(&to, &from, sizeof(To)); std::memcpy(std::addressof(to), std::addressof(from), sizeof(To));
} }
return to; return to;