summaryrefslogtreecommitdiff
path: root/src/core/hle/kernel/svc.cpp
diff options
context:
space:
mode:
authorGravatar Liam2023-02-05 14:22:02 -0500
committerGravatar Liam2023-02-06 23:57:44 -0500
commit2415d37ea296e8856267375989a8b95cebe2575a (patch)
tree376baf5952a8ccc15b445702d38c056ffa71dd1b /src/core/hle/kernel/svc.cpp
parentMerge pull request #9731 from liamwhite/svc-move-only (diff)
downloadyuzu-2415d37ea296e8856267375989a8b95cebe2575a.tar.gz
yuzu-2415d37ea296e8856267375989a8b95cebe2575a.tar.xz
yuzu-2415d37ea296e8856267375989a8b95cebe2575a.zip
kernel/svc: switch to generated wrappers
Diffstat (limited to 'src/core/hle/kernel/svc.cpp')
-rw-r--r--src/core/hle/kernel/svc.cpp4844
1 files changed, 4415 insertions, 429 deletions
diff --git a/src/core/hle/kernel/svc.cpp b/src/core/hle/kernel/svc.cpp
index 4cb6f40a0..4ef57356e 100644
--- a/src/core/hle/kernel/svc.cpp
+++ b/src/core/hle/kernel/svc.cpp
@@ -1,449 +1,4435 @@
1// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project 1// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
2// SPDX-License-Identifier: GPL-2.0-or-later 2// SPDX-License-Identifier: GPL-2.0-or-later
3 3
4#include "common/common_types.h" 4// This file is automatically generated using svc_generator.py.
5
6#include <type_traits>
7
8#include "core/arm/arm_interface.h"
9#include "core/core.h"
5#include "core/hle/kernel/k_process.h" 10#include "core/hle/kernel/k_process.h"
6#include "core/hle/kernel/k_thread.h"
7#include "core/hle/kernel/svc.h" 11#include "core/hle/kernel/svc.h"
8#include "core/hle/kernel/svc_wrap.h"
9#include "core/hle/result.h"
10 12
11namespace Kernel::Svc { 13namespace Kernel::Svc {
12namespace { 14
13 15static uint32_t GetReg32(Core::System& system, int n) {
14struct FunctionDef { 16 return static_cast<uint32_t>(system.CurrentArmInterface().GetReg(n));
15 using Func = void(Core::System&); 17}
16 18
17 u32 id; 19static void SetReg32(Core::System& system, int n, uint32_t result) {
18 Func* func; 20 system.CurrentArmInterface().SetReg(n, static_cast<uint64_t>(result));
19 const char* name; 21}
20}; 22
21 23static uint64_t GetReg64(Core::System& system, int n) {
22} // namespace 24 return system.CurrentArmInterface().GetReg(n);
23 25}
24static const FunctionDef SVC_Table_32[] = { 26
25 {0x00, nullptr, "Unknown0"}, 27static void SetReg64(Core::System& system, int n, uint64_t result) {
26 {0x01, SvcWrap32<SetHeapSize32>, "SetHeapSize32"}, 28 system.CurrentArmInterface().SetReg(n, result);
27 {0x02, nullptr, "SetMemoryPermission32"}, 29}
28 {0x03, SvcWrap32<SetMemoryAttribute32>, "SetMemoryAttribute32"}, 30
29 {0x04, SvcWrap32<MapMemory32>, "MapMemory32"}, 31// Like bit_cast, but handles the case when the source and dest
30 {0x05, SvcWrap32<UnmapMemory32>, "UnmapMemory32"}, 32// are differently-sized.
31 {0x06, SvcWrap32<QueryMemory32>, "QueryMemory32"}, 33template <typename To, typename From>
32 {0x07, SvcWrap32<ExitProcess32>, "ExitProcess32"}, 34 requires(std::is_trivial_v<To> && std::is_trivially_copyable_v<From>)
33 {0x08, SvcWrap32<CreateThread32>, "CreateThread32"}, 35static To Convert(const From& from) {
34 {0x09, SvcWrap32<StartThread32>, "StartThread32"}, 36 To to{};
35 {0x0a, SvcWrap32<ExitThread32>, "ExitThread32"}, 37
36 {0x0b, SvcWrap32<SleepThread32>, "SleepThread32"}, 38 if constexpr (sizeof(To) >= sizeof(From)) {
37 {0x0c, SvcWrap32<GetThreadPriority32>, "GetThreadPriority32"}, 39 std::memcpy(&to, &from, sizeof(From));
38 {0x0d, SvcWrap32<SetThreadPriority32>, "SetThreadPriority32"}, 40 } else {
39 {0x0e, SvcWrap32<GetThreadCoreMask32>, "GetThreadCoreMask32"}, 41 std::memcpy(&to, &from, sizeof(To));
40 {0x0f, SvcWrap32<SetThreadCoreMask32>, "SetThreadCoreMask32"}, 42 }
41 {0x10, SvcWrap32<GetCurrentProcessorNumber32>, "GetCurrentProcessorNumber32"}, 43
42 {0x11, SvcWrap32<SignalEvent32>, "SignalEvent32"}, 44 return to;
43 {0x12, SvcWrap32<ClearEvent32>, "ClearEvent32"}, 45}
44 {0x13, SvcWrap32<MapSharedMemory32>, "MapSharedMemory32"}, 46
45 {0x14, SvcWrap32<UnmapSharedMemory32>, "UnmapSharedMemory32"}, 47// clang-format off
46 {0x15, SvcWrap32<CreateTransferMemory32>, "CreateTransferMemory32"}, 48static_assert(sizeof(ArbitrationType) == 4);
47 {0x16, SvcWrap32<CloseHandle32>, "CloseHandle32"}, 49static_assert(sizeof(BreakReason) == 4);
48 {0x17, SvcWrap32<ResetSignal32>, "ResetSignal32"}, 50static_assert(sizeof(CodeMemoryOperation) == 4);
49 {0x18, SvcWrap32<WaitSynchronization32>, "WaitSynchronization32"}, 51static_assert(sizeof(DebugThreadParam) == 4);
50 {0x19, SvcWrap32<CancelSynchronization32>, "CancelSynchronization32"}, 52static_assert(sizeof(DeviceName) == 4);
51 {0x1a, SvcWrap32<ArbitrateLock32>, "ArbitrateLock32"}, 53static_assert(sizeof(HardwareBreakPointRegisterName) == 4);
52 {0x1b, SvcWrap32<ArbitrateUnlock32>, "ArbitrateUnlock32"}, 54static_assert(sizeof(Handle) == 4);
53 {0x1c, SvcWrap32<WaitProcessWideKeyAtomic32>, "WaitProcessWideKeyAtomic32"}, 55static_assert(sizeof(InfoType) == 4);
54 {0x1d, SvcWrap32<SignalProcessWideKey32>, "SignalProcessWideKey32"}, 56static_assert(sizeof(InterruptType) == 4);
55 {0x1e, SvcWrap32<GetSystemTick32>, "GetSystemTick32"}, 57static_assert(sizeof(IoPoolType) == 4);
56 {0x1f, SvcWrap32<ConnectToNamedPort32>, "ConnectToNamedPort32"}, 58static_assert(sizeof(KernelDebugType) == 4);
57 {0x20, nullptr, "SendSyncRequestLight32"}, 59static_assert(sizeof(KernelTraceState) == 4);
58 {0x21, SvcWrap32<SendSyncRequest32>, "SendSyncRequest32"}, 60static_assert(sizeof(LimitableResource) == 4);
59 {0x22, nullptr, "SendSyncRequestWithUserBuffer32"}, 61static_assert(sizeof(MemoryMapping) == 4);
60 {0x23, nullptr, "SendAsyncRequestWithUserBuffer32"}, 62static_assert(sizeof(MemoryPermission) == 4);
61 {0x24, SvcWrap32<GetProcessId32>, "GetProcessId32"}, 63static_assert(sizeof(PageInfo) == 4);
62 {0x25, SvcWrap32<GetThreadId32>, "GetThreadId32"}, 64static_assert(sizeof(ProcessActivity) == 4);
63 {0x26, SvcWrap32<Break32>, "Break32"}, 65static_assert(sizeof(ProcessInfoType) == 4);
64 {0x27, SvcWrap32<OutputDebugString32>, "OutputDebugString32"}, 66static_assert(sizeof(Result) == 4);
65 {0x28, nullptr, "ReturnFromException32"}, 67static_assert(sizeof(SignalType) == 4);
66 {0x29, SvcWrap32<GetInfo32>, "GetInfo32"}, 68static_assert(sizeof(SystemInfoType) == 4);
67 {0x2a, nullptr, "FlushEntireDataCache32"}, 69static_assert(sizeof(ThreadActivity) == 4);
68 {0x2b, nullptr, "FlushDataCache32"}, 70static_assert(sizeof(ilp32::LastThreadContext) == 16);
69 {0x2c, SvcWrap32<MapPhysicalMemory32>, "MapPhysicalMemory32"}, 71static_assert(sizeof(ilp32::PhysicalMemoryInfo) == 16);
70 {0x2d, SvcWrap32<UnmapPhysicalMemory32>, "UnmapPhysicalMemory32"}, 72static_assert(sizeof(ilp32::SecureMonitorArguments) == 32);
71 {0x2e, nullptr, "GetDebugFutureThreadInfo32"}, 73static_assert(sizeof(lp64::LastThreadContext) == 32);
72 {0x2f, nullptr, "GetLastThreadInfo32"}, 74static_assert(sizeof(lp64::PhysicalMemoryInfo) == 24);
73 {0x30, nullptr, "GetResourceLimitLimitValue32"}, 75static_assert(sizeof(lp64::SecureMonitorArguments) == 64);
74 {0x31, nullptr, "GetResourceLimitCurrentValue32"}, 76static_assert(sizeof(bool) == 1);
75 {0x32, SvcWrap32<SetThreadActivity32>, "SetThreadActivity32"}, 77static_assert(sizeof(int32_t) == 4);
76 {0x33, SvcWrap32<GetThreadContext32>, "GetThreadContext32"}, 78static_assert(sizeof(int64_t) == 8);
77 {0x34, SvcWrap32<WaitForAddress32>, "WaitForAddress32"}, 79static_assert(sizeof(uint32_t) == 4);
78 {0x35, SvcWrap32<SignalToAddress32>, "SignalToAddress32"}, 80static_assert(sizeof(uint64_t) == 8);
79 {0x36, SvcWrap32<SynchronizePreemptionState>, "SynchronizePreemptionState32"}, 81
80 {0x37, nullptr, "GetResourceLimitPeakValue32"}, 82static void SvcWrap_SetHeapSize64From32(Core::System& system) {
81 {0x38, nullptr, "Unknown38"}, 83 Result ret{};
82 {0x39, nullptr, "CreateIoPool32"}, 84
83 {0x3a, nullptr, "CreateIoRegion32"}, 85 uintptr_t out_address{};
84 {0x3b, nullptr, "Unknown3b"}, 86 uint32_t size{};
85 {0x3c, nullptr, "KernelDebug32"}, 87
86 {0x3d, nullptr, "ChangeKernelTraceState32"}, 88 size = Convert<uint32_t>(GetReg32(system, 1));
87 {0x3e, nullptr, "Unknown3e"}, 89
88 {0x3f, nullptr, "Unknown3f"}, 90 ret = SetHeapSize64From32(system, &out_address, size);
89 {0x40, nullptr, "CreateSession32"}, 91
90 {0x41, nullptr, "AcceptSession32"}, 92 SetReg32(system, 0, Convert<uint32_t>(ret));
91 {0x42, nullptr, "ReplyAndReceiveLight32"}, 93 SetReg32(system, 1, Convert<uint32_t>(out_address));
92 {0x43, nullptr, "ReplyAndReceive32"}, 94}
93 {0x44, nullptr, "ReplyAndReceiveWithUserBuffer32"}, 95
94 {0x45, SvcWrap32<CreateEvent32>, "CreateEvent32"}, 96static void SvcWrap_SetMemoryPermission64From32(Core::System& system) {
95 {0x46, nullptr, "MapIoRegion32"}, 97 Result ret{};
96 {0x47, nullptr, "UnmapIoRegion32"}, 98
97 {0x48, nullptr, "MapPhysicalMemoryUnsafe32"}, 99 uint32_t address{};
98 {0x49, nullptr, "UnmapPhysicalMemoryUnsafe32"}, 100 uint32_t size{};
99 {0x4a, nullptr, "SetUnsafeLimit32"}, 101 MemoryPermission perm{};
100 {0x4b, SvcWrap32<CreateCodeMemory32>, "CreateCodeMemory32"}, 102
101 {0x4c, SvcWrap32<ControlCodeMemory32>, "ControlCodeMemory32"}, 103 address = Convert<uint32_t>(GetReg32(system, 0));
102 {0x4d, nullptr, "SleepSystem32"}, 104 size = Convert<uint32_t>(GetReg32(system, 1));
103 {0x4e, nullptr, "ReadWriteRegister32"}, 105 perm = Convert<MemoryPermission>(GetReg32(system, 2));
104 {0x4f, nullptr, "SetProcessActivity32"}, 106
105 {0x50, nullptr, "CreateSharedMemory32"}, 107 ret = SetMemoryPermission64From32(system, address, size, perm);
106 {0x51, nullptr, "MapTransferMemory32"}, 108
107 {0x52, nullptr, "UnmapTransferMemory32"}, 109 SetReg32(system, 0, Convert<uint32_t>(ret));
108 {0x53, nullptr, "CreateInterruptEvent32"}, 110}
109 {0x54, nullptr, "QueryPhysicalAddress32"}, 111
110 {0x55, nullptr, "QueryIoMapping32"}, 112static void SvcWrap_SetMemoryAttribute64From32(Core::System& system) {
111 {0x56, nullptr, "CreateDeviceAddressSpace32"}, 113 Result ret{};
112 {0x57, nullptr, "AttachDeviceAddressSpace32"}, 114
113 {0x58, nullptr, "DetachDeviceAddressSpace32"}, 115 uint32_t address{};
114 {0x59, nullptr, "MapDeviceAddressSpaceByForce32"}, 116 uint32_t size{};
115 {0x5a, nullptr, "MapDeviceAddressSpaceAligned32"}, 117 uint32_t mask{};
116 {0x5b, nullptr, "MapDeviceAddressSpace32"}, 118 uint32_t attr{};
117 {0x5c, nullptr, "UnmapDeviceAddressSpace32"}, 119
118 {0x5d, nullptr, "InvalidateProcessDataCache32"}, 120 address = Convert<uint32_t>(GetReg32(system, 0));
119 {0x5e, nullptr, "StoreProcessDataCache32"}, 121 size = Convert<uint32_t>(GetReg32(system, 1));
120 {0x5F, SvcWrap32<FlushProcessDataCache32>, "FlushProcessDataCache32"}, 122 mask = Convert<uint32_t>(GetReg32(system, 2));
121 {0x60, nullptr, "StoreProcessDataCache32"}, 123 attr = Convert<uint32_t>(GetReg32(system, 3));
122 {0x61, nullptr, "BreakDebugProcess32"}, 124
123 {0x62, nullptr, "TerminateDebugProcess32"}, 125 ret = SetMemoryAttribute64From32(system, address, size, mask, attr);
124 {0x63, nullptr, "GetDebugEvent32"}, 126
125 {0x64, nullptr, "ContinueDebugEvent32"}, 127 SetReg32(system, 0, Convert<uint32_t>(ret));
126 {0x65, nullptr, "GetProcessList32"}, 128}
127 {0x66, nullptr, "GetThreadList"}, 129
128 {0x67, nullptr, "GetDebugThreadContext32"}, 130static void SvcWrap_MapMemory64From32(Core::System& system) {
129 {0x68, nullptr, "SetDebugThreadContext32"}, 131 Result ret{};
130 {0x69, nullptr, "QueryDebugProcessMemory32"}, 132
131 {0x6A, nullptr, "ReadDebugProcessMemory32"}, 133 uint32_t dst_address{};
132 {0x6B, nullptr, "WriteDebugProcessMemory32"}, 134 uint32_t src_address{};
133 {0x6C, nullptr, "SetHardwareBreakPoint32"}, 135 uint32_t size{};
134 {0x6D, nullptr, "GetDebugThreadParam32"}, 136
135 {0x6E, nullptr, "Unknown6E"}, 137 dst_address = Convert<uint32_t>(GetReg32(system, 0));
136 {0x6f, nullptr, "GetSystemInfo32"}, 138 src_address = Convert<uint32_t>(GetReg32(system, 1));
137 {0x70, nullptr, "CreatePort32"}, 139 size = Convert<uint32_t>(GetReg32(system, 2));
138 {0x71, nullptr, "ManageNamedPort32"}, 140
139 {0x72, nullptr, "ConnectToPort32"}, 141 ret = MapMemory64From32(system, dst_address, src_address, size);
140 {0x73, nullptr, "SetProcessMemoryPermission32"}, 142
141 {0x74, nullptr, "MapProcessMemory32"}, 143 SetReg32(system, 0, Convert<uint32_t>(ret));
142 {0x75, nullptr, "UnmapProcessMemory32"}, 144}
143 {0x76, nullptr, "QueryProcessMemory32"}, 145
144 {0x77, nullptr, "MapProcessCodeMemory32"}, 146static void SvcWrap_UnmapMemory64From32(Core::System& system) {
145 {0x78, nullptr, "UnmapProcessCodeMemory32"}, 147 Result ret{};
146 {0x79, nullptr, "CreateProcess32"}, 148
147 {0x7A, nullptr, "StartProcess32"}, 149 uint32_t dst_address{};
148 {0x7B, nullptr, "TerminateProcess32"}, 150 uint32_t src_address{};
149 {0x7C, nullptr, "GetProcessInfo32"}, 151 uint32_t size{};
150 {0x7D, nullptr, "CreateResourceLimit32"}, 152
151 {0x7E, nullptr, "SetResourceLimitLimitValue32"}, 153 dst_address = Convert<uint32_t>(GetReg32(system, 0));
152 {0x7F, nullptr, "CallSecureMonitor32"}, 154 src_address = Convert<uint32_t>(GetReg32(system, 1));
153 {0x80, nullptr, "Unknown"}, 155 size = Convert<uint32_t>(GetReg32(system, 2));
154 {0x81, nullptr, "Unknown"}, 156
155 {0x82, nullptr, "Unknown"}, 157 ret = UnmapMemory64From32(system, dst_address, src_address, size);
156 {0x83, nullptr, "Unknown"}, 158
157 {0x84, nullptr, "Unknown"}, 159 SetReg32(system, 0, Convert<uint32_t>(ret));
158 {0x85, nullptr, "Unknown"}, 160}
159 {0x86, nullptr, "Unknown"}, 161
160 {0x87, nullptr, "Unknown"}, 162static void SvcWrap_QueryMemory64From32(Core::System& system) {
161 {0x88, nullptr, "Unknown"}, 163 Result ret{};
162 {0x89, nullptr, "Unknown"}, 164
163 {0x8A, nullptr, "Unknown"}, 165 PageInfo out_page_info{};
164 {0x8B, nullptr, "Unknown"}, 166 uint32_t out_memory_info{};
165 {0x8C, nullptr, "Unknown"}, 167 uint32_t address{};
166 {0x8D, nullptr, "Unknown"}, 168
167 {0x8E, nullptr, "Unknown"}, 169 out_memory_info = Convert<uint32_t>(GetReg32(system, 0));
168 {0x8F, nullptr, "Unknown"}, 170 address = Convert<uint32_t>(GetReg32(system, 2));
169 {0x90, nullptr, "Unknown"}, 171
170 {0x91, nullptr, "Unknown"}, 172 ret = QueryMemory64From32(system, out_memory_info, &out_page_info, address);
171 {0x92, nullptr, "Unknown"}, 173
172 {0x93, nullptr, "Unknown"}, 174 SetReg32(system, 0, Convert<uint32_t>(ret));
173 {0x94, nullptr, "Unknown"}, 175 SetReg32(system, 1, Convert<uint32_t>(out_page_info));
174 {0x95, nullptr, "Unknown"}, 176}
175 {0x96, nullptr, "Unknown"}, 177
176 {0x97, nullptr, "Unknown"}, 178static void SvcWrap_ExitProcess64From32(Core::System& system) {
177 {0x98, nullptr, "Unknown"}, 179 ExitProcess64From32(system);
178 {0x99, nullptr, "Unknown"}, 180}
179 {0x9A, nullptr, "Unknown"}, 181
180 {0x9B, nullptr, "Unknown"}, 182static void SvcWrap_CreateThread64From32(Core::System& system) {
181 {0x9C, nullptr, "Unknown"}, 183 Result ret{};
182 {0x9D, nullptr, "Unknown"}, 184
183 {0x9E, nullptr, "Unknown"}, 185 Handle out_handle{};
184 {0x9F, nullptr, "Unknown"}, 186 uint32_t func{};
185 {0xA0, nullptr, "Unknown"}, 187 uint32_t arg{};
186 {0xA1, nullptr, "Unknown"}, 188 uint32_t stack_bottom{};
187 {0xA2, nullptr, "Unknown"}, 189 int32_t priority{};
188 {0xA3, nullptr, "Unknown"}, 190 int32_t core_id{};
189 {0xA4, nullptr, "Unknown"}, 191
190 {0xA5, nullptr, "Unknown"}, 192 func = Convert<uint32_t>(GetReg32(system, 1));
191 {0xA6, nullptr, "Unknown"}, 193 arg = Convert<uint32_t>(GetReg32(system, 2));
192 {0xA7, nullptr, "Unknown"}, 194 stack_bottom = Convert<uint32_t>(GetReg32(system, 3));
193 {0xA8, nullptr, "Unknown"}, 195 priority = Convert<int32_t>(GetReg32(system, 0));
194 {0xA9, nullptr, "Unknown"}, 196 core_id = Convert<int32_t>(GetReg32(system, 4));
195 {0xAA, nullptr, "Unknown"}, 197
196 {0xAB, nullptr, "Unknown"}, 198 ret = CreateThread64From32(system, &out_handle, func, arg, stack_bottom, priority, core_id);
197 {0xAC, nullptr, "Unknown"}, 199
198 {0xAD, nullptr, "Unknown"}, 200 SetReg32(system, 0, Convert<uint32_t>(ret));
199 {0xAE, nullptr, "Unknown"}, 201 SetReg32(system, 1, Convert<uint32_t>(out_handle));
200 {0xAF, nullptr, "Unknown"}, 202}
201 {0xB0, nullptr, "Unknown"}, 203
202 {0xB1, nullptr, "Unknown"}, 204static void SvcWrap_StartThread64From32(Core::System& system) {
203 {0xB2, nullptr, "Unknown"}, 205 Result ret{};
204 {0xB3, nullptr, "Unknown"}, 206
205 {0xB4, nullptr, "Unknown"}, 207 Handle thread_handle{};
206 {0xB5, nullptr, "Unknown"}, 208
207 {0xB6, nullptr, "Unknown"}, 209 thread_handle = Convert<Handle>(GetReg32(system, 0));
208 {0xB7, nullptr, "Unknown"}, 210
209 {0xB8, nullptr, "Unknown"}, 211 ret = StartThread64From32(system, thread_handle);
210 {0xB9, nullptr, "Unknown"}, 212
211 {0xBA, nullptr, "Unknown"}, 213 SetReg32(system, 0, Convert<uint32_t>(ret));
212 {0xBB, nullptr, "Unknown"}, 214}
213 {0xBC, nullptr, "Unknown"}, 215
214 {0xBD, nullptr, "Unknown"}, 216static void SvcWrap_ExitThread64From32(Core::System& system) {
215 {0xBE, nullptr, "Unknown"}, 217 ExitThread64From32(system);
216 {0xBF, nullptr, "Unknown"}, 218}
217}; 219
218 220static void SvcWrap_SleepThread64From32(Core::System& system) {
219static const FunctionDef SVC_Table_64[] = { 221 int64_t ns{};
220 {0x00, nullptr, "Unknown0"}, 222
221 {0x01, SvcWrap64<SetHeapSize>, "SetHeapSize"}, 223 std::array<uint32_t, 2> ns_gather{};
222 {0x02, SvcWrap64<SetMemoryPermission>, "SetMemoryPermission"}, 224 ns_gather[0] = GetReg32(system, 0);
223 {0x03, SvcWrap64<SetMemoryAttribute>, "SetMemoryAttribute"}, 225 ns_gather[1] = GetReg32(system, 1);
224 {0x04, SvcWrap64<MapMemory>, "MapMemory"}, 226 ns = Convert<int64_t>(ns_gather);
225 {0x05, SvcWrap64<UnmapMemory>, "UnmapMemory"}, 227
226 {0x06, SvcWrap64<QueryMemory>, "QueryMemory"}, 228 SleepThread64From32(system, ns);
227 {0x07, SvcWrap64<ExitProcess>, "ExitProcess"}, 229}
228 {0x08, SvcWrap64<CreateThread>, "CreateThread"}, 230
229 {0x09, SvcWrap64<StartThread>, "StartThread"}, 231static void SvcWrap_GetThreadPriority64From32(Core::System& system) {
230 {0x0A, SvcWrap64<ExitThread>, "ExitThread"}, 232 Result ret{};
231 {0x0B, SvcWrap64<SleepThread>, "SleepThread"}, 233
232 {0x0C, SvcWrap64<GetThreadPriority>, "GetThreadPriority"}, 234 int32_t out_priority{};
233 {0x0D, SvcWrap64<SetThreadPriority>, "SetThreadPriority"}, 235 Handle thread_handle{};
234 {0x0E, SvcWrap64<GetThreadCoreMask>, "GetThreadCoreMask"}, 236
235 {0x0F, SvcWrap64<SetThreadCoreMask>, "SetThreadCoreMask"}, 237 thread_handle = Convert<Handle>(GetReg32(system, 1));
236 {0x10, SvcWrap64<GetCurrentProcessorNumber>, "GetCurrentProcessorNumber"}, 238
237 {0x11, SvcWrap64<SignalEvent>, "SignalEvent"}, 239 ret = GetThreadPriority64From32(system, &out_priority, thread_handle);
238 {0x12, SvcWrap64<ClearEvent>, "ClearEvent"}, 240
239 {0x13, SvcWrap64<MapSharedMemory>, "MapSharedMemory"}, 241 SetReg32(system, 0, Convert<uint32_t>(ret));
240 {0x14, SvcWrap64<UnmapSharedMemory>, "UnmapSharedMemory"}, 242 SetReg32(system, 1, Convert<uint32_t>(out_priority));
241 {0x15, SvcWrap64<CreateTransferMemory>, "CreateTransferMemory"}, 243}
242 {0x16, SvcWrap64<CloseHandle>, "CloseHandle"}, 244
243 {0x17, SvcWrap64<ResetSignal>, "ResetSignal"}, 245static void SvcWrap_SetThreadPriority64From32(Core::System& system) {
244 {0x18, SvcWrap64<WaitSynchronization>, "WaitSynchronization"}, 246 Result ret{};
245 {0x19, SvcWrap64<CancelSynchronization>, "CancelSynchronization"}, 247
246 {0x1A, SvcWrap64<ArbitrateLock>, "ArbitrateLock"}, 248 Handle thread_handle{};
247 {0x1B, SvcWrap64<ArbitrateUnlock>, "ArbitrateUnlock"}, 249 int32_t priority{};
248 {0x1C, SvcWrap64<WaitProcessWideKeyAtomic>, "WaitProcessWideKeyAtomic"}, 250
249 {0x1D, SvcWrap64<SignalProcessWideKey>, "SignalProcessWideKey"}, 251 thread_handle = Convert<Handle>(GetReg32(system, 0));
250 {0x1E, SvcWrap64<GetSystemTick>, "GetSystemTick"}, 252 priority = Convert<int32_t>(GetReg32(system, 1));
251 {0x1F, SvcWrap64<ConnectToNamedPort>, "ConnectToNamedPort"}, 253
252 {0x20, nullptr, "SendSyncRequestLight"}, 254 ret = SetThreadPriority64From32(system, thread_handle, priority);
253 {0x21, SvcWrap64<SendSyncRequest>, "SendSyncRequest"}, 255
254 {0x22, nullptr, "SendSyncRequestWithUserBuffer"}, 256 SetReg32(system, 0, Convert<uint32_t>(ret));
255 {0x23, nullptr, "SendAsyncRequestWithUserBuffer"}, 257}
256 {0x24, SvcWrap64<GetProcessId>, "GetProcessId"}, 258
257 {0x25, SvcWrap64<GetThreadId>, "GetThreadId"}, 259static void SvcWrap_GetThreadCoreMask64From32(Core::System& system) {
258 {0x26, SvcWrap64<Break>, "Break"}, 260 Result ret{};
259 {0x27, SvcWrap64<OutputDebugString>, "OutputDebugString"}, 261
260 {0x28, nullptr, "ReturnFromException"}, 262 int32_t out_core_id{};
261 {0x29, SvcWrap64<GetInfo>, "GetInfo"}, 263 uint64_t out_affinity_mask{};
262 {0x2A, nullptr, "FlushEntireDataCache"}, 264 Handle thread_handle{};
263 {0x2B, nullptr, "FlushDataCache"}, 265
264 {0x2C, SvcWrap64<MapPhysicalMemory>, "MapPhysicalMemory"}, 266 thread_handle = Convert<Handle>(GetReg32(system, 2));
265 {0x2D, SvcWrap64<UnmapPhysicalMemory>, "UnmapPhysicalMemory"}, 267
266 {0x2E, nullptr, "GetFutureThreadInfo"}, 268 ret = GetThreadCoreMask64From32(system, &out_core_id, &out_affinity_mask, thread_handle);
267 {0x2F, nullptr, "GetLastThreadInfo"}, 269
268 {0x30, SvcWrap64<GetResourceLimitLimitValue>, "GetResourceLimitLimitValue"}, 270 SetReg32(system, 0, Convert<uint32_t>(ret));
269 {0x31, SvcWrap64<GetResourceLimitCurrentValue>, "GetResourceLimitCurrentValue"}, 271 SetReg32(system, 1, Convert<uint32_t>(out_core_id));
270 {0x32, SvcWrap64<SetThreadActivity>, "SetThreadActivity"}, 272 auto out_affinity_mask_scatter = Convert<std::array<uint32_t, 2>>(out_affinity_mask);
271 {0x33, SvcWrap64<GetThreadContext>, "GetThreadContext"}, 273 SetReg32(system, 2, out_affinity_mask_scatter[0]);
272 {0x34, SvcWrap64<WaitForAddress>, "WaitForAddress"}, 274 SetReg32(system, 3, out_affinity_mask_scatter[1]);
273 {0x35, SvcWrap64<SignalToAddress>, "SignalToAddress"}, 275}
274 {0x36, SvcWrap64<SynchronizePreemptionState>, "SynchronizePreemptionState"}, 276
275 {0x37, nullptr, "GetResourceLimitPeakValue"}, 277static void SvcWrap_SetThreadCoreMask64From32(Core::System& system) {
276 {0x38, nullptr, "Unknown38"}, 278 Result ret{};
277 {0x39, nullptr, "CreateIoPool"}, 279
278 {0x3A, nullptr, "CreateIoRegion"}, 280 Handle thread_handle{};
279 {0x3B, nullptr, "Unknown3B"}, 281 int32_t core_id{};
280 {0x3C, SvcWrap64<KernelDebug>, "KernelDebug"}, 282 uint64_t affinity_mask{};
281 {0x3D, SvcWrap64<ChangeKernelTraceState>, "ChangeKernelTraceState"}, 283
282 {0x3E, nullptr, "Unknown3e"}, 284 thread_handle = Convert<Handle>(GetReg32(system, 0));
283 {0x3F, nullptr, "Unknown3f"}, 285 core_id = Convert<int32_t>(GetReg32(system, 1));
284 {0x40, SvcWrap64<CreateSession>, "CreateSession"}, 286 std::array<uint32_t, 2> affinity_mask_gather{};
285 {0x41, nullptr, "AcceptSession"}, 287 affinity_mask_gather[0] = GetReg32(system, 2);
286 {0x42, nullptr, "ReplyAndReceiveLight"}, 288 affinity_mask_gather[1] = GetReg32(system, 3);
287 {0x43, SvcWrap64<ReplyAndReceive>, "ReplyAndReceive"}, 289 affinity_mask = Convert<uint64_t>(affinity_mask_gather);
288 {0x44, nullptr, "ReplyAndReceiveWithUserBuffer"}, 290
289 {0x45, SvcWrap64<CreateEvent>, "CreateEvent"}, 291 ret = SetThreadCoreMask64From32(system, thread_handle, core_id, affinity_mask);
290 {0x46, nullptr, "MapIoRegion"}, 292
291 {0x47, nullptr, "UnmapIoRegion"}, 293 SetReg32(system, 0, Convert<uint32_t>(ret));
292 {0x48, nullptr, "MapPhysicalMemoryUnsafe"}, 294}
293 {0x49, nullptr, "UnmapPhysicalMemoryUnsafe"}, 295
294 {0x4A, nullptr, "SetUnsafeLimit"}, 296static void SvcWrap_GetCurrentProcessorNumber64From32(Core::System& system) {
295 {0x4B, SvcWrap64<CreateCodeMemory>, "CreateCodeMemory"}, 297 int32_t ret{};
296 {0x4C, SvcWrap64<ControlCodeMemory>, "ControlCodeMemory"}, 298
297 {0x4D, nullptr, "SleepSystem"}, 299 ret = GetCurrentProcessorNumber64From32(system);
298 {0x4E, nullptr, "ReadWriteRegister"}, 300
299 {0x4F, nullptr, "SetProcessActivity"}, 301 SetReg32(system, 0, Convert<uint32_t>(ret));
300 {0x50, nullptr, "CreateSharedMemory"}, 302}
301 {0x51, nullptr, "MapTransferMemory"}, 303
302 {0x52, nullptr, "UnmapTransferMemory"}, 304static void SvcWrap_SignalEvent64From32(Core::System& system) {
303 {0x53, nullptr, "CreateInterruptEvent"}, 305 Result ret{};
304 {0x54, nullptr, "QueryPhysicalAddress"}, 306
305 {0x55, nullptr, "QueryIoMapping"}, 307 Handle event_handle{};
306 {0x56, nullptr, "CreateDeviceAddressSpace"}, 308
307 {0x57, nullptr, "AttachDeviceAddressSpace"}, 309 event_handle = Convert<Handle>(GetReg32(system, 0));
308 {0x58, nullptr, "DetachDeviceAddressSpace"}, 310
309 {0x59, nullptr, "MapDeviceAddressSpaceByForce"}, 311 ret = SignalEvent64From32(system, event_handle);
310 {0x5A, nullptr, "MapDeviceAddressSpaceAligned"}, 312
311 {0x5B, nullptr, "MapDeviceAddressSpace"}, 313 SetReg32(system, 0, Convert<uint32_t>(ret));
312 {0x5C, nullptr, "UnmapDeviceAddressSpace"}, 314}
313 {0x5D, nullptr, "InvalidateProcessDataCache"}, 315
314 {0x5E, nullptr, "StoreProcessDataCache"}, 316static void SvcWrap_ClearEvent64From32(Core::System& system) {
315 {0x5F, nullptr, "FlushProcessDataCache"}, 317 Result ret{};
316 {0x60, nullptr, "DebugActiveProcess"}, 318
317 {0x61, nullptr, "BreakDebugProcess"}, 319 Handle event_handle{};
318 {0x62, nullptr, "TerminateDebugProcess"}, 320
319 {0x63, nullptr, "GetDebugEvent"}, 321 event_handle = Convert<Handle>(GetReg32(system, 0));
320 {0x64, nullptr, "ContinueDebugEvent"}, 322
321 {0x65, SvcWrap64<GetProcessList>, "GetProcessList"}, 323 ret = ClearEvent64From32(system, event_handle);
322 {0x66, SvcWrap64<GetThreadList>, "GetThreadList"}, 324
323 {0x67, nullptr, "GetDebugThreadContext"}, 325 SetReg32(system, 0, Convert<uint32_t>(ret));
324 {0x68, nullptr, "SetDebugThreadContext"}, 326}
325 {0x69, nullptr, "QueryDebugProcessMemory"}, 327
326 {0x6A, nullptr, "ReadDebugProcessMemory"}, 328static void SvcWrap_MapSharedMemory64From32(Core::System& system) {
327 {0x6B, nullptr, "WriteDebugProcessMemory"}, 329 Result ret{};
328 {0x6C, nullptr, "SetHardwareBreakPoint"}, 330
329 {0x6D, nullptr, "GetDebugThreadParam"}, 331 Handle shmem_handle{};
330 {0x6E, nullptr, "Unknown6E"}, 332 uint32_t address{};
331 {0x6F, nullptr, "GetSystemInfo"}, 333 uint32_t size{};
332 {0x70, nullptr, "CreatePort"}, 334 MemoryPermission map_perm{};
333 {0x71, nullptr, "ManageNamedPort"}, 335
334 {0x72, nullptr, "ConnectToPort"}, 336 shmem_handle = Convert<Handle>(GetReg32(system, 0));
335 {0x73, SvcWrap64<SetProcessMemoryPermission>, "SetProcessMemoryPermission"}, 337 address = Convert<uint32_t>(GetReg32(system, 1));
336 {0x74, SvcWrap64<MapProcessMemory>, "MapProcessMemory"}, 338 size = Convert<uint32_t>(GetReg32(system, 2));
337 {0x75, SvcWrap64<UnmapProcessMemory>, "UnmapProcessMemory"}, 339 map_perm = Convert<MemoryPermission>(GetReg32(system, 3));
338 {0x76, SvcWrap64<QueryProcessMemory>, "QueryProcessMemory"}, 340
339 {0x77, SvcWrap64<MapProcessCodeMemory>, "MapProcessCodeMemory"}, 341 ret = MapSharedMemory64From32(system, shmem_handle, address, size, map_perm);
340 {0x78, SvcWrap64<UnmapProcessCodeMemory>, "UnmapProcessCodeMemory"}, 342
341 {0x79, nullptr, "CreateProcess"}, 343 SetReg32(system, 0, Convert<uint32_t>(ret));
342 {0x7A, nullptr, "StartProcess"}, 344}
343 {0x7B, nullptr, "TerminateProcess"}, 345
344 {0x7C, SvcWrap64<GetProcessInfo>, "GetProcessInfo"}, 346static void SvcWrap_UnmapSharedMemory64From32(Core::System& system) {
345 {0x7D, SvcWrap64<CreateResourceLimit>, "CreateResourceLimit"}, 347 Result ret{};
346 {0x7E, SvcWrap64<SetResourceLimitLimitValue>, "SetResourceLimitLimitValue"}, 348
347 {0x7F, nullptr, "CallSecureMonitor"}, 349 Handle shmem_handle{};
348 {0x80, nullptr, "Unknown"}, 350 uint32_t address{};
349 {0x81, nullptr, "Unknown"}, 351 uint32_t size{};
350 {0x82, nullptr, "Unknown"}, 352
351 {0x83, nullptr, "Unknown"}, 353 shmem_handle = Convert<Handle>(GetReg32(system, 0));
352 {0x84, nullptr, "Unknown"}, 354 address = Convert<uint32_t>(GetReg32(system, 1));
353 {0x85, nullptr, "Unknown"}, 355 size = Convert<uint32_t>(GetReg32(system, 2));
354 {0x86, nullptr, "Unknown"}, 356
355 {0x87, nullptr, "Unknown"}, 357 ret = UnmapSharedMemory64From32(system, shmem_handle, address, size);
356 {0x88, nullptr, "Unknown"}, 358
357 {0x89, nullptr, "Unknown"}, 359 SetReg32(system, 0, Convert<uint32_t>(ret));
358 {0x8A, nullptr, "Unknown"}, 360}
359 {0x8B, nullptr, "Unknown"}, 361
360 {0x8C, nullptr, "Unknown"}, 362static void SvcWrap_CreateTransferMemory64From32(Core::System& system) {
361 {0x8D, nullptr, "Unknown"}, 363 Result ret{};
362 {0x8E, nullptr, "Unknown"}, 364
363 {0x8F, nullptr, "Unknown"}, 365 Handle out_handle{};
364 {0x90, nullptr, "Unknown"}, 366 uint32_t address{};
365 {0x91, nullptr, "Unknown"}, 367 uint32_t size{};
366 {0x92, nullptr, "Unknown"}, 368 MemoryPermission map_perm{};
367 {0x93, nullptr, "Unknown"}, 369
368 {0x94, nullptr, "Unknown"}, 370 address = Convert<uint32_t>(GetReg32(system, 1));
369 {0x95, nullptr, "Unknown"}, 371 size = Convert<uint32_t>(GetReg32(system, 2));
370 {0x96, nullptr, "Unknown"}, 372 map_perm = Convert<MemoryPermission>(GetReg32(system, 3));
371 {0x97, nullptr, "Unknown"}, 373
372 {0x98, nullptr, "Unknown"}, 374 ret = CreateTransferMemory64From32(system, &out_handle, address, size, map_perm);
373 {0x99, nullptr, "Unknown"}, 375
374 {0x9A, nullptr, "Unknown"}, 376 SetReg32(system, 0, Convert<uint32_t>(ret));
375 {0x9B, nullptr, "Unknown"}, 377 SetReg32(system, 1, Convert<uint32_t>(out_handle));
376 {0x9C, nullptr, "Unknown"}, 378}
377 {0x9D, nullptr, "Unknown"}, 379
378 {0x9E, nullptr, "Unknown"}, 380static void SvcWrap_CloseHandle64From32(Core::System& system) {
379 {0x9F, nullptr, "Unknown"}, 381 Result ret{};
380 {0xA0, nullptr, "Unknown"}, 382
381 {0xA1, nullptr, "Unknown"}, 383 Handle handle{};
382 {0xA2, nullptr, "Unknown"}, 384
383 {0xA3, nullptr, "Unknown"}, 385 handle = Convert<Handle>(GetReg32(system, 0));
384 {0xA4, nullptr, "Unknown"}, 386
385 {0xA5, nullptr, "Unknown"}, 387 ret = CloseHandle64From32(system, handle);
386 {0xA6, nullptr, "Unknown"}, 388
387 {0xA7, nullptr, "Unknown"}, 389 SetReg32(system, 0, Convert<uint32_t>(ret));
388 {0xA8, nullptr, "Unknown"}, 390}
389 {0xA9, nullptr, "Unknown"}, 391
390 {0xAA, nullptr, "Unknown"}, 392static void SvcWrap_ResetSignal64From32(Core::System& system) {
391 {0xAB, nullptr, "Unknown"}, 393 Result ret{};
392 {0xAC, nullptr, "Unknown"}, 394
393 {0xAD, nullptr, "Unknown"}, 395 Handle handle{};
394 {0xAE, nullptr, "Unknown"}, 396
395 {0xAF, nullptr, "Unknown"}, 397 handle = Convert<Handle>(GetReg32(system, 0));
396 {0xB0, nullptr, "Unknown"}, 398
397 {0xB1, nullptr, "Unknown"}, 399 ret = ResetSignal64From32(system, handle);
398 {0xB2, nullptr, "Unknown"}, 400
399 {0xB3, nullptr, "Unknown"}, 401 SetReg32(system, 0, Convert<uint32_t>(ret));
400 {0xB4, nullptr, "Unknown"}, 402}
401 {0xB5, nullptr, "Unknown"}, 403
402 {0xB6, nullptr, "Unknown"}, 404static void SvcWrap_WaitSynchronization64From32(Core::System& system) {
403 {0xB7, nullptr, "Unknown"}, 405 Result ret{};
404 {0xB8, nullptr, "Unknown"}, 406
405 {0xB9, nullptr, "Unknown"}, 407 int32_t out_index{};
406 {0xBA, nullptr, "Unknown"}, 408 uint32_t handles{};
407 {0xBB, nullptr, "Unknown"}, 409 int32_t num_handles{};
408 {0xBC, nullptr, "Unknown"}, 410 int64_t timeout_ns{};
409 {0xBD, nullptr, "Unknown"}, 411
410 {0xBE, nullptr, "Unknown"}, 412 handles = Convert<uint32_t>(GetReg32(system, 1));
411 {0xBF, nullptr, "Unknown"}, 413 num_handles = Convert<int32_t>(GetReg32(system, 2));
412}; 414 std::array<uint32_t, 2> timeout_ns_gather{};
413 415 timeout_ns_gather[0] = GetReg32(system, 0);
414static const FunctionDef* GetSVCInfo32(u32 func_num) { 416 timeout_ns_gather[1] = GetReg32(system, 3);
415 if (func_num >= std::size(SVC_Table_32)) { 417 timeout_ns = Convert<int64_t>(timeout_ns_gather);
416 LOG_ERROR(Kernel_SVC, "Unknown svc=0x{:02X}", func_num); 418
417 return nullptr; 419 ret = WaitSynchronization64From32(system, &out_index, handles, num_handles, timeout_ns);
420
421 SetReg32(system, 0, Convert<uint32_t>(ret));
422 SetReg32(system, 1, Convert<uint32_t>(out_index));
423}
424
425static void SvcWrap_CancelSynchronization64From32(Core::System& system) {
426 Result ret{};
427
428 Handle handle{};
429
430 handle = Convert<Handle>(GetReg32(system, 0));
431
432 ret = CancelSynchronization64From32(system, handle);
433
434 SetReg32(system, 0, Convert<uint32_t>(ret));
435}
436
437static void SvcWrap_ArbitrateLock64From32(Core::System& system) {
438 Result ret{};
439
440 Handle thread_handle{};
441 uint32_t address{};
442 uint32_t tag{};
443
444 thread_handle = Convert<Handle>(GetReg32(system, 0));
445 address = Convert<uint32_t>(GetReg32(system, 1));
446 tag = Convert<uint32_t>(GetReg32(system, 2));
447
448 ret = ArbitrateLock64From32(system, thread_handle, address, tag);
449
450 SetReg32(system, 0, Convert<uint32_t>(ret));
451}
452
453static void SvcWrap_ArbitrateUnlock64From32(Core::System& system) {
454 Result ret{};
455
456 uint32_t address{};
457
458 address = Convert<uint32_t>(GetReg32(system, 0));
459
460 ret = ArbitrateUnlock64From32(system, address);
461
462 SetReg32(system, 0, Convert<uint32_t>(ret));
463}
464
465static void SvcWrap_WaitProcessWideKeyAtomic64From32(Core::System& system) {
466 Result ret{};
467
468 uint32_t address{};
469 uint32_t cv_key{};
470 uint32_t tag{};
471 int64_t timeout_ns{};
472
473 address = Convert<uint32_t>(GetReg32(system, 0));
474 cv_key = Convert<uint32_t>(GetReg32(system, 1));
475 tag = Convert<uint32_t>(GetReg32(system, 2));
476 std::array<uint32_t, 2> timeout_ns_gather{};
477 timeout_ns_gather[0] = GetReg32(system, 3);
478 timeout_ns_gather[1] = GetReg32(system, 4);
479 timeout_ns = Convert<int64_t>(timeout_ns_gather);
480
481 ret = WaitProcessWideKeyAtomic64From32(system, address, cv_key, tag, timeout_ns);
482
483 SetReg32(system, 0, Convert<uint32_t>(ret));
484}
485
486static void SvcWrap_SignalProcessWideKey64From32(Core::System& system) {
487 uint32_t cv_key{};
488 int32_t count{};
489
490 cv_key = Convert<uint32_t>(GetReg32(system, 0));
491 count = Convert<int32_t>(GetReg32(system, 1));
492
493 SignalProcessWideKey64From32(system, cv_key, count);
494}
495
496static void SvcWrap_GetSystemTick64From32(Core::System& system) {
497 int64_t ret{};
498
499 ret = GetSystemTick64From32(system);
500
501 auto ret_scatter = Convert<std::array<uint32_t, 2>>(ret);
502 SetReg32(system, 0, ret_scatter[0]);
503 SetReg32(system, 1, ret_scatter[1]);
504}
505
506static void SvcWrap_ConnectToNamedPort64From32(Core::System& system) {
507 Result ret{};
508
509 Handle out_handle{};
510 uint32_t name{};
511
512 name = Convert<uint32_t>(GetReg32(system, 1));
513
514 ret = ConnectToNamedPort64From32(system, &out_handle, name);
515
516 SetReg32(system, 0, Convert<uint32_t>(ret));
517 SetReg32(system, 1, Convert<uint32_t>(out_handle));
518}
519
520static void SvcWrap_SendSyncRequest64From32(Core::System& system) {
521 Result ret{};
522
523 Handle session_handle{};
524
525 session_handle = Convert<Handle>(GetReg32(system, 0));
526
527 ret = SendSyncRequest64From32(system, session_handle);
528
529 SetReg32(system, 0, Convert<uint32_t>(ret));
530}
531
532static void SvcWrap_SendSyncRequestWithUserBuffer64From32(Core::System& system) {
533 Result ret{};
534
535 uint32_t message_buffer{};
536 uint32_t message_buffer_size{};
537 Handle session_handle{};
538
539 message_buffer = Convert<uint32_t>(GetReg32(system, 0));
540 message_buffer_size = Convert<uint32_t>(GetReg32(system, 1));
541 session_handle = Convert<Handle>(GetReg32(system, 2));
542
543 ret = SendSyncRequestWithUserBuffer64From32(system, message_buffer, message_buffer_size, session_handle);
544
545 SetReg32(system, 0, Convert<uint32_t>(ret));
546}
547
548static void SvcWrap_SendAsyncRequestWithUserBuffer64From32(Core::System& system) {
549 Result ret{};
550
551 Handle out_event_handle{};
552 uint32_t message_buffer{};
553 uint32_t message_buffer_size{};
554 Handle session_handle{};
555
556 message_buffer = Convert<uint32_t>(GetReg32(system, 1));
557 message_buffer_size = Convert<uint32_t>(GetReg32(system, 2));
558 session_handle = Convert<Handle>(GetReg32(system, 3));
559
560 ret = SendAsyncRequestWithUserBuffer64From32(system, &out_event_handle, message_buffer, message_buffer_size, session_handle);
561
562 SetReg32(system, 0, Convert<uint32_t>(ret));
563 SetReg32(system, 1, Convert<uint32_t>(out_event_handle));
564}
565
566static void SvcWrap_GetProcessId64From32(Core::System& system) {
567 Result ret{};
568
569 uint64_t out_process_id{};
570 Handle process_handle{};
571
572 process_handle = Convert<Handle>(GetReg32(system, 1));
573
574 ret = GetProcessId64From32(system, &out_process_id, process_handle);
575
576 SetReg32(system, 0, Convert<uint32_t>(ret));
577 auto out_process_id_scatter = Convert<std::array<uint32_t, 2>>(out_process_id);
578 SetReg32(system, 1, out_process_id_scatter[0]);
579 SetReg32(system, 2, out_process_id_scatter[1]);
580}
581
582static void SvcWrap_GetThreadId64From32(Core::System& system) {
583 Result ret{};
584
585 uint64_t out_thread_id{};
586 Handle thread_handle{};
587
588 thread_handle = Convert<Handle>(GetReg32(system, 1));
589
590 ret = GetThreadId64From32(system, &out_thread_id, thread_handle);
591
592 SetReg32(system, 0, Convert<uint32_t>(ret));
593 auto out_thread_id_scatter = Convert<std::array<uint32_t, 2>>(out_thread_id);
594 SetReg32(system, 1, out_thread_id_scatter[0]);
595 SetReg32(system, 2, out_thread_id_scatter[1]);
596}
597
598static void SvcWrap_Break64From32(Core::System& system) {
599 BreakReason break_reason{};
600 uint32_t arg{};
601 uint32_t size{};
602
603 break_reason = Convert<BreakReason>(GetReg32(system, 0));
604 arg = Convert<uint32_t>(GetReg32(system, 1));
605 size = Convert<uint32_t>(GetReg32(system, 2));
606
607 Break64From32(system, break_reason, arg, size);
608}
609
610static void SvcWrap_OutputDebugString64From32(Core::System& system) {
611 Result ret{};
612
613 uint32_t debug_str{};
614 uint32_t len{};
615
616 debug_str = Convert<uint32_t>(GetReg32(system, 0));
617 len = Convert<uint32_t>(GetReg32(system, 1));
618
619 ret = OutputDebugString64From32(system, debug_str, len);
620
621 SetReg32(system, 0, Convert<uint32_t>(ret));
622}
623
624static void SvcWrap_ReturnFromException64From32(Core::System& system) {
625 Result result{};
626
627 result = Convert<Result>(GetReg32(system, 0));
628
629 ReturnFromException64From32(system, result);
630}
631
632static void SvcWrap_GetInfo64From32(Core::System& system) {
633 Result ret{};
634
635 uint64_t out{};
636 InfoType info_type{};
637 Handle handle{};
638 uint64_t info_subtype{};
639
640 info_type = Convert<InfoType>(GetReg32(system, 1));
641 handle = Convert<Handle>(GetReg32(system, 2));
642 std::array<uint32_t, 2> info_subtype_gather{};
643 info_subtype_gather[0] = GetReg32(system, 0);
644 info_subtype_gather[1] = GetReg32(system, 3);
645 info_subtype = Convert<uint64_t>(info_subtype_gather);
646
647 ret = GetInfo64From32(system, &out, info_type, handle, info_subtype);
648
649 SetReg32(system, 0, Convert<uint32_t>(ret));
650 auto out_scatter = Convert<std::array<uint32_t, 2>>(out);
651 SetReg32(system, 1, out_scatter[0]);
652 SetReg32(system, 2, out_scatter[1]);
653}
654
655static void SvcWrap_FlushEntireDataCache64From32(Core::System& system) {
656 FlushEntireDataCache64From32(system);
657}
658
659static void SvcWrap_FlushDataCache64From32(Core::System& system) {
660 Result ret{};
661
662 uint32_t address{};
663 uint32_t size{};
664
665 address = Convert<uint32_t>(GetReg32(system, 0));
666 size = Convert<uint32_t>(GetReg32(system, 1));
667
668 ret = FlushDataCache64From32(system, address, size);
669
670 SetReg32(system, 0, Convert<uint32_t>(ret));
671}
672
673static void SvcWrap_MapPhysicalMemory64From32(Core::System& system) {
674 Result ret{};
675
676 uint32_t address{};
677 uint32_t size{};
678
679 address = Convert<uint32_t>(GetReg32(system, 0));
680 size = Convert<uint32_t>(GetReg32(system, 1));
681
682 ret = MapPhysicalMemory64From32(system, address, size);
683
684 SetReg32(system, 0, Convert<uint32_t>(ret));
685}
686
687static void SvcWrap_UnmapPhysicalMemory64From32(Core::System& system) {
688 Result ret{};
689
690 uint32_t address{};
691 uint32_t size{};
692
693 address = Convert<uint32_t>(GetReg32(system, 0));
694 size = Convert<uint32_t>(GetReg32(system, 1));
695
696 ret = UnmapPhysicalMemory64From32(system, address, size);
697
698 SetReg32(system, 0, Convert<uint32_t>(ret));
699}
700
701static void SvcWrap_GetDebugFutureThreadInfo64From32(Core::System& system) {
702 Result ret{};
703
704 ilp32::LastThreadContext out_context{};
705 uint64_t out_thread_id{};
706 Handle debug_handle{};
707 int64_t ns{};
708
709 debug_handle = Convert<Handle>(GetReg32(system, 2));
710 std::array<uint32_t, 2> ns_gather{};
711 ns_gather[0] = GetReg32(system, 0);
712 ns_gather[1] = GetReg32(system, 1);
713 ns = Convert<int64_t>(ns_gather);
714
715 ret = GetDebugFutureThreadInfo64From32(system, &out_context, &out_thread_id, debug_handle, ns);
716
717 SetReg32(system, 0, Convert<uint32_t>(ret));
718 auto out_context_scatter = Convert<std::array<uint32_t, 4>>(out_context);
719 SetReg32(system, 1, out_context_scatter[0]);
720 SetReg32(system, 2, out_context_scatter[1]);
721 SetReg32(system, 3, out_context_scatter[2]);
722 SetReg32(system, 4, out_context_scatter[3]);
723 auto out_thread_id_scatter = Convert<std::array<uint32_t, 2>>(out_thread_id);
724 SetReg32(system, 5, out_thread_id_scatter[0]);
725 SetReg32(system, 6, out_thread_id_scatter[1]);
726}
727
728static void SvcWrap_GetLastThreadInfo64From32(Core::System& system) {
729 Result ret{};
730
731 ilp32::LastThreadContext out_context{};
732 uintptr_t out_tls_address{};
733 uint32_t out_flags{};
734
735 ret = GetLastThreadInfo64From32(system, &out_context, &out_tls_address, &out_flags);
736
737 SetReg32(system, 0, Convert<uint32_t>(ret));
738 auto out_context_scatter = Convert<std::array<uint32_t, 4>>(out_context);
739 SetReg32(system, 1, out_context_scatter[0]);
740 SetReg32(system, 2, out_context_scatter[1]);
741 SetReg32(system, 3, out_context_scatter[2]);
742 SetReg32(system, 4, out_context_scatter[3]);
743 SetReg32(system, 5, Convert<uint32_t>(out_tls_address));
744 SetReg32(system, 6, Convert<uint32_t>(out_flags));
745}
746
747static void SvcWrap_GetResourceLimitLimitValue64From32(Core::System& system) {
748 Result ret{};
749
750 int64_t out_limit_value{};
751 Handle resource_limit_handle{};
752 LimitableResource which{};
753
754 resource_limit_handle = Convert<Handle>(GetReg32(system, 1));
755 which = Convert<LimitableResource>(GetReg32(system, 2));
756
757 ret = GetResourceLimitLimitValue64From32(system, &out_limit_value, resource_limit_handle, which);
758
759 SetReg32(system, 0, Convert<uint32_t>(ret));
760 auto out_limit_value_scatter = Convert<std::array<uint32_t, 2>>(out_limit_value);
761 SetReg32(system, 1, out_limit_value_scatter[0]);
762 SetReg32(system, 2, out_limit_value_scatter[1]);
763}
764
765static void SvcWrap_GetResourceLimitCurrentValue64From32(Core::System& system) {
766 Result ret{};
767
768 int64_t out_current_value{};
769 Handle resource_limit_handle{};
770 LimitableResource which{};
771
772 resource_limit_handle = Convert<Handle>(GetReg32(system, 1));
773 which = Convert<LimitableResource>(GetReg32(system, 2));
774
775 ret = GetResourceLimitCurrentValue64From32(system, &out_current_value, resource_limit_handle, which);
776
777 SetReg32(system, 0, Convert<uint32_t>(ret));
778 auto out_current_value_scatter = Convert<std::array<uint32_t, 2>>(out_current_value);
779 SetReg32(system, 1, out_current_value_scatter[0]);
780 SetReg32(system, 2, out_current_value_scatter[1]);
781}
782
783static void SvcWrap_SetThreadActivity64From32(Core::System& system) {
784 Result ret{};
785
786 Handle thread_handle{};
787 ThreadActivity thread_activity{};
788
789 thread_handle = Convert<Handle>(GetReg32(system, 0));
790 thread_activity = Convert<ThreadActivity>(GetReg32(system, 1));
791
792 ret = SetThreadActivity64From32(system, thread_handle, thread_activity);
793
794 SetReg32(system, 0, Convert<uint32_t>(ret));
795}
796
797static void SvcWrap_GetThreadContext364From32(Core::System& system) {
798 Result ret{};
799
800 uint32_t out_context{};
801 Handle thread_handle{};
802
803 out_context = Convert<uint32_t>(GetReg32(system, 0));
804 thread_handle = Convert<Handle>(GetReg32(system, 1));
805
806 ret = GetThreadContext364From32(system, out_context, thread_handle);
807
808 SetReg32(system, 0, Convert<uint32_t>(ret));
809}
810
811static void SvcWrap_WaitForAddress64From32(Core::System& system) {
812 Result ret{};
813
814 uint32_t address{};
815 ArbitrationType arb_type{};
816 int32_t value{};
817 int64_t timeout_ns{};
818
819 address = Convert<uint32_t>(GetReg32(system, 0));
820 arb_type = Convert<ArbitrationType>(GetReg32(system, 1));
821 value = Convert<int32_t>(GetReg32(system, 2));
822 std::array<uint32_t, 2> timeout_ns_gather{};
823 timeout_ns_gather[0] = GetReg32(system, 3);
824 timeout_ns_gather[1] = GetReg32(system, 4);
825 timeout_ns = Convert<int64_t>(timeout_ns_gather);
826
827 ret = WaitForAddress64From32(system, address, arb_type, value, timeout_ns);
828
829 SetReg32(system, 0, Convert<uint32_t>(ret));
830}
831
832static void SvcWrap_SignalToAddress64From32(Core::System& system) {
833 Result ret{};
834
835 uint32_t address{};
836 SignalType signal_type{};
837 int32_t value{};
838 int32_t count{};
839
840 address = Convert<uint32_t>(GetReg32(system, 0));
841 signal_type = Convert<SignalType>(GetReg32(system, 1));
842 value = Convert<int32_t>(GetReg32(system, 2));
843 count = Convert<int32_t>(GetReg32(system, 3));
844
845 ret = SignalToAddress64From32(system, address, signal_type, value, count);
846
847 SetReg32(system, 0, Convert<uint32_t>(ret));
848}
849
850static void SvcWrap_SynchronizePreemptionState64From32(Core::System& system) {
851 SynchronizePreemptionState64From32(system);
852}
853
854static void SvcWrap_GetResourceLimitPeakValue64From32(Core::System& system) {
855 Result ret{};
856
857 int64_t out_peak_value{};
858 Handle resource_limit_handle{};
859 LimitableResource which{};
860
861 resource_limit_handle = Convert<Handle>(GetReg32(system, 1));
862 which = Convert<LimitableResource>(GetReg32(system, 2));
863
864 ret = GetResourceLimitPeakValue64From32(system, &out_peak_value, resource_limit_handle, which);
865
866 SetReg32(system, 0, Convert<uint32_t>(ret));
867 auto out_peak_value_scatter = Convert<std::array<uint32_t, 2>>(out_peak_value);
868 SetReg32(system, 1, out_peak_value_scatter[0]);
869 SetReg32(system, 2, out_peak_value_scatter[1]);
870}
871
872static void SvcWrap_CreateIoPool64From32(Core::System& system) {
873 Result ret{};
874
875 Handle out_handle{};
876 IoPoolType which{};
877
878 which = Convert<IoPoolType>(GetReg32(system, 1));
879
880 ret = CreateIoPool64From32(system, &out_handle, which);
881
882 SetReg32(system, 0, Convert<uint32_t>(ret));
883 SetReg32(system, 1, Convert<uint32_t>(out_handle));
884}
885
886static void SvcWrap_CreateIoRegion64From32(Core::System& system) {
887 Result ret{};
888
889 Handle out_handle{};
890 Handle io_pool{};
891 uint64_t physical_address{};
892 uint32_t size{};
893 MemoryMapping mapping{};
894 MemoryPermission perm{};
895
896 io_pool = Convert<Handle>(GetReg32(system, 1));
897 std::array<uint32_t, 2> physical_address_gather{};
898 physical_address_gather[0] = GetReg32(system, 2);
899 physical_address_gather[1] = GetReg32(system, 3);
900 physical_address = Convert<uint64_t>(physical_address_gather);
901 size = Convert<uint32_t>(GetReg32(system, 0));
902 mapping = Convert<MemoryMapping>(GetReg32(system, 4));
903 perm = Convert<MemoryPermission>(GetReg32(system, 5));
904
905 ret = CreateIoRegion64From32(system, &out_handle, io_pool, physical_address, size, mapping, perm);
906
907 SetReg32(system, 0, Convert<uint32_t>(ret));
908 SetReg32(system, 1, Convert<uint32_t>(out_handle));
909}
910
911static void SvcWrap_KernelDebug64From32(Core::System& system) {
912 KernelDebugType kern_debug_type{};
913 uint64_t arg0{};
914 uint64_t arg1{};
915 uint64_t arg2{};
916
917 kern_debug_type = Convert<KernelDebugType>(GetReg32(system, 0));
918 std::array<uint32_t, 2> arg0_gather{};
919 arg0_gather[0] = GetReg32(system, 2);
920 arg0_gather[1] = GetReg32(system, 3);
921 arg0 = Convert<uint64_t>(arg0_gather);
922 std::array<uint32_t, 2> arg1_gather{};
923 arg1_gather[0] = GetReg32(system, 1);
924 arg1_gather[1] = GetReg32(system, 4);
925 arg1 = Convert<uint64_t>(arg1_gather);
926 std::array<uint32_t, 2> arg2_gather{};
927 arg2_gather[0] = GetReg32(system, 5);
928 arg2_gather[1] = GetReg32(system, 6);
929 arg2 = Convert<uint64_t>(arg2_gather);
930
931 KernelDebug64From32(system, kern_debug_type, arg0, arg1, arg2);
932}
933
934static void SvcWrap_ChangeKernelTraceState64From32(Core::System& system) {
935 KernelTraceState kern_trace_state{};
936
937 kern_trace_state = Convert<KernelTraceState>(GetReg32(system, 0));
938
939 ChangeKernelTraceState64From32(system, kern_trace_state);
940}
941
942static void SvcWrap_CreateSession64From32(Core::System& system) {
943 Result ret{};
944
945 Handle out_server_session_handle{};
946 Handle out_client_session_handle{};
947 bool is_light{};
948 uint32_t name{};
949
950 is_light = Convert<bool>(GetReg32(system, 2));
951 name = Convert<uint32_t>(GetReg32(system, 3));
952
953 ret = CreateSession64From32(system, &out_server_session_handle, &out_client_session_handle, is_light, name);
954
955 SetReg32(system, 0, Convert<uint32_t>(ret));
956 SetReg32(system, 1, Convert<uint32_t>(out_server_session_handle));
957 SetReg32(system, 2, Convert<uint32_t>(out_client_session_handle));
958}
959
960static void SvcWrap_AcceptSession64From32(Core::System& system) {
961 Result ret{};
962
963 Handle out_handle{};
964 Handle port{};
965
966 port = Convert<Handle>(GetReg32(system, 1));
967
968 ret = AcceptSession64From32(system, &out_handle, port);
969
970 SetReg32(system, 0, Convert<uint32_t>(ret));
971 SetReg32(system, 1, Convert<uint32_t>(out_handle));
972}
973
974static void SvcWrap_ReplyAndReceive64From32(Core::System& system) {
975 Result ret{};
976
977 int32_t out_index{};
978 uint32_t handles{};
979 int32_t num_handles{};
980 Handle reply_target{};
981 int64_t timeout_ns{};
982
983 handles = Convert<uint32_t>(GetReg32(system, 1));
984 num_handles = Convert<int32_t>(GetReg32(system, 2));
985 reply_target = Convert<Handle>(GetReg32(system, 3));
986 std::array<uint32_t, 2> timeout_ns_gather{};
987 timeout_ns_gather[0] = GetReg32(system, 0);
988 timeout_ns_gather[1] = GetReg32(system, 4);
989 timeout_ns = Convert<int64_t>(timeout_ns_gather);
990
991 ret = ReplyAndReceive64From32(system, &out_index, handles, num_handles, reply_target, timeout_ns);
992
993 SetReg32(system, 0, Convert<uint32_t>(ret));
994 SetReg32(system, 1, Convert<uint32_t>(out_index));
995}
996
997static void SvcWrap_ReplyAndReceiveWithUserBuffer64From32(Core::System& system) {
998 Result ret{};
999
1000 int32_t out_index{};
1001 uint32_t message_buffer{};
1002 uint32_t message_buffer_size{};
1003 uint32_t handles{};
1004 int32_t num_handles{};
1005 Handle reply_target{};
1006 int64_t timeout_ns{};
1007
1008 message_buffer = Convert<uint32_t>(GetReg32(system, 1));
1009 message_buffer_size = Convert<uint32_t>(GetReg32(system, 2));
1010 handles = Convert<uint32_t>(GetReg32(system, 3));
1011 num_handles = Convert<int32_t>(GetReg32(system, 0));
1012 reply_target = Convert<Handle>(GetReg32(system, 4));
1013 std::array<uint32_t, 2> timeout_ns_gather{};
1014 timeout_ns_gather[0] = GetReg32(system, 5);
1015 timeout_ns_gather[1] = GetReg32(system, 6);
1016 timeout_ns = Convert<int64_t>(timeout_ns_gather);
1017
1018 ret = ReplyAndReceiveWithUserBuffer64From32(system, &out_index, message_buffer, message_buffer_size, handles, num_handles, reply_target, timeout_ns);
1019
1020 SetReg32(system, 0, Convert<uint32_t>(ret));
1021 SetReg32(system, 1, Convert<uint32_t>(out_index));
1022}
1023
1024static void SvcWrap_CreateEvent64From32(Core::System& system) {
1025 Result ret{};
1026
1027 Handle out_write_handle{};
1028 Handle out_read_handle{};
1029
1030 ret = CreateEvent64From32(system, &out_write_handle, &out_read_handle);
1031
1032 SetReg32(system, 0, Convert<uint32_t>(ret));
1033 SetReg32(system, 1, Convert<uint32_t>(out_write_handle));
1034 SetReg32(system, 2, Convert<uint32_t>(out_read_handle));
1035}
1036
1037static void SvcWrap_MapIoRegion64From32(Core::System& system) {
1038 Result ret{};
1039
1040 Handle io_region{};
1041 uint32_t address{};
1042 uint32_t size{};
1043 MemoryPermission perm{};
1044
1045 io_region = Convert<Handle>(GetReg32(system, 0));
1046 address = Convert<uint32_t>(GetReg32(system, 1));
1047 size = Convert<uint32_t>(GetReg32(system, 2));
1048 perm = Convert<MemoryPermission>(GetReg32(system, 3));
1049
1050 ret = MapIoRegion64From32(system, io_region, address, size, perm);
1051
1052 SetReg32(system, 0, Convert<uint32_t>(ret));
1053}
1054
1055static void SvcWrap_UnmapIoRegion64From32(Core::System& system) {
1056 Result ret{};
1057
1058 Handle io_region{};
1059 uint32_t address{};
1060 uint32_t size{};
1061
1062 io_region = Convert<Handle>(GetReg32(system, 0));
1063 address = Convert<uint32_t>(GetReg32(system, 1));
1064 size = Convert<uint32_t>(GetReg32(system, 2));
1065
1066 ret = UnmapIoRegion64From32(system, io_region, address, size);
1067
1068 SetReg32(system, 0, Convert<uint32_t>(ret));
1069}
1070
1071static void SvcWrap_MapPhysicalMemoryUnsafe64From32(Core::System& system) {
1072 Result ret{};
1073
1074 uint32_t address{};
1075 uint32_t size{};
1076
1077 address = Convert<uint32_t>(GetReg32(system, 0));
1078 size = Convert<uint32_t>(GetReg32(system, 1));
1079
1080 ret = MapPhysicalMemoryUnsafe64From32(system, address, size);
1081
1082 SetReg32(system, 0, Convert<uint32_t>(ret));
1083}
1084
1085static void SvcWrap_UnmapPhysicalMemoryUnsafe64From32(Core::System& system) {
1086 Result ret{};
1087
1088 uint32_t address{};
1089 uint32_t size{};
1090
1091 address = Convert<uint32_t>(GetReg32(system, 0));
1092 size = Convert<uint32_t>(GetReg32(system, 1));
1093
1094 ret = UnmapPhysicalMemoryUnsafe64From32(system, address, size);
1095
1096 SetReg32(system, 0, Convert<uint32_t>(ret));
1097}
1098
1099static void SvcWrap_SetUnsafeLimit64From32(Core::System& system) {
1100 Result ret{};
1101
1102 uint32_t limit{};
1103
1104 limit = Convert<uint32_t>(GetReg32(system, 0));
1105
1106 ret = SetUnsafeLimit64From32(system, limit);
1107
1108 SetReg32(system, 0, Convert<uint32_t>(ret));
1109}
1110
1111static void SvcWrap_CreateCodeMemory64From32(Core::System& system) {
1112 Result ret{};
1113
1114 Handle out_handle{};
1115 uint32_t address{};
1116 uint32_t size{};
1117
1118 address = Convert<uint32_t>(GetReg32(system, 1));
1119 size = Convert<uint32_t>(GetReg32(system, 2));
1120
1121 ret = CreateCodeMemory64From32(system, &out_handle, address, size);
1122
1123 SetReg32(system, 0, Convert<uint32_t>(ret));
1124 SetReg32(system, 1, Convert<uint32_t>(out_handle));
1125}
1126
1127static void SvcWrap_ControlCodeMemory64From32(Core::System& system) {
1128 Result ret{};
1129
1130 Handle code_memory_handle{};
1131 CodeMemoryOperation operation{};
1132 uint64_t address{};
1133 uint64_t size{};
1134 MemoryPermission perm{};
1135
1136 code_memory_handle = Convert<Handle>(GetReg32(system, 0));
1137 operation = Convert<CodeMemoryOperation>(GetReg32(system, 1));
1138 std::array<uint32_t, 2> address_gather{};
1139 address_gather[0] = GetReg32(system, 2);
1140 address_gather[1] = GetReg32(system, 3);
1141 address = Convert<uint64_t>(address_gather);
1142 std::array<uint32_t, 2> size_gather{};
1143 size_gather[0] = GetReg32(system, 4);
1144 size_gather[1] = GetReg32(system, 5);
1145 size = Convert<uint64_t>(size_gather);
1146 perm = Convert<MemoryPermission>(GetReg32(system, 6));
1147
1148 ret = ControlCodeMemory64From32(system, code_memory_handle, operation, address, size, perm);
1149
1150 SetReg32(system, 0, Convert<uint32_t>(ret));
1151}
1152
1153static void SvcWrap_SleepSystem64From32(Core::System& system) {
1154 SleepSystem64From32(system);
1155}
1156
1157static void SvcWrap_ReadWriteRegister64From32(Core::System& system) {
1158 Result ret{};
1159
1160 uint32_t out_value{};
1161 uint64_t address{};
1162 uint32_t mask{};
1163 uint32_t value{};
1164
1165 std::array<uint32_t, 2> address_gather{};
1166 address_gather[0] = GetReg32(system, 2);
1167 address_gather[1] = GetReg32(system, 3);
1168 address = Convert<uint64_t>(address_gather);
1169 mask = Convert<uint32_t>(GetReg32(system, 0));
1170 value = Convert<uint32_t>(GetReg32(system, 1));
1171
1172 ret = ReadWriteRegister64From32(system, &out_value, address, mask, value);
1173
1174 SetReg32(system, 0, Convert<uint32_t>(ret));
1175 SetReg32(system, 1, Convert<uint32_t>(out_value));
1176}
1177
1178static void SvcWrap_SetProcessActivity64From32(Core::System& system) {
1179 Result ret{};
1180
1181 Handle process_handle{};
1182 ProcessActivity process_activity{};
1183
1184 process_handle = Convert<Handle>(GetReg32(system, 0));
1185 process_activity = Convert<ProcessActivity>(GetReg32(system, 1));
1186
1187 ret = SetProcessActivity64From32(system, process_handle, process_activity);
1188
1189 SetReg32(system, 0, Convert<uint32_t>(ret));
1190}
1191
1192static void SvcWrap_CreateSharedMemory64From32(Core::System& system) {
1193 Result ret{};
1194
1195 Handle out_handle{};
1196 uint32_t size{};
1197 MemoryPermission owner_perm{};
1198 MemoryPermission remote_perm{};
1199
1200 size = Convert<uint32_t>(GetReg32(system, 1));
1201 owner_perm = Convert<MemoryPermission>(GetReg32(system, 2));
1202 remote_perm = Convert<MemoryPermission>(GetReg32(system, 3));
1203
1204 ret = CreateSharedMemory64From32(system, &out_handle, size, owner_perm, remote_perm);
1205
1206 SetReg32(system, 0, Convert<uint32_t>(ret));
1207 SetReg32(system, 1, Convert<uint32_t>(out_handle));
1208}
1209
1210static void SvcWrap_MapTransferMemory64From32(Core::System& system) {
1211 Result ret{};
1212
1213 Handle trmem_handle{};
1214 uint32_t address{};
1215 uint32_t size{};
1216 MemoryPermission owner_perm{};
1217
1218 trmem_handle = Convert<Handle>(GetReg32(system, 0));
1219 address = Convert<uint32_t>(GetReg32(system, 1));
1220 size = Convert<uint32_t>(GetReg32(system, 2));
1221 owner_perm = Convert<MemoryPermission>(GetReg32(system, 3));
1222
1223 ret = MapTransferMemory64From32(system, trmem_handle, address, size, owner_perm);
1224
1225 SetReg32(system, 0, Convert<uint32_t>(ret));
1226}
1227
1228static void SvcWrap_UnmapTransferMemory64From32(Core::System& system) {
1229 Result ret{};
1230
1231 Handle trmem_handle{};
1232 uint32_t address{};
1233 uint32_t size{};
1234
1235 trmem_handle = Convert<Handle>(GetReg32(system, 0));
1236 address = Convert<uint32_t>(GetReg32(system, 1));
1237 size = Convert<uint32_t>(GetReg32(system, 2));
1238
1239 ret = UnmapTransferMemory64From32(system, trmem_handle, address, size);
1240
1241 SetReg32(system, 0, Convert<uint32_t>(ret));
1242}
1243
1244static void SvcWrap_CreateInterruptEvent64From32(Core::System& system) {
1245 Result ret{};
1246
1247 Handle out_read_handle{};
1248 int32_t interrupt_id{};
1249 InterruptType interrupt_type{};
1250
1251 interrupt_id = Convert<int32_t>(GetReg32(system, 1));
1252 interrupt_type = Convert<InterruptType>(GetReg32(system, 2));
1253
1254 ret = CreateInterruptEvent64From32(system, &out_read_handle, interrupt_id, interrupt_type);
1255
1256 SetReg32(system, 0, Convert<uint32_t>(ret));
1257 SetReg32(system, 1, Convert<uint32_t>(out_read_handle));
1258}
1259
1260static void SvcWrap_QueryPhysicalAddress64From32(Core::System& system) {
1261 Result ret{};
1262
1263 ilp32::PhysicalMemoryInfo out_info{};
1264 uint32_t address{};
1265
1266 address = Convert<uint32_t>(GetReg32(system, 1));
1267
1268 ret = QueryPhysicalAddress64From32(system, &out_info, address);
1269
1270 SetReg32(system, 0, Convert<uint32_t>(ret));
1271 auto out_info_scatter = Convert<std::array<uint32_t, 4>>(out_info);
1272 SetReg32(system, 1, out_info_scatter[0]);
1273 SetReg32(system, 2, out_info_scatter[1]);
1274 SetReg32(system, 3, out_info_scatter[2]);
1275 SetReg32(system, 4, out_info_scatter[3]);
1276}
1277
1278static void SvcWrap_QueryIoMapping64From32(Core::System& system) {
1279 Result ret{};
1280
1281 uintptr_t out_address{};
1282 uintptr_t out_size{};
1283 uint64_t physical_address{};
1284 uint32_t size{};
1285
1286 std::array<uint32_t, 2> physical_address_gather{};
1287 physical_address_gather[0] = GetReg32(system, 2);
1288 physical_address_gather[1] = GetReg32(system, 3);
1289 physical_address = Convert<uint64_t>(physical_address_gather);
1290 size = Convert<uint32_t>(GetReg32(system, 0));
1291
1292 ret = QueryIoMapping64From32(system, &out_address, &out_size, physical_address, size);
1293
1294 SetReg32(system, 0, Convert<uint32_t>(ret));
1295 SetReg32(system, 1, Convert<uint32_t>(out_address));
1296 SetReg32(system, 2, Convert<uint32_t>(out_size));
1297}
1298
1299static void SvcWrap_CreateDeviceAddressSpace64From32(Core::System& system) {
1300 Result ret{};
1301
1302 Handle out_handle{};
1303 uint64_t das_address{};
1304 uint64_t das_size{};
1305
1306 std::array<uint32_t, 2> das_address_gather{};
1307 das_address_gather[0] = GetReg32(system, 2);
1308 das_address_gather[1] = GetReg32(system, 3);
1309 das_address = Convert<uint64_t>(das_address_gather);
1310 std::array<uint32_t, 2> das_size_gather{};
1311 das_size_gather[0] = GetReg32(system, 0);
1312 das_size_gather[1] = GetReg32(system, 1);
1313 das_size = Convert<uint64_t>(das_size_gather);
1314
1315 ret = CreateDeviceAddressSpace64From32(system, &out_handle, das_address, das_size);
1316
1317 SetReg32(system, 0, Convert<uint32_t>(ret));
1318 SetReg32(system, 1, Convert<uint32_t>(out_handle));
1319}
1320
1321static void SvcWrap_AttachDeviceAddressSpace64From32(Core::System& system) {
1322 Result ret{};
1323
1324 DeviceName device_name{};
1325 Handle das_handle{};
1326
1327 device_name = Convert<DeviceName>(GetReg32(system, 0));
1328 das_handle = Convert<Handle>(GetReg32(system, 1));
1329
1330 ret = AttachDeviceAddressSpace64From32(system, device_name, das_handle);
1331
1332 SetReg32(system, 0, Convert<uint32_t>(ret));
1333}
1334
1335static void SvcWrap_DetachDeviceAddressSpace64From32(Core::System& system) {
1336 Result ret{};
1337
1338 DeviceName device_name{};
1339 Handle das_handle{};
1340
1341 device_name = Convert<DeviceName>(GetReg32(system, 0));
1342 das_handle = Convert<Handle>(GetReg32(system, 1));
1343
1344 ret = DetachDeviceAddressSpace64From32(system, device_name, das_handle);
1345
1346 SetReg32(system, 0, Convert<uint32_t>(ret));
1347}
1348
1349static void SvcWrap_MapDeviceAddressSpaceByForce64From32(Core::System& system) {
1350 Result ret{};
1351
1352 Handle das_handle{};
1353 Handle process_handle{};
1354 uint64_t process_address{};
1355 uint32_t size{};
1356 uint64_t device_address{};
1357 uint32_t option{};
1358
1359 das_handle = Convert<Handle>(GetReg32(system, 0));
1360 process_handle = Convert<Handle>(GetReg32(system, 1));
1361 std::array<uint32_t, 2> process_address_gather{};
1362 process_address_gather[0] = GetReg32(system, 2);
1363 process_address_gather[1] = GetReg32(system, 3);
1364 process_address = Convert<uint64_t>(process_address_gather);
1365 size = Convert<uint32_t>(GetReg32(system, 4));
1366 std::array<uint32_t, 2> device_address_gather{};
1367 device_address_gather[0] = GetReg32(system, 5);
1368 device_address_gather[1] = GetReg32(system, 6);
1369 device_address = Convert<uint64_t>(device_address_gather);
1370 option = Convert<uint32_t>(GetReg32(system, 7));
1371
1372 ret = MapDeviceAddressSpaceByForce64From32(system, das_handle, process_handle, process_address, size, device_address, option);
1373
1374 SetReg32(system, 0, Convert<uint32_t>(ret));
1375}
1376
1377static void SvcWrap_MapDeviceAddressSpaceAligned64From32(Core::System& system) {
1378 Result ret{};
1379
1380 Handle das_handle{};
1381 Handle process_handle{};
1382 uint64_t process_address{};
1383 uint32_t size{};
1384 uint64_t device_address{};
1385 uint32_t option{};
1386
1387 das_handle = Convert<Handle>(GetReg32(system, 0));
1388 process_handle = Convert<Handle>(GetReg32(system, 1));
1389 std::array<uint32_t, 2> process_address_gather{};
1390 process_address_gather[0] = GetReg32(system, 2);
1391 process_address_gather[1] = GetReg32(system, 3);
1392 process_address = Convert<uint64_t>(process_address_gather);
1393 size = Convert<uint32_t>(GetReg32(system, 4));
1394 std::array<uint32_t, 2> device_address_gather{};
1395 device_address_gather[0] = GetReg32(system, 5);
1396 device_address_gather[1] = GetReg32(system, 6);
1397 device_address = Convert<uint64_t>(device_address_gather);
1398 option = Convert<uint32_t>(GetReg32(system, 7));
1399
1400 ret = MapDeviceAddressSpaceAligned64From32(system, das_handle, process_handle, process_address, size, device_address, option);
1401
1402 SetReg32(system, 0, Convert<uint32_t>(ret));
1403}
1404
1405static void SvcWrap_UnmapDeviceAddressSpace64From32(Core::System& system) {
1406 Result ret{};
1407
1408 Handle das_handle{};
1409 Handle process_handle{};
1410 uint64_t process_address{};
1411 uint32_t size{};
1412 uint64_t device_address{};
1413
1414 das_handle = Convert<Handle>(GetReg32(system, 0));
1415 process_handle = Convert<Handle>(GetReg32(system, 1));
1416 std::array<uint32_t, 2> process_address_gather{};
1417 process_address_gather[0] = GetReg32(system, 2);
1418 process_address_gather[1] = GetReg32(system, 3);
1419 process_address = Convert<uint64_t>(process_address_gather);
1420 size = Convert<uint32_t>(GetReg32(system, 4));
1421 std::array<uint32_t, 2> device_address_gather{};
1422 device_address_gather[0] = GetReg32(system, 5);
1423 device_address_gather[1] = GetReg32(system, 6);
1424 device_address = Convert<uint64_t>(device_address_gather);
1425
1426 ret = UnmapDeviceAddressSpace64From32(system, das_handle, process_handle, process_address, size, device_address);
1427
1428 SetReg32(system, 0, Convert<uint32_t>(ret));
1429}
1430
1431static void SvcWrap_InvalidateProcessDataCache64From32(Core::System& system) {
1432 Result ret{};
1433
1434 Handle process_handle{};
1435 uint64_t address{};
1436 uint64_t size{};
1437
1438 process_handle = Convert<Handle>(GetReg32(system, 0));
1439 std::array<uint32_t, 2> address_gather{};
1440 address_gather[0] = GetReg32(system, 2);
1441 address_gather[1] = GetReg32(system, 3);
1442 address = Convert<uint64_t>(address_gather);
1443 std::array<uint32_t, 2> size_gather{};
1444 size_gather[0] = GetReg32(system, 1);
1445 size_gather[1] = GetReg32(system, 4);
1446 size = Convert<uint64_t>(size_gather);
1447
1448 ret = InvalidateProcessDataCache64From32(system, process_handle, address, size);
1449
1450 SetReg32(system, 0, Convert<uint32_t>(ret));
1451}
1452
1453static void SvcWrap_StoreProcessDataCache64From32(Core::System& system) {
1454 Result ret{};
1455
1456 Handle process_handle{};
1457 uint64_t address{};
1458 uint64_t size{};
1459
1460 process_handle = Convert<Handle>(GetReg32(system, 0));
1461 std::array<uint32_t, 2> address_gather{};
1462 address_gather[0] = GetReg32(system, 2);
1463 address_gather[1] = GetReg32(system, 3);
1464 address = Convert<uint64_t>(address_gather);
1465 std::array<uint32_t, 2> size_gather{};
1466 size_gather[0] = GetReg32(system, 1);
1467 size_gather[1] = GetReg32(system, 4);
1468 size = Convert<uint64_t>(size_gather);
1469
1470 ret = StoreProcessDataCache64From32(system, process_handle, address, size);
1471
1472 SetReg32(system, 0, Convert<uint32_t>(ret));
1473}
1474
1475static void SvcWrap_FlushProcessDataCache64From32(Core::System& system) {
1476 Result ret{};
1477
1478 Handle process_handle{};
1479 uint64_t address{};
1480 uint64_t size{};
1481
1482 process_handle = Convert<Handle>(GetReg32(system, 0));
1483 std::array<uint32_t, 2> address_gather{};
1484 address_gather[0] = GetReg32(system, 2);
1485 address_gather[1] = GetReg32(system, 3);
1486 address = Convert<uint64_t>(address_gather);
1487 std::array<uint32_t, 2> size_gather{};
1488 size_gather[0] = GetReg32(system, 1);
1489 size_gather[1] = GetReg32(system, 4);
1490 size = Convert<uint64_t>(size_gather);
1491
1492 ret = FlushProcessDataCache64From32(system, process_handle, address, size);
1493
1494 SetReg32(system, 0, Convert<uint32_t>(ret));
1495}
1496
1497static void SvcWrap_DebugActiveProcess64From32(Core::System& system) {
1498 Result ret{};
1499
1500 Handle out_handle{};
1501 uint64_t process_id{};
1502
1503 std::array<uint32_t, 2> process_id_gather{};
1504 process_id_gather[0] = GetReg32(system, 2);
1505 process_id_gather[1] = GetReg32(system, 3);
1506 process_id = Convert<uint64_t>(process_id_gather);
1507
1508 ret = DebugActiveProcess64From32(system, &out_handle, process_id);
1509
1510 SetReg32(system, 0, Convert<uint32_t>(ret));
1511 SetReg32(system, 1, Convert<uint32_t>(out_handle));
1512}
1513
1514static void SvcWrap_BreakDebugProcess64From32(Core::System& system) {
1515 Result ret{};
1516
1517 Handle debug_handle{};
1518
1519 debug_handle = Convert<Handle>(GetReg32(system, 0));
1520
1521 ret = BreakDebugProcess64From32(system, debug_handle);
1522
1523 SetReg32(system, 0, Convert<uint32_t>(ret));
1524}
1525
1526static void SvcWrap_TerminateDebugProcess64From32(Core::System& system) {
1527 Result ret{};
1528
1529 Handle debug_handle{};
1530
1531 debug_handle = Convert<Handle>(GetReg32(system, 0));
1532
1533 ret = TerminateDebugProcess64From32(system, debug_handle);
1534
1535 SetReg32(system, 0, Convert<uint32_t>(ret));
1536}
1537
1538static void SvcWrap_GetDebugEvent64From32(Core::System& system) {
1539 Result ret{};
1540
1541 uint32_t out_info{};
1542 Handle debug_handle{};
1543
1544 out_info = Convert<uint32_t>(GetReg32(system, 0));
1545 debug_handle = Convert<Handle>(GetReg32(system, 1));
1546
1547 ret = GetDebugEvent64From32(system, out_info, debug_handle);
1548
1549 SetReg32(system, 0, Convert<uint32_t>(ret));
1550}
1551
1552static void SvcWrap_ContinueDebugEvent64From32(Core::System& system) {
1553 Result ret{};
1554
1555 Handle debug_handle{};
1556 uint32_t flags{};
1557 uint32_t thread_ids{};
1558 int32_t num_thread_ids{};
1559
1560 debug_handle = Convert<Handle>(GetReg32(system, 0));
1561 flags = Convert<uint32_t>(GetReg32(system, 1));
1562 thread_ids = Convert<uint32_t>(GetReg32(system, 2));
1563 num_thread_ids = Convert<int32_t>(GetReg32(system, 3));
1564
1565 ret = ContinueDebugEvent64From32(system, debug_handle, flags, thread_ids, num_thread_ids);
1566
1567 SetReg32(system, 0, Convert<uint32_t>(ret));
1568}
1569
1570static void SvcWrap_GetProcessList64From32(Core::System& system) {
1571 Result ret{};
1572
1573 int32_t out_num_processes{};
1574 uint32_t out_process_ids{};
1575 int32_t max_out_count{};
1576
1577 out_process_ids = Convert<uint32_t>(GetReg32(system, 1));
1578 max_out_count = Convert<int32_t>(GetReg32(system, 2));
1579
1580 ret = GetProcessList64From32(system, &out_num_processes, out_process_ids, max_out_count);
1581
1582 SetReg32(system, 0, Convert<uint32_t>(ret));
1583 SetReg32(system, 1, Convert<uint32_t>(out_num_processes));
1584}
1585
1586static void SvcWrap_GetThreadList64From32(Core::System& system) {
1587 Result ret{};
1588
1589 int32_t out_num_threads{};
1590 uint32_t out_thread_ids{};
1591 int32_t max_out_count{};
1592 Handle debug_handle{};
1593
1594 out_thread_ids = Convert<uint32_t>(GetReg32(system, 1));
1595 max_out_count = Convert<int32_t>(GetReg32(system, 2));
1596 debug_handle = Convert<Handle>(GetReg32(system, 3));
1597
1598 ret = GetThreadList64From32(system, &out_num_threads, out_thread_ids, max_out_count, debug_handle);
1599
1600 SetReg32(system, 0, Convert<uint32_t>(ret));
1601 SetReg32(system, 1, Convert<uint32_t>(out_num_threads));
1602}
1603
1604static void SvcWrap_GetDebugThreadContext64From32(Core::System& system) {
1605 Result ret{};
1606
1607 uint32_t out_context{};
1608 Handle debug_handle{};
1609 uint64_t thread_id{};
1610 uint32_t context_flags{};
1611
1612 out_context = Convert<uint32_t>(GetReg32(system, 0));
1613 debug_handle = Convert<Handle>(GetReg32(system, 1));
1614 std::array<uint32_t, 2> thread_id_gather{};
1615 thread_id_gather[0] = GetReg32(system, 2);
1616 thread_id_gather[1] = GetReg32(system, 3);
1617 thread_id = Convert<uint64_t>(thread_id_gather);
1618 context_flags = Convert<uint32_t>(GetReg32(system, 4));
1619
1620 ret = GetDebugThreadContext64From32(system, out_context, debug_handle, thread_id, context_flags);
1621
1622 SetReg32(system, 0, Convert<uint32_t>(ret));
1623}
1624
1625static void SvcWrap_SetDebugThreadContext64From32(Core::System& system) {
1626 Result ret{};
1627
1628 Handle debug_handle{};
1629 uint64_t thread_id{};
1630 uint32_t context{};
1631 uint32_t context_flags{};
1632
1633 debug_handle = Convert<Handle>(GetReg32(system, 0));
1634 std::array<uint32_t, 2> thread_id_gather{};
1635 thread_id_gather[0] = GetReg32(system, 2);
1636 thread_id_gather[1] = GetReg32(system, 3);
1637 thread_id = Convert<uint64_t>(thread_id_gather);
1638 context = Convert<uint32_t>(GetReg32(system, 1));
1639 context_flags = Convert<uint32_t>(GetReg32(system, 4));
1640
1641 ret = SetDebugThreadContext64From32(system, debug_handle, thread_id, context, context_flags);
1642
1643 SetReg32(system, 0, Convert<uint32_t>(ret));
1644}
1645
1646static void SvcWrap_QueryDebugProcessMemory64From32(Core::System& system) {
1647 Result ret{};
1648
1649 PageInfo out_page_info{};
1650 uint32_t out_memory_info{};
1651 Handle process_handle{};
1652 uint32_t address{};
1653
1654 out_memory_info = Convert<uint32_t>(GetReg32(system, 0));
1655 process_handle = Convert<Handle>(GetReg32(system, 2));
1656 address = Convert<uint32_t>(GetReg32(system, 3));
1657
1658 ret = QueryDebugProcessMemory64From32(system, out_memory_info, &out_page_info, process_handle, address);
1659
1660 SetReg32(system, 0, Convert<uint32_t>(ret));
1661 SetReg32(system, 1, Convert<uint32_t>(out_page_info));
1662}
1663
1664static void SvcWrap_ReadDebugProcessMemory64From32(Core::System& system) {
1665 Result ret{};
1666
1667 uint32_t buffer{};
1668 Handle debug_handle{};
1669 uint32_t address{};
1670 uint32_t size{};
1671
1672 buffer = Convert<uint32_t>(GetReg32(system, 0));
1673 debug_handle = Convert<Handle>(GetReg32(system, 1));
1674 address = Convert<uint32_t>(GetReg32(system, 2));
1675 size = Convert<uint32_t>(GetReg32(system, 3));
1676
1677 ret = ReadDebugProcessMemory64From32(system, buffer, debug_handle, address, size);
1678
1679 SetReg32(system, 0, Convert<uint32_t>(ret));
1680}
1681
1682static void SvcWrap_WriteDebugProcessMemory64From32(Core::System& system) {
1683 Result ret{};
1684
1685 Handle debug_handle{};
1686 uint32_t buffer{};
1687 uint32_t address{};
1688 uint32_t size{};
1689
1690 debug_handle = Convert<Handle>(GetReg32(system, 0));
1691 buffer = Convert<uint32_t>(GetReg32(system, 1));
1692 address = Convert<uint32_t>(GetReg32(system, 2));
1693 size = Convert<uint32_t>(GetReg32(system, 3));
1694
1695 ret = WriteDebugProcessMemory64From32(system, debug_handle, buffer, address, size);
1696
1697 SetReg32(system, 0, Convert<uint32_t>(ret));
1698}
1699
1700static void SvcWrap_SetHardwareBreakPoint64From32(Core::System& system) {
1701 Result ret{};
1702
1703 HardwareBreakPointRegisterName name{};
1704 uint64_t flags{};
1705 uint64_t value{};
1706
1707 name = Convert<HardwareBreakPointRegisterName>(GetReg32(system, 0));
1708 std::array<uint32_t, 2> flags_gather{};
1709 flags_gather[0] = GetReg32(system, 2);
1710 flags_gather[1] = GetReg32(system, 3);
1711 flags = Convert<uint64_t>(flags_gather);
1712 std::array<uint32_t, 2> value_gather{};
1713 value_gather[0] = GetReg32(system, 1);
1714 value_gather[1] = GetReg32(system, 4);
1715 value = Convert<uint64_t>(value_gather);
1716
1717 ret = SetHardwareBreakPoint64From32(system, name, flags, value);
1718
1719 SetReg32(system, 0, Convert<uint32_t>(ret));
1720}
1721
1722static void SvcWrap_GetDebugThreadParam64From32(Core::System& system) {
1723 Result ret{};
1724
1725 uint64_t out_64{};
1726 uint32_t out_32{};
1727 Handle debug_handle{};
1728 uint64_t thread_id{};
1729 DebugThreadParam param{};
1730
1731 debug_handle = Convert<Handle>(GetReg32(system, 2));
1732 std::array<uint32_t, 2> thread_id_gather{};
1733 thread_id_gather[0] = GetReg32(system, 0);
1734 thread_id_gather[1] = GetReg32(system, 1);
1735 thread_id = Convert<uint64_t>(thread_id_gather);
1736 param = Convert<DebugThreadParam>(GetReg32(system, 3));
1737
1738 ret = GetDebugThreadParam64From32(system, &out_64, &out_32, debug_handle, thread_id, param);
1739
1740 SetReg32(system, 0, Convert<uint32_t>(ret));
1741 auto out_64_scatter = Convert<std::array<uint32_t, 2>>(out_64);
1742 SetReg32(system, 1, out_64_scatter[0]);
1743 SetReg32(system, 2, out_64_scatter[1]);
1744 SetReg32(system, 3, Convert<uint32_t>(out_32));
1745}
1746
1747static void SvcWrap_GetSystemInfo64From32(Core::System& system) {
1748 Result ret{};
1749
1750 uint64_t out{};
1751 SystemInfoType info_type{};
1752 Handle handle{};
1753 uint64_t info_subtype{};
1754
1755 info_type = Convert<SystemInfoType>(GetReg32(system, 1));
1756 handle = Convert<Handle>(GetReg32(system, 2));
1757 std::array<uint32_t, 2> info_subtype_gather{};
1758 info_subtype_gather[0] = GetReg32(system, 0);
1759 info_subtype_gather[1] = GetReg32(system, 3);
1760 info_subtype = Convert<uint64_t>(info_subtype_gather);
1761
1762 ret = GetSystemInfo64From32(system, &out, info_type, handle, info_subtype);
1763
1764 SetReg32(system, 0, Convert<uint32_t>(ret));
1765 auto out_scatter = Convert<std::array<uint32_t, 2>>(out);
1766 SetReg32(system, 1, out_scatter[0]);
1767 SetReg32(system, 2, out_scatter[1]);
1768}
1769
1770static void SvcWrap_CreatePort64From32(Core::System& system) {
1771 Result ret{};
1772
1773 Handle out_server_handle{};
1774 Handle out_client_handle{};
1775 int32_t max_sessions{};
1776 bool is_light{};
1777 uint32_t name{};
1778
1779 max_sessions = Convert<int32_t>(GetReg32(system, 2));
1780 is_light = Convert<bool>(GetReg32(system, 3));
1781 name = Convert<uint32_t>(GetReg32(system, 0));
1782
1783 ret = CreatePort64From32(system, &out_server_handle, &out_client_handle, max_sessions, is_light, name);
1784
1785 SetReg32(system, 0, Convert<uint32_t>(ret));
1786 SetReg32(system, 1, Convert<uint32_t>(out_server_handle));
1787 SetReg32(system, 2, Convert<uint32_t>(out_client_handle));
1788}
1789
1790static void SvcWrap_ManageNamedPort64From32(Core::System& system) {
1791 Result ret{};
1792
1793 Handle out_server_handle{};
1794 uint32_t name{};
1795 int32_t max_sessions{};
1796
1797 name = Convert<uint32_t>(GetReg32(system, 1));
1798 max_sessions = Convert<int32_t>(GetReg32(system, 2));
1799
1800 ret = ManageNamedPort64From32(system, &out_server_handle, name, max_sessions);
1801
1802 SetReg32(system, 0, Convert<uint32_t>(ret));
1803 SetReg32(system, 1, Convert<uint32_t>(out_server_handle));
1804}
1805
1806static void SvcWrap_ConnectToPort64From32(Core::System& system) {
1807 Result ret{};
1808
1809 Handle out_handle{};
1810 Handle port{};
1811
1812 port = Convert<Handle>(GetReg32(system, 1));
1813
1814 ret = ConnectToPort64From32(system, &out_handle, port);
1815
1816 SetReg32(system, 0, Convert<uint32_t>(ret));
1817 SetReg32(system, 1, Convert<uint32_t>(out_handle));
1818}
1819
1820static void SvcWrap_SetProcessMemoryPermission64From32(Core::System& system) {
1821 Result ret{};
1822
1823 Handle process_handle{};
1824 uint64_t address{};
1825 uint64_t size{};
1826 MemoryPermission perm{};
1827
1828 process_handle = Convert<Handle>(GetReg32(system, 0));
1829 std::array<uint32_t, 2> address_gather{};
1830 address_gather[0] = GetReg32(system, 2);
1831 address_gather[1] = GetReg32(system, 3);
1832 address = Convert<uint64_t>(address_gather);
1833 std::array<uint32_t, 2> size_gather{};
1834 size_gather[0] = GetReg32(system, 1);
1835 size_gather[1] = GetReg32(system, 4);
1836 size = Convert<uint64_t>(size_gather);
1837 perm = Convert<MemoryPermission>(GetReg32(system, 5));
1838
1839 ret = SetProcessMemoryPermission64From32(system, process_handle, address, size, perm);
1840
1841 SetReg32(system, 0, Convert<uint32_t>(ret));
1842}
1843
1844static void SvcWrap_MapProcessMemory64From32(Core::System& system) {
1845 Result ret{};
1846
1847 uint32_t dst_address{};
1848 Handle process_handle{};
1849 uint64_t src_address{};
1850 uint32_t size{};
1851
1852 dst_address = Convert<uint32_t>(GetReg32(system, 0));
1853 process_handle = Convert<Handle>(GetReg32(system, 1));
1854 std::array<uint32_t, 2> src_address_gather{};
1855 src_address_gather[0] = GetReg32(system, 2);
1856 src_address_gather[1] = GetReg32(system, 3);
1857 src_address = Convert<uint64_t>(src_address_gather);
1858 size = Convert<uint32_t>(GetReg32(system, 4));
1859
1860 ret = MapProcessMemory64From32(system, dst_address, process_handle, src_address, size);
1861
1862 SetReg32(system, 0, Convert<uint32_t>(ret));
1863}
1864
1865static void SvcWrap_UnmapProcessMemory64From32(Core::System& system) {
1866 Result ret{};
1867
1868 uint32_t dst_address{};
1869 Handle process_handle{};
1870 uint64_t src_address{};
1871 uint32_t size{};
1872
1873 dst_address = Convert<uint32_t>(GetReg32(system, 0));
1874 process_handle = Convert<Handle>(GetReg32(system, 1));
1875 std::array<uint32_t, 2> src_address_gather{};
1876 src_address_gather[0] = GetReg32(system, 2);
1877 src_address_gather[1] = GetReg32(system, 3);
1878 src_address = Convert<uint64_t>(src_address_gather);
1879 size = Convert<uint32_t>(GetReg32(system, 4));
1880
1881 ret = UnmapProcessMemory64From32(system, dst_address, process_handle, src_address, size);
1882
1883 SetReg32(system, 0, Convert<uint32_t>(ret));
1884}
1885
1886static void SvcWrap_QueryProcessMemory64From32(Core::System& system) {
1887 Result ret{};
1888
1889 PageInfo out_page_info{};
1890 uint32_t out_memory_info{};
1891 Handle process_handle{};
1892 uint64_t address{};
1893
1894 out_memory_info = Convert<uint32_t>(GetReg32(system, 0));
1895 process_handle = Convert<Handle>(GetReg32(system, 2));
1896 std::array<uint32_t, 2> address_gather{};
1897 address_gather[0] = GetReg32(system, 1);
1898 address_gather[1] = GetReg32(system, 3);
1899 address = Convert<uint64_t>(address_gather);
1900
1901 ret = QueryProcessMemory64From32(system, out_memory_info, &out_page_info, process_handle, address);
1902
1903 SetReg32(system, 0, Convert<uint32_t>(ret));
1904 SetReg32(system, 1, Convert<uint32_t>(out_page_info));
1905}
1906
1907static void SvcWrap_MapProcessCodeMemory64From32(Core::System& system) {
1908 Result ret{};
1909
1910 Handle process_handle{};
1911 uint64_t dst_address{};
1912 uint64_t src_address{};
1913 uint64_t size{};
1914
1915 process_handle = Convert<Handle>(GetReg32(system, 0));
1916 std::array<uint32_t, 2> dst_address_gather{};
1917 dst_address_gather[0] = GetReg32(system, 2);
1918 dst_address_gather[1] = GetReg32(system, 3);
1919 dst_address = Convert<uint64_t>(dst_address_gather);
1920 std::array<uint32_t, 2> src_address_gather{};
1921 src_address_gather[0] = GetReg32(system, 1);
1922 src_address_gather[1] = GetReg32(system, 4);
1923 src_address = Convert<uint64_t>(src_address_gather);
1924 std::array<uint32_t, 2> size_gather{};
1925 size_gather[0] = GetReg32(system, 5);
1926 size_gather[1] = GetReg32(system, 6);
1927 size = Convert<uint64_t>(size_gather);
1928
1929 ret = MapProcessCodeMemory64From32(system, process_handle, dst_address, src_address, size);
1930
1931 SetReg32(system, 0, Convert<uint32_t>(ret));
1932}
1933
1934static void SvcWrap_UnmapProcessCodeMemory64From32(Core::System& system) {
1935 Result ret{};
1936
1937 Handle process_handle{};
1938 uint64_t dst_address{};
1939 uint64_t src_address{};
1940 uint64_t size{};
1941
1942 process_handle = Convert<Handle>(GetReg32(system, 0));
1943 std::array<uint32_t, 2> dst_address_gather{};
1944 dst_address_gather[0] = GetReg32(system, 2);
1945 dst_address_gather[1] = GetReg32(system, 3);
1946 dst_address = Convert<uint64_t>(dst_address_gather);
1947 std::array<uint32_t, 2> src_address_gather{};
1948 src_address_gather[0] = GetReg32(system, 1);
1949 src_address_gather[1] = GetReg32(system, 4);
1950 src_address = Convert<uint64_t>(src_address_gather);
1951 std::array<uint32_t, 2> size_gather{};
1952 size_gather[0] = GetReg32(system, 5);
1953 size_gather[1] = GetReg32(system, 6);
1954 size = Convert<uint64_t>(size_gather);
1955
1956 ret = UnmapProcessCodeMemory64From32(system, process_handle, dst_address, src_address, size);
1957
1958 SetReg32(system, 0, Convert<uint32_t>(ret));
1959}
1960
1961static void SvcWrap_CreateProcess64From32(Core::System& system) {
1962 Result ret{};
1963
1964 Handle out_handle{};
1965 uint32_t parameters{};
1966 uint32_t caps{};
1967 int32_t num_caps{};
1968
1969 parameters = Convert<uint32_t>(GetReg32(system, 1));
1970 caps = Convert<uint32_t>(GetReg32(system, 2));
1971 num_caps = Convert<int32_t>(GetReg32(system, 3));
1972
1973 ret = CreateProcess64From32(system, &out_handle, parameters, caps, num_caps);
1974
1975 SetReg32(system, 0, Convert<uint32_t>(ret));
1976 SetReg32(system, 1, Convert<uint32_t>(out_handle));
1977}
1978
1979static void SvcWrap_StartProcess64From32(Core::System& system) {
1980 Result ret{};
1981
1982 Handle process_handle{};
1983 int32_t priority{};
1984 int32_t core_id{};
1985 uint64_t main_thread_stack_size{};
1986
1987 process_handle = Convert<Handle>(GetReg32(system, 0));
1988 priority = Convert<int32_t>(GetReg32(system, 1));
1989 core_id = Convert<int32_t>(GetReg32(system, 2));
1990 std::array<uint32_t, 2> main_thread_stack_size_gather{};
1991 main_thread_stack_size_gather[0] = GetReg32(system, 3);
1992 main_thread_stack_size_gather[1] = GetReg32(system, 4);
1993 main_thread_stack_size = Convert<uint64_t>(main_thread_stack_size_gather);
1994
1995 ret = StartProcess64From32(system, process_handle, priority, core_id, main_thread_stack_size);
1996
1997 SetReg32(system, 0, Convert<uint32_t>(ret));
1998}
1999
2000static void SvcWrap_TerminateProcess64From32(Core::System& system) {
2001 Result ret{};
2002
2003 Handle process_handle{};
2004
2005 process_handle = Convert<Handle>(GetReg32(system, 0));
2006
2007 ret = TerminateProcess64From32(system, process_handle);
2008
2009 SetReg32(system, 0, Convert<uint32_t>(ret));
2010}
2011
2012static void SvcWrap_GetProcessInfo64From32(Core::System& system) {
2013 Result ret{};
2014
2015 int64_t out_info{};
2016 Handle process_handle{};
2017 ProcessInfoType info_type{};
2018
2019 process_handle = Convert<Handle>(GetReg32(system, 1));
2020 info_type = Convert<ProcessInfoType>(GetReg32(system, 2));
2021
2022 ret = GetProcessInfo64From32(system, &out_info, process_handle, info_type);
2023
2024 SetReg32(system, 0, Convert<uint32_t>(ret));
2025 auto out_info_scatter = Convert<std::array<uint32_t, 2>>(out_info);
2026 SetReg32(system, 1, out_info_scatter[0]);
2027 SetReg32(system, 2, out_info_scatter[1]);
2028}
2029
2030static void SvcWrap_CreateResourceLimit64From32(Core::System& system) {
2031 Result ret{};
2032
2033 Handle out_handle{};
2034
2035 ret = CreateResourceLimit64From32(system, &out_handle);
2036
2037 SetReg32(system, 0, Convert<uint32_t>(ret));
2038 SetReg32(system, 1, Convert<uint32_t>(out_handle));
2039}
2040
2041static void SvcWrap_SetResourceLimitLimitValue64From32(Core::System& system) {
2042 Result ret{};
2043
2044 Handle resource_limit_handle{};
2045 LimitableResource which{};
2046 int64_t limit_value{};
2047
2048 resource_limit_handle = Convert<Handle>(GetReg32(system, 0));
2049 which = Convert<LimitableResource>(GetReg32(system, 1));
2050 std::array<uint32_t, 2> limit_value_gather{};
2051 limit_value_gather[0] = GetReg32(system, 2);
2052 limit_value_gather[1] = GetReg32(system, 3);
2053 limit_value = Convert<int64_t>(limit_value_gather);
2054
2055 ret = SetResourceLimitLimitValue64From32(system, resource_limit_handle, which, limit_value);
2056
2057 SetReg32(system, 0, Convert<uint32_t>(ret));
2058}
2059
2060static void SvcWrap_MapInsecureMemory64From32(Core::System& system) {
2061 Result ret{};
2062
2063 uint32_t address{};
2064 uint32_t size{};
2065
2066 address = Convert<uint32_t>(GetReg32(system, 0));
2067 size = Convert<uint32_t>(GetReg32(system, 1));
2068
2069 ret = MapInsecureMemory64From32(system, address, size);
2070
2071 SetReg32(system, 0, Convert<uint32_t>(ret));
2072}
2073
2074static void SvcWrap_UnmapInsecureMemory64From32(Core::System& system) {
2075 Result ret{};
2076
2077 uint32_t address{};
2078 uint32_t size{};
2079
2080 address = Convert<uint32_t>(GetReg32(system, 0));
2081 size = Convert<uint32_t>(GetReg32(system, 1));
2082
2083 ret = UnmapInsecureMemory64From32(system, address, size);
2084
2085 SetReg32(system, 0, Convert<uint32_t>(ret));
2086}
2087
2088static void SvcWrap_SetHeapSize64(Core::System& system) {
2089 Result ret{};
2090
2091 uintptr_t out_address{};
2092 uint64_t size{};
2093
2094 size = Convert<uint64_t>(GetReg64(system, 1));
2095
2096 ret = SetHeapSize64(system, &out_address, size);
2097
2098 SetReg64(system, 0, Convert<uint64_t>(ret));
2099 SetReg64(system, 1, Convert<uint64_t>(out_address));
2100}
2101
2102static void SvcWrap_SetMemoryPermission64(Core::System& system) {
2103 Result ret{};
2104
2105 uint64_t address{};
2106 uint64_t size{};
2107 MemoryPermission perm{};
2108
2109 address = Convert<uint64_t>(GetReg64(system, 0));
2110 size = Convert<uint64_t>(GetReg64(system, 1));
2111 perm = Convert<MemoryPermission>(GetReg64(system, 2));
2112
2113 ret = SetMemoryPermission64(system, address, size, perm);
2114
2115 SetReg64(system, 0, Convert<uint64_t>(ret));
2116}
2117
2118static void SvcWrap_SetMemoryAttribute64(Core::System& system) {
2119 Result ret{};
2120
2121 uint64_t address{};
2122 uint64_t size{};
2123 uint32_t mask{};
2124 uint32_t attr{};
2125
2126 address = Convert<uint64_t>(GetReg64(system, 0));
2127 size = Convert<uint64_t>(GetReg64(system, 1));
2128 mask = Convert<uint32_t>(GetReg64(system, 2));
2129 attr = Convert<uint32_t>(GetReg64(system, 3));
2130
2131 ret = SetMemoryAttribute64(system, address, size, mask, attr);
2132
2133 SetReg64(system, 0, Convert<uint64_t>(ret));
2134}
2135
2136static void SvcWrap_MapMemory64(Core::System& system) {
2137 Result ret{};
2138
2139 uint64_t dst_address{};
2140 uint64_t src_address{};
2141 uint64_t size{};
2142
2143 dst_address = Convert<uint64_t>(GetReg64(system, 0));
2144 src_address = Convert<uint64_t>(GetReg64(system, 1));
2145 size = Convert<uint64_t>(GetReg64(system, 2));
2146
2147 ret = MapMemory64(system, dst_address, src_address, size);
2148
2149 SetReg64(system, 0, Convert<uint64_t>(ret));
2150}
2151
2152static void SvcWrap_UnmapMemory64(Core::System& system) {
2153 Result ret{};
2154
2155 uint64_t dst_address{};
2156 uint64_t src_address{};
2157 uint64_t size{};
2158
2159 dst_address = Convert<uint64_t>(GetReg64(system, 0));
2160 src_address = Convert<uint64_t>(GetReg64(system, 1));
2161 size = Convert<uint64_t>(GetReg64(system, 2));
2162
2163 ret = UnmapMemory64(system, dst_address, src_address, size);
2164
2165 SetReg64(system, 0, Convert<uint64_t>(ret));
2166}
2167
2168static void SvcWrap_QueryMemory64(Core::System& system) {
2169 Result ret{};
2170
2171 PageInfo out_page_info{};
2172 uint64_t out_memory_info{};
2173 uint64_t address{};
2174
2175 out_memory_info = Convert<uint64_t>(GetReg64(system, 0));
2176 address = Convert<uint64_t>(GetReg64(system, 2));
2177
2178 ret = QueryMemory64(system, out_memory_info, &out_page_info, address);
2179
2180 SetReg64(system, 0, Convert<uint64_t>(ret));
2181 SetReg64(system, 1, Convert<uint64_t>(out_page_info));
2182}
2183
2184static void SvcWrap_ExitProcess64(Core::System& system) {
2185 ExitProcess64(system);
2186}
2187
2188static void SvcWrap_CreateThread64(Core::System& system) {
2189 Result ret{};
2190
2191 Handle out_handle{};
2192 uint64_t func{};
2193 uint64_t arg{};
2194 uint64_t stack_bottom{};
2195 int32_t priority{};
2196 int32_t core_id{};
2197
2198 func = Convert<uint64_t>(GetReg64(system, 1));
2199 arg = Convert<uint64_t>(GetReg64(system, 2));
2200 stack_bottom = Convert<uint64_t>(GetReg64(system, 3));
2201 priority = Convert<int32_t>(GetReg64(system, 4));
2202 core_id = Convert<int32_t>(GetReg64(system, 5));
2203
2204 ret = CreateThread64(system, &out_handle, func, arg, stack_bottom, priority, core_id);
2205
2206 SetReg64(system, 0, Convert<uint64_t>(ret));
2207 SetReg64(system, 1, Convert<uint64_t>(out_handle));
2208}
2209
2210static void SvcWrap_StartThread64(Core::System& system) {
2211 Result ret{};
2212
2213 Handle thread_handle{};
2214
2215 thread_handle = Convert<Handle>(GetReg64(system, 0));
2216
2217 ret = StartThread64(system, thread_handle);
2218
2219 SetReg64(system, 0, Convert<uint64_t>(ret));
2220}
2221
2222static void SvcWrap_ExitThread64(Core::System& system) {
2223 ExitThread64(system);
2224}
2225
2226static void SvcWrap_SleepThread64(Core::System& system) {
2227 int64_t ns{};
2228
2229 ns = Convert<int64_t>(GetReg64(system, 0));
2230
2231 SleepThread64(system, ns);
2232}
2233
2234static void SvcWrap_GetThreadPriority64(Core::System& system) {
2235 Result ret{};
2236
2237 int32_t out_priority{};
2238 Handle thread_handle{};
2239
2240 thread_handle = Convert<Handle>(GetReg64(system, 1));
2241
2242 ret = GetThreadPriority64(system, &out_priority, thread_handle);
2243
2244 SetReg64(system, 0, Convert<uint64_t>(ret));
2245 SetReg64(system, 1, Convert<uint64_t>(out_priority));
2246}
2247
2248static void SvcWrap_SetThreadPriority64(Core::System& system) {
2249 Result ret{};
2250
2251 Handle thread_handle{};
2252 int32_t priority{};
2253
2254 thread_handle = Convert<Handle>(GetReg64(system, 0));
2255 priority = Convert<int32_t>(GetReg64(system, 1));
2256
2257 ret = SetThreadPriority64(system, thread_handle, priority);
2258
2259 SetReg64(system, 0, Convert<uint64_t>(ret));
2260}
2261
2262static void SvcWrap_GetThreadCoreMask64(Core::System& system) {
2263 Result ret{};
2264
2265 int32_t out_core_id{};
2266 uint64_t out_affinity_mask{};
2267 Handle thread_handle{};
2268
2269 thread_handle = Convert<Handle>(GetReg64(system, 2));
2270
2271 ret = GetThreadCoreMask64(system, &out_core_id, &out_affinity_mask, thread_handle);
2272
2273 SetReg64(system, 0, Convert<uint64_t>(ret));
2274 SetReg64(system, 1, Convert<uint64_t>(out_core_id));
2275 SetReg64(system, 2, Convert<uint64_t>(out_affinity_mask));
2276}
2277
2278static void SvcWrap_SetThreadCoreMask64(Core::System& system) {
2279 Result ret{};
2280
2281 Handle thread_handle{};
2282 int32_t core_id{};
2283 uint64_t affinity_mask{};
2284
2285 thread_handle = Convert<Handle>(GetReg64(system, 0));
2286 core_id = Convert<int32_t>(GetReg64(system, 1));
2287 affinity_mask = Convert<uint64_t>(GetReg64(system, 2));
2288
2289 ret = SetThreadCoreMask64(system, thread_handle, core_id, affinity_mask);
2290
2291 SetReg64(system, 0, Convert<uint64_t>(ret));
2292}
2293
2294static void SvcWrap_GetCurrentProcessorNumber64(Core::System& system) {
2295 int32_t ret{};
2296
2297 ret = GetCurrentProcessorNumber64(system);
2298
2299 SetReg64(system, 0, Convert<uint64_t>(ret));
2300}
2301
2302static void SvcWrap_SignalEvent64(Core::System& system) {
2303 Result ret{};
2304
2305 Handle event_handle{};
2306
2307 event_handle = Convert<Handle>(GetReg64(system, 0));
2308
2309 ret = SignalEvent64(system, event_handle);
2310
2311 SetReg64(system, 0, Convert<uint64_t>(ret));
2312}
2313
2314static void SvcWrap_ClearEvent64(Core::System& system) {
2315 Result ret{};
2316
2317 Handle event_handle{};
2318
2319 event_handle = Convert<Handle>(GetReg64(system, 0));
2320
2321 ret = ClearEvent64(system, event_handle);
2322
2323 SetReg64(system, 0, Convert<uint64_t>(ret));
2324}
2325
2326static void SvcWrap_MapSharedMemory64(Core::System& system) {
2327 Result ret{};
2328
2329 Handle shmem_handle{};
2330 uint64_t address{};
2331 uint64_t size{};
2332 MemoryPermission map_perm{};
2333
2334 shmem_handle = Convert<Handle>(GetReg64(system, 0));
2335 address = Convert<uint64_t>(GetReg64(system, 1));
2336 size = Convert<uint64_t>(GetReg64(system, 2));
2337 map_perm = Convert<MemoryPermission>(GetReg64(system, 3));
2338
2339 ret = MapSharedMemory64(system, shmem_handle, address, size, map_perm);
2340
2341 SetReg64(system, 0, Convert<uint64_t>(ret));
2342}
2343
2344static void SvcWrap_UnmapSharedMemory64(Core::System& system) {
2345 Result ret{};
2346
2347 Handle shmem_handle{};
2348 uint64_t address{};
2349 uint64_t size{};
2350
2351 shmem_handle = Convert<Handle>(GetReg64(system, 0));
2352 address = Convert<uint64_t>(GetReg64(system, 1));
2353 size = Convert<uint64_t>(GetReg64(system, 2));
2354
2355 ret = UnmapSharedMemory64(system, shmem_handle, address, size);
2356
2357 SetReg64(system, 0, Convert<uint64_t>(ret));
2358}
2359
2360static void SvcWrap_CreateTransferMemory64(Core::System& system) {
2361 Result ret{};
2362
2363 Handle out_handle{};
2364 uint64_t address{};
2365 uint64_t size{};
2366 MemoryPermission map_perm{};
2367
2368 address = Convert<uint64_t>(GetReg64(system, 1));
2369 size = Convert<uint64_t>(GetReg64(system, 2));
2370 map_perm = Convert<MemoryPermission>(GetReg64(system, 3));
2371
2372 ret = CreateTransferMemory64(system, &out_handle, address, size, map_perm);
2373
2374 SetReg64(system, 0, Convert<uint64_t>(ret));
2375 SetReg64(system, 1, Convert<uint64_t>(out_handle));
2376}
2377
2378static void SvcWrap_CloseHandle64(Core::System& system) {
2379 Result ret{};
2380
2381 Handle handle{};
2382
2383 handle = Convert<Handle>(GetReg64(system, 0));
2384
2385 ret = CloseHandle64(system, handle);
2386
2387 SetReg64(system, 0, Convert<uint64_t>(ret));
2388}
2389
2390static void SvcWrap_ResetSignal64(Core::System& system) {
2391 Result ret{};
2392
2393 Handle handle{};
2394
2395 handle = Convert<Handle>(GetReg64(system, 0));
2396
2397 ret = ResetSignal64(system, handle);
2398
2399 SetReg64(system, 0, Convert<uint64_t>(ret));
2400}
2401
2402static void SvcWrap_WaitSynchronization64(Core::System& system) {
2403 Result ret{};
2404
2405 int32_t out_index{};
2406 uint64_t handles{};
2407 int32_t num_handles{};
2408 int64_t timeout_ns{};
2409
2410 handles = Convert<uint64_t>(GetReg64(system, 1));
2411 num_handles = Convert<int32_t>(GetReg64(system, 2));
2412 timeout_ns = Convert<int64_t>(GetReg64(system, 3));
2413
2414 ret = WaitSynchronization64(system, &out_index, handles, num_handles, timeout_ns);
2415
2416 SetReg64(system, 0, Convert<uint64_t>(ret));
2417 SetReg64(system, 1, Convert<uint64_t>(out_index));
2418}
2419
2420static void SvcWrap_CancelSynchronization64(Core::System& system) {
2421 Result ret{};
2422
2423 Handle handle{};
2424
2425 handle = Convert<Handle>(GetReg64(system, 0));
2426
2427 ret = CancelSynchronization64(system, handle);
2428
2429 SetReg64(system, 0, Convert<uint64_t>(ret));
2430}
2431
2432static void SvcWrap_ArbitrateLock64(Core::System& system) {
2433 Result ret{};
2434
2435 Handle thread_handle{};
2436 uint64_t address{};
2437 uint32_t tag{};
2438
2439 thread_handle = Convert<Handle>(GetReg64(system, 0));
2440 address = Convert<uint64_t>(GetReg64(system, 1));
2441 tag = Convert<uint32_t>(GetReg64(system, 2));
2442
2443 ret = ArbitrateLock64(system, thread_handle, address, tag);
2444
2445 SetReg64(system, 0, Convert<uint64_t>(ret));
2446}
2447
2448static void SvcWrap_ArbitrateUnlock64(Core::System& system) {
2449 Result ret{};
2450
2451 uint64_t address{};
2452
2453 address = Convert<uint64_t>(GetReg64(system, 0));
2454
2455 ret = ArbitrateUnlock64(system, address);
2456
2457 SetReg64(system, 0, Convert<uint64_t>(ret));
2458}
2459
2460static void SvcWrap_WaitProcessWideKeyAtomic64(Core::System& system) {
2461 Result ret{};
2462
2463 uint64_t address{};
2464 uint64_t cv_key{};
2465 uint32_t tag{};
2466 int64_t timeout_ns{};
2467
2468 address = Convert<uint64_t>(GetReg64(system, 0));
2469 cv_key = Convert<uint64_t>(GetReg64(system, 1));
2470 tag = Convert<uint32_t>(GetReg64(system, 2));
2471 timeout_ns = Convert<int64_t>(GetReg64(system, 3));
2472
2473 ret = WaitProcessWideKeyAtomic64(system, address, cv_key, tag, timeout_ns);
2474
2475 SetReg64(system, 0, Convert<uint64_t>(ret));
2476}
2477
2478static void SvcWrap_SignalProcessWideKey64(Core::System& system) {
2479 uint64_t cv_key{};
2480 int32_t count{};
2481
2482 cv_key = Convert<uint64_t>(GetReg64(system, 0));
2483 count = Convert<int32_t>(GetReg64(system, 1));
2484
2485 SignalProcessWideKey64(system, cv_key, count);
2486}
2487
2488static void SvcWrap_GetSystemTick64(Core::System& system) {
2489 int64_t ret{};
2490
2491 ret = GetSystemTick64(system);
2492
2493 SetReg64(system, 0, Convert<uint64_t>(ret));
2494}
2495
2496static void SvcWrap_ConnectToNamedPort64(Core::System& system) {
2497 Result ret{};
2498
2499 Handle out_handle{};
2500 uint64_t name{};
2501
2502 name = Convert<uint64_t>(GetReg64(system, 1));
2503
2504 ret = ConnectToNamedPort64(system, &out_handle, name);
2505
2506 SetReg64(system, 0, Convert<uint64_t>(ret));
2507 SetReg64(system, 1, Convert<uint64_t>(out_handle));
2508}
2509
2510static void SvcWrap_SendSyncRequest64(Core::System& system) {
2511 Result ret{};
2512
2513 Handle session_handle{};
2514
2515 session_handle = Convert<Handle>(GetReg64(system, 0));
2516
2517 ret = SendSyncRequest64(system, session_handle);
2518
2519 SetReg64(system, 0, Convert<uint64_t>(ret));
2520}
2521
2522static void SvcWrap_SendSyncRequestWithUserBuffer64(Core::System& system) {
2523 Result ret{};
2524
2525 uint64_t message_buffer{};
2526 uint64_t message_buffer_size{};
2527 Handle session_handle{};
2528
2529 message_buffer = Convert<uint64_t>(GetReg64(system, 0));
2530 message_buffer_size = Convert<uint64_t>(GetReg64(system, 1));
2531 session_handle = Convert<Handle>(GetReg64(system, 2));
2532
2533 ret = SendSyncRequestWithUserBuffer64(system, message_buffer, message_buffer_size, session_handle);
2534
2535 SetReg64(system, 0, Convert<uint64_t>(ret));
2536}
2537
2538static void SvcWrap_SendAsyncRequestWithUserBuffer64(Core::System& system) {
2539 Result ret{};
2540
2541 Handle out_event_handle{};
2542 uint64_t message_buffer{};
2543 uint64_t message_buffer_size{};
2544 Handle session_handle{};
2545
2546 message_buffer = Convert<uint64_t>(GetReg64(system, 1));
2547 message_buffer_size = Convert<uint64_t>(GetReg64(system, 2));
2548 session_handle = Convert<Handle>(GetReg64(system, 3));
2549
2550 ret = SendAsyncRequestWithUserBuffer64(system, &out_event_handle, message_buffer, message_buffer_size, session_handle);
2551
2552 SetReg64(system, 0, Convert<uint64_t>(ret));
2553 SetReg64(system, 1, Convert<uint64_t>(out_event_handle));
2554}
2555
2556static void SvcWrap_GetProcessId64(Core::System& system) {
2557 Result ret{};
2558
2559 uint64_t out_process_id{};
2560 Handle process_handle{};
2561
2562 process_handle = Convert<Handle>(GetReg64(system, 1));
2563
2564 ret = GetProcessId64(system, &out_process_id, process_handle);
2565
2566 SetReg64(system, 0, Convert<uint64_t>(ret));
2567 SetReg64(system, 1, Convert<uint64_t>(out_process_id));
2568}
2569
2570static void SvcWrap_GetThreadId64(Core::System& system) {
2571 Result ret{};
2572
2573 uint64_t out_thread_id{};
2574 Handle thread_handle{};
2575
2576 thread_handle = Convert<Handle>(GetReg64(system, 1));
2577
2578 ret = GetThreadId64(system, &out_thread_id, thread_handle);
2579
2580 SetReg64(system, 0, Convert<uint64_t>(ret));
2581 SetReg64(system, 1, Convert<uint64_t>(out_thread_id));
2582}
2583
2584static void SvcWrap_Break64(Core::System& system) {
2585 BreakReason break_reason{};
2586 uint64_t arg{};
2587 uint64_t size{};
2588
2589 break_reason = Convert<BreakReason>(GetReg64(system, 0));
2590 arg = Convert<uint64_t>(GetReg64(system, 1));
2591 size = Convert<uint64_t>(GetReg64(system, 2));
2592
2593 Break64(system, break_reason, arg, size);
2594}
2595
2596static void SvcWrap_OutputDebugString64(Core::System& system) {
2597 Result ret{};
2598
2599 uint64_t debug_str{};
2600 uint64_t len{};
2601
2602 debug_str = Convert<uint64_t>(GetReg64(system, 0));
2603 len = Convert<uint64_t>(GetReg64(system, 1));
2604
2605 ret = OutputDebugString64(system, debug_str, len);
2606
2607 SetReg64(system, 0, Convert<uint64_t>(ret));
2608}
2609
2610static void SvcWrap_ReturnFromException64(Core::System& system) {
2611 Result result{};
2612
2613 result = Convert<Result>(GetReg64(system, 0));
2614
2615 ReturnFromException64(system, result);
2616}
2617
2618static void SvcWrap_GetInfo64(Core::System& system) {
2619 Result ret{};
2620
2621 uint64_t out{};
2622 InfoType info_type{};
2623 Handle handle{};
2624 uint64_t info_subtype{};
2625
2626 info_type = Convert<InfoType>(GetReg64(system, 1));
2627 handle = Convert<Handle>(GetReg64(system, 2));
2628 info_subtype = Convert<uint64_t>(GetReg64(system, 3));
2629
2630 ret = GetInfo64(system, &out, info_type, handle, info_subtype);
2631
2632 SetReg64(system, 0, Convert<uint64_t>(ret));
2633 SetReg64(system, 1, Convert<uint64_t>(out));
2634}
2635
2636static void SvcWrap_FlushEntireDataCache64(Core::System& system) {
2637 FlushEntireDataCache64(system);
2638}
2639
2640static void SvcWrap_FlushDataCache64(Core::System& system) {
2641 Result ret{};
2642
2643 uint64_t address{};
2644 uint64_t size{};
2645
2646 address = Convert<uint64_t>(GetReg64(system, 0));
2647 size = Convert<uint64_t>(GetReg64(system, 1));
2648
2649 ret = FlushDataCache64(system, address, size);
2650
2651 SetReg64(system, 0, Convert<uint64_t>(ret));
2652}
2653
2654static void SvcWrap_MapPhysicalMemory64(Core::System& system) {
2655 Result ret{};
2656
2657 uint64_t address{};
2658 uint64_t size{};
2659
2660 address = Convert<uint64_t>(GetReg64(system, 0));
2661 size = Convert<uint64_t>(GetReg64(system, 1));
2662
2663 ret = MapPhysicalMemory64(system, address, size);
2664
2665 SetReg64(system, 0, Convert<uint64_t>(ret));
2666}
2667
2668static void SvcWrap_UnmapPhysicalMemory64(Core::System& system) {
2669 Result ret{};
2670
2671 uint64_t address{};
2672 uint64_t size{};
2673
2674 address = Convert<uint64_t>(GetReg64(system, 0));
2675 size = Convert<uint64_t>(GetReg64(system, 1));
2676
2677 ret = UnmapPhysicalMemory64(system, address, size);
2678
2679 SetReg64(system, 0, Convert<uint64_t>(ret));
2680}
2681
2682static void SvcWrap_GetDebugFutureThreadInfo64(Core::System& system) {
2683 Result ret{};
2684
2685 lp64::LastThreadContext out_context{};
2686 uint64_t out_thread_id{};
2687 Handle debug_handle{};
2688 int64_t ns{};
2689
2690 debug_handle = Convert<Handle>(GetReg64(system, 2));
2691 ns = Convert<int64_t>(GetReg64(system, 3));
2692
2693 ret = GetDebugFutureThreadInfo64(system, &out_context, &out_thread_id, debug_handle, ns);
2694
2695 SetReg64(system, 0, Convert<uint64_t>(ret));
2696 auto out_context_scatter = Convert<std::array<uint64_t, 4>>(out_context);
2697 SetReg64(system, 1, out_context_scatter[0]);
2698 SetReg64(system, 2, out_context_scatter[1]);
2699 SetReg64(system, 3, out_context_scatter[2]);
2700 SetReg64(system, 4, out_context_scatter[3]);
2701 SetReg64(system, 5, Convert<uint64_t>(out_thread_id));
2702}
2703
2704static void SvcWrap_GetLastThreadInfo64(Core::System& system) {
2705 Result ret{};
2706
2707 lp64::LastThreadContext out_context{};
2708 uintptr_t out_tls_address{};
2709 uint32_t out_flags{};
2710
2711 ret = GetLastThreadInfo64(system, &out_context, &out_tls_address, &out_flags);
2712
2713 SetReg64(system, 0, Convert<uint64_t>(ret));
2714 auto out_context_scatter = Convert<std::array<uint64_t, 4>>(out_context);
2715 SetReg64(system, 1, out_context_scatter[0]);
2716 SetReg64(system, 2, out_context_scatter[1]);
2717 SetReg64(system, 3, out_context_scatter[2]);
2718 SetReg64(system, 4, out_context_scatter[3]);
2719 SetReg64(system, 5, Convert<uint64_t>(out_tls_address));
2720 SetReg64(system, 6, Convert<uint64_t>(out_flags));
2721}
2722
2723static void SvcWrap_GetResourceLimitLimitValue64(Core::System& system) {
2724 Result ret{};
2725
2726 int64_t out_limit_value{};
2727 Handle resource_limit_handle{};
2728 LimitableResource which{};
2729
2730 resource_limit_handle = Convert<Handle>(GetReg64(system, 1));
2731 which = Convert<LimitableResource>(GetReg64(system, 2));
2732
2733 ret = GetResourceLimitLimitValue64(system, &out_limit_value, resource_limit_handle, which);
2734
2735 SetReg64(system, 0, Convert<uint64_t>(ret));
2736 SetReg64(system, 1, Convert<uint64_t>(out_limit_value));
2737}
2738
2739static void SvcWrap_GetResourceLimitCurrentValue64(Core::System& system) {
2740 Result ret{};
2741
2742 int64_t out_current_value{};
2743 Handle resource_limit_handle{};
2744 LimitableResource which{};
2745
2746 resource_limit_handle = Convert<Handle>(GetReg64(system, 1));
2747 which = Convert<LimitableResource>(GetReg64(system, 2));
2748
2749 ret = GetResourceLimitCurrentValue64(system, &out_current_value, resource_limit_handle, which);
2750
2751 SetReg64(system, 0, Convert<uint64_t>(ret));
2752 SetReg64(system, 1, Convert<uint64_t>(out_current_value));
2753}
2754
2755static void SvcWrap_SetThreadActivity64(Core::System& system) {
2756 Result ret{};
2757
2758 Handle thread_handle{};
2759 ThreadActivity thread_activity{};
2760
2761 thread_handle = Convert<Handle>(GetReg64(system, 0));
2762 thread_activity = Convert<ThreadActivity>(GetReg64(system, 1));
2763
2764 ret = SetThreadActivity64(system, thread_handle, thread_activity);
2765
2766 SetReg64(system, 0, Convert<uint64_t>(ret));
2767}
2768
2769static void SvcWrap_GetThreadContext364(Core::System& system) {
2770 Result ret{};
2771
2772 uint64_t out_context{};
2773 Handle thread_handle{};
2774
2775 out_context = Convert<uint64_t>(GetReg64(system, 0));
2776 thread_handle = Convert<Handle>(GetReg64(system, 1));
2777
2778 ret = GetThreadContext364(system, out_context, thread_handle);
2779
2780 SetReg64(system, 0, Convert<uint64_t>(ret));
2781}
2782
2783static void SvcWrap_WaitForAddress64(Core::System& system) {
2784 Result ret{};
2785
2786 uint64_t address{};
2787 ArbitrationType arb_type{};
2788 int32_t value{};
2789 int64_t timeout_ns{};
2790
2791 address = Convert<uint64_t>(GetReg64(system, 0));
2792 arb_type = Convert<ArbitrationType>(GetReg64(system, 1));
2793 value = Convert<int32_t>(GetReg64(system, 2));
2794 timeout_ns = Convert<int64_t>(GetReg64(system, 3));
2795
2796 ret = WaitForAddress64(system, address, arb_type, value, timeout_ns);
2797
2798 SetReg64(system, 0, Convert<uint64_t>(ret));
2799}
2800
2801static void SvcWrap_SignalToAddress64(Core::System& system) {
2802 Result ret{};
2803
2804 uint64_t address{};
2805 SignalType signal_type{};
2806 int32_t value{};
2807 int32_t count{};
2808
2809 address = Convert<uint64_t>(GetReg64(system, 0));
2810 signal_type = Convert<SignalType>(GetReg64(system, 1));
2811 value = Convert<int32_t>(GetReg64(system, 2));
2812 count = Convert<int32_t>(GetReg64(system, 3));
2813
2814 ret = SignalToAddress64(system, address, signal_type, value, count);
2815
2816 SetReg64(system, 0, Convert<uint64_t>(ret));
2817}
2818
2819static void SvcWrap_SynchronizePreemptionState64(Core::System& system) {
2820 SynchronizePreemptionState64(system);
2821}
2822
2823static void SvcWrap_GetResourceLimitPeakValue64(Core::System& system) {
2824 Result ret{};
2825
2826 int64_t out_peak_value{};
2827 Handle resource_limit_handle{};
2828 LimitableResource which{};
2829
2830 resource_limit_handle = Convert<Handle>(GetReg64(system, 1));
2831 which = Convert<LimitableResource>(GetReg64(system, 2));
2832
2833 ret = GetResourceLimitPeakValue64(system, &out_peak_value, resource_limit_handle, which);
2834
2835 SetReg64(system, 0, Convert<uint64_t>(ret));
2836 SetReg64(system, 1, Convert<uint64_t>(out_peak_value));
2837}
2838
2839static void SvcWrap_CreateIoPool64(Core::System& system) {
2840 Result ret{};
2841
2842 Handle out_handle{};
2843 IoPoolType which{};
2844
2845 which = Convert<IoPoolType>(GetReg64(system, 1));
2846
2847 ret = CreateIoPool64(system, &out_handle, which);
2848
2849 SetReg64(system, 0, Convert<uint64_t>(ret));
2850 SetReg64(system, 1, Convert<uint64_t>(out_handle));
2851}
2852
2853static void SvcWrap_CreateIoRegion64(Core::System& system) {
2854 Result ret{};
2855
2856 Handle out_handle{};
2857 Handle io_pool{};
2858 uint64_t physical_address{};
2859 uint64_t size{};
2860 MemoryMapping mapping{};
2861 MemoryPermission perm{};
2862
2863 io_pool = Convert<Handle>(GetReg64(system, 1));
2864 physical_address = Convert<uint64_t>(GetReg64(system, 2));
2865 size = Convert<uint64_t>(GetReg64(system, 3));
2866 mapping = Convert<MemoryMapping>(GetReg64(system, 4));
2867 perm = Convert<MemoryPermission>(GetReg64(system, 5));
2868
2869 ret = CreateIoRegion64(system, &out_handle, io_pool, physical_address, size, mapping, perm);
2870
2871 SetReg64(system, 0, Convert<uint64_t>(ret));
2872 SetReg64(system, 1, Convert<uint64_t>(out_handle));
2873}
2874
2875static void SvcWrap_KernelDebug64(Core::System& system) {
2876 KernelDebugType kern_debug_type{};
2877 uint64_t arg0{};
2878 uint64_t arg1{};
2879 uint64_t arg2{};
2880
2881 kern_debug_type = Convert<KernelDebugType>(GetReg64(system, 0));
2882 arg0 = Convert<uint64_t>(GetReg64(system, 1));
2883 arg1 = Convert<uint64_t>(GetReg64(system, 2));
2884 arg2 = Convert<uint64_t>(GetReg64(system, 3));
2885
2886 KernelDebug64(system, kern_debug_type, arg0, arg1, arg2);
2887}
2888
2889static void SvcWrap_ChangeKernelTraceState64(Core::System& system) {
2890 KernelTraceState kern_trace_state{};
2891
2892 kern_trace_state = Convert<KernelTraceState>(GetReg64(system, 0));
2893
2894 ChangeKernelTraceState64(system, kern_trace_state);
2895}
2896
2897static void SvcWrap_CreateSession64(Core::System& system) {
2898 Result ret{};
2899
2900 Handle out_server_session_handle{};
2901 Handle out_client_session_handle{};
2902 bool is_light{};
2903 uint64_t name{};
2904
2905 is_light = Convert<bool>(GetReg64(system, 2));
2906 name = Convert<uint64_t>(GetReg64(system, 3));
2907
2908 ret = CreateSession64(system, &out_server_session_handle, &out_client_session_handle, is_light, name);
2909
2910 SetReg64(system, 0, Convert<uint64_t>(ret));
2911 SetReg64(system, 1, Convert<uint64_t>(out_server_session_handle));
2912 SetReg64(system, 2, Convert<uint64_t>(out_client_session_handle));
2913}
2914
2915static void SvcWrap_AcceptSession64(Core::System& system) {
2916 Result ret{};
2917
2918 Handle out_handle{};
2919 Handle port{};
2920
2921 port = Convert<Handle>(GetReg64(system, 1));
2922
2923 ret = AcceptSession64(system, &out_handle, port);
2924
2925 SetReg64(system, 0, Convert<uint64_t>(ret));
2926 SetReg64(system, 1, Convert<uint64_t>(out_handle));
2927}
2928
2929static void SvcWrap_ReplyAndReceive64(Core::System& system) {
2930 Result ret{};
2931
2932 int32_t out_index{};
2933 uint64_t handles{};
2934 int32_t num_handles{};
2935 Handle reply_target{};
2936 int64_t timeout_ns{};
2937
2938 handles = Convert<uint64_t>(GetReg64(system, 1));
2939 num_handles = Convert<int32_t>(GetReg64(system, 2));
2940 reply_target = Convert<Handle>(GetReg64(system, 3));
2941 timeout_ns = Convert<int64_t>(GetReg64(system, 4));
2942
2943 ret = ReplyAndReceive64(system, &out_index, handles, num_handles, reply_target, timeout_ns);
2944
2945 SetReg64(system, 0, Convert<uint64_t>(ret));
2946 SetReg64(system, 1, Convert<uint64_t>(out_index));
2947}
2948
2949static void SvcWrap_ReplyAndReceiveWithUserBuffer64(Core::System& system) {
2950 Result ret{};
2951
2952 int32_t out_index{};
2953 uint64_t message_buffer{};
2954 uint64_t message_buffer_size{};
2955 uint64_t handles{};
2956 int32_t num_handles{};
2957 Handle reply_target{};
2958 int64_t timeout_ns{};
2959
2960 message_buffer = Convert<uint64_t>(GetReg64(system, 1));
2961 message_buffer_size = Convert<uint64_t>(GetReg64(system, 2));
2962 handles = Convert<uint64_t>(GetReg64(system, 3));
2963 num_handles = Convert<int32_t>(GetReg64(system, 4));
2964 reply_target = Convert<Handle>(GetReg64(system, 5));
2965 timeout_ns = Convert<int64_t>(GetReg64(system, 6));
2966
2967 ret = ReplyAndReceiveWithUserBuffer64(system, &out_index, message_buffer, message_buffer_size, handles, num_handles, reply_target, timeout_ns);
2968
2969 SetReg64(system, 0, Convert<uint64_t>(ret));
2970 SetReg64(system, 1, Convert<uint64_t>(out_index));
2971}
2972
2973static void SvcWrap_CreateEvent64(Core::System& system) {
2974 Result ret{};
2975
2976 Handle out_write_handle{};
2977 Handle out_read_handle{};
2978
2979 ret = CreateEvent64(system, &out_write_handle, &out_read_handle);
2980
2981 SetReg64(system, 0, Convert<uint64_t>(ret));
2982 SetReg64(system, 1, Convert<uint64_t>(out_write_handle));
2983 SetReg64(system, 2, Convert<uint64_t>(out_read_handle));
2984}
2985
2986static void SvcWrap_MapIoRegion64(Core::System& system) {
2987 Result ret{};
2988
2989 Handle io_region{};
2990 uint64_t address{};
2991 uint64_t size{};
2992 MemoryPermission perm{};
2993
2994 io_region = Convert<Handle>(GetReg64(system, 0));
2995 address = Convert<uint64_t>(GetReg64(system, 1));
2996 size = Convert<uint64_t>(GetReg64(system, 2));
2997 perm = Convert<MemoryPermission>(GetReg64(system, 3));
2998
2999 ret = MapIoRegion64(system, io_region, address, size, perm);
3000
3001 SetReg64(system, 0, Convert<uint64_t>(ret));
3002}
3003
3004static void SvcWrap_UnmapIoRegion64(Core::System& system) {
3005 Result ret{};
3006
3007 Handle io_region{};
3008 uint64_t address{};
3009 uint64_t size{};
3010
3011 io_region = Convert<Handle>(GetReg64(system, 0));
3012 address = Convert<uint64_t>(GetReg64(system, 1));
3013 size = Convert<uint64_t>(GetReg64(system, 2));
3014
3015 ret = UnmapIoRegion64(system, io_region, address, size);
3016
3017 SetReg64(system, 0, Convert<uint64_t>(ret));
3018}
3019
3020static void SvcWrap_MapPhysicalMemoryUnsafe64(Core::System& system) {
3021 Result ret{};
3022
3023 uint64_t address{};
3024 uint64_t size{};
3025
3026 address = Convert<uint64_t>(GetReg64(system, 0));
3027 size = Convert<uint64_t>(GetReg64(system, 1));
3028
3029 ret = MapPhysicalMemoryUnsafe64(system, address, size);
3030
3031 SetReg64(system, 0, Convert<uint64_t>(ret));
3032}
3033
3034static void SvcWrap_UnmapPhysicalMemoryUnsafe64(Core::System& system) {
3035 Result ret{};
3036
3037 uint64_t address{};
3038 uint64_t size{};
3039
3040 address = Convert<uint64_t>(GetReg64(system, 0));
3041 size = Convert<uint64_t>(GetReg64(system, 1));
3042
3043 ret = UnmapPhysicalMemoryUnsafe64(system, address, size);
3044
3045 SetReg64(system, 0, Convert<uint64_t>(ret));
3046}
3047
3048static void SvcWrap_SetUnsafeLimit64(Core::System& system) {
3049 Result ret{};
3050
3051 uint64_t limit{};
3052
3053 limit = Convert<uint64_t>(GetReg64(system, 0));
3054
3055 ret = SetUnsafeLimit64(system, limit);
3056
3057 SetReg64(system, 0, Convert<uint64_t>(ret));
3058}
3059
3060static void SvcWrap_CreateCodeMemory64(Core::System& system) {
3061 Result ret{};
3062
3063 Handle out_handle{};
3064 uint64_t address{};
3065 uint64_t size{};
3066
3067 address = Convert<uint64_t>(GetReg64(system, 1));
3068 size = Convert<uint64_t>(GetReg64(system, 2));
3069
3070 ret = CreateCodeMemory64(system, &out_handle, address, size);
3071
3072 SetReg64(system, 0, Convert<uint64_t>(ret));
3073 SetReg64(system, 1, Convert<uint64_t>(out_handle));
3074}
3075
3076static void SvcWrap_ControlCodeMemory64(Core::System& system) {
3077 Result ret{};
3078
3079 Handle code_memory_handle{};
3080 CodeMemoryOperation operation{};
3081 uint64_t address{};
3082 uint64_t size{};
3083 MemoryPermission perm{};
3084
3085 code_memory_handle = Convert<Handle>(GetReg64(system, 0));
3086 operation = Convert<CodeMemoryOperation>(GetReg64(system, 1));
3087 address = Convert<uint64_t>(GetReg64(system, 2));
3088 size = Convert<uint64_t>(GetReg64(system, 3));
3089 perm = Convert<MemoryPermission>(GetReg64(system, 4));
3090
3091 ret = ControlCodeMemory64(system, code_memory_handle, operation, address, size, perm);
3092
3093 SetReg64(system, 0, Convert<uint64_t>(ret));
3094}
3095
3096static void SvcWrap_SleepSystem64(Core::System& system) {
3097 SleepSystem64(system);
3098}
3099
3100static void SvcWrap_ReadWriteRegister64(Core::System& system) {
3101 Result ret{};
3102
3103 uint32_t out_value{};
3104 uint64_t address{};
3105 uint32_t mask{};
3106 uint32_t value{};
3107
3108 address = Convert<uint64_t>(GetReg64(system, 1));
3109 mask = Convert<uint32_t>(GetReg64(system, 2));
3110 value = Convert<uint32_t>(GetReg64(system, 3));
3111
3112 ret = ReadWriteRegister64(system, &out_value, address, mask, value);
3113
3114 SetReg64(system, 0, Convert<uint64_t>(ret));
3115 SetReg64(system, 1, Convert<uint64_t>(out_value));
3116}
3117
3118static void SvcWrap_SetProcessActivity64(Core::System& system) {
3119 Result ret{};
3120
3121 Handle process_handle{};
3122 ProcessActivity process_activity{};
3123
3124 process_handle = Convert<Handle>(GetReg64(system, 0));
3125 process_activity = Convert<ProcessActivity>(GetReg64(system, 1));
3126
3127 ret = SetProcessActivity64(system, process_handle, process_activity);
3128
3129 SetReg64(system, 0, Convert<uint64_t>(ret));
3130}
3131
3132static void SvcWrap_CreateSharedMemory64(Core::System& system) {
3133 Result ret{};
3134
3135 Handle out_handle{};
3136 uint64_t size{};
3137 MemoryPermission owner_perm{};
3138 MemoryPermission remote_perm{};
3139
3140 size = Convert<uint64_t>(GetReg64(system, 1));
3141 owner_perm = Convert<MemoryPermission>(GetReg64(system, 2));
3142 remote_perm = Convert<MemoryPermission>(GetReg64(system, 3));
3143
3144 ret = CreateSharedMemory64(system, &out_handle, size, owner_perm, remote_perm);
3145
3146 SetReg64(system, 0, Convert<uint64_t>(ret));
3147 SetReg64(system, 1, Convert<uint64_t>(out_handle));
3148}
3149
3150static void SvcWrap_MapTransferMemory64(Core::System& system) {
3151 Result ret{};
3152
3153 Handle trmem_handle{};
3154 uint64_t address{};
3155 uint64_t size{};
3156 MemoryPermission owner_perm{};
3157
3158 trmem_handle = Convert<Handle>(GetReg64(system, 0));
3159 address = Convert<uint64_t>(GetReg64(system, 1));
3160 size = Convert<uint64_t>(GetReg64(system, 2));
3161 owner_perm = Convert<MemoryPermission>(GetReg64(system, 3));
3162
3163 ret = MapTransferMemory64(system, trmem_handle, address, size, owner_perm);
3164
3165 SetReg64(system, 0, Convert<uint64_t>(ret));
3166}
3167
3168static void SvcWrap_UnmapTransferMemory64(Core::System& system) {
3169 Result ret{};
3170
3171 Handle trmem_handle{};
3172 uint64_t address{};
3173 uint64_t size{};
3174
3175 trmem_handle = Convert<Handle>(GetReg64(system, 0));
3176 address = Convert<uint64_t>(GetReg64(system, 1));
3177 size = Convert<uint64_t>(GetReg64(system, 2));
3178
3179 ret = UnmapTransferMemory64(system, trmem_handle, address, size);
3180
3181 SetReg64(system, 0, Convert<uint64_t>(ret));
3182}
3183
3184static void SvcWrap_CreateInterruptEvent64(Core::System& system) {
3185 Result ret{};
3186
3187 Handle out_read_handle{};
3188 int32_t interrupt_id{};
3189 InterruptType interrupt_type{};
3190
3191 interrupt_id = Convert<int32_t>(GetReg64(system, 1));
3192 interrupt_type = Convert<InterruptType>(GetReg64(system, 2));
3193
3194 ret = CreateInterruptEvent64(system, &out_read_handle, interrupt_id, interrupt_type);
3195
3196 SetReg64(system, 0, Convert<uint64_t>(ret));
3197 SetReg64(system, 1, Convert<uint64_t>(out_read_handle));
3198}
3199
3200static void SvcWrap_QueryPhysicalAddress64(Core::System& system) {
3201 Result ret{};
3202
3203 lp64::PhysicalMemoryInfo out_info{};
3204 uint64_t address{};
3205
3206 address = Convert<uint64_t>(GetReg64(system, 1));
3207
3208 ret = QueryPhysicalAddress64(system, &out_info, address);
3209
3210 SetReg64(system, 0, Convert<uint64_t>(ret));
3211 auto out_info_scatter = Convert<std::array<uint64_t, 3>>(out_info);
3212 SetReg64(system, 1, out_info_scatter[0]);
3213 SetReg64(system, 2, out_info_scatter[1]);
3214 SetReg64(system, 3, out_info_scatter[2]);
3215}
3216
3217static void SvcWrap_QueryIoMapping64(Core::System& system) {
3218 Result ret{};
3219
3220 uintptr_t out_address{};
3221 uintptr_t out_size{};
3222 uint64_t physical_address{};
3223 uint64_t size{};
3224
3225 physical_address = Convert<uint64_t>(GetReg64(system, 2));
3226 size = Convert<uint64_t>(GetReg64(system, 3));
3227
3228 ret = QueryIoMapping64(system, &out_address, &out_size, physical_address, size);
3229
3230 SetReg64(system, 0, Convert<uint64_t>(ret));
3231 SetReg64(system, 1, Convert<uint64_t>(out_address));
3232 SetReg64(system, 2, Convert<uint64_t>(out_size));
3233}
3234
3235static void SvcWrap_CreateDeviceAddressSpace64(Core::System& system) {
3236 Result ret{};
3237
3238 Handle out_handle{};
3239 uint64_t das_address{};
3240 uint64_t das_size{};
3241
3242 das_address = Convert<uint64_t>(GetReg64(system, 1));
3243 das_size = Convert<uint64_t>(GetReg64(system, 2));
3244
3245 ret = CreateDeviceAddressSpace64(system, &out_handle, das_address, das_size);
3246
3247 SetReg64(system, 0, Convert<uint64_t>(ret));
3248 SetReg64(system, 1, Convert<uint64_t>(out_handle));
3249}
3250
3251static void SvcWrap_AttachDeviceAddressSpace64(Core::System& system) {
3252 Result ret{};
3253
3254 DeviceName device_name{};
3255 Handle das_handle{};
3256
3257 device_name = Convert<DeviceName>(GetReg64(system, 0));
3258 das_handle = Convert<Handle>(GetReg64(system, 1));
3259
3260 ret = AttachDeviceAddressSpace64(system, device_name, das_handle);
3261
3262 SetReg64(system, 0, Convert<uint64_t>(ret));
3263}
3264
3265static void SvcWrap_DetachDeviceAddressSpace64(Core::System& system) {
3266 Result ret{};
3267
3268 DeviceName device_name{};
3269 Handle das_handle{};
3270
3271 device_name = Convert<DeviceName>(GetReg64(system, 0));
3272 das_handle = Convert<Handle>(GetReg64(system, 1));
3273
3274 ret = DetachDeviceAddressSpace64(system, device_name, das_handle);
3275
3276 SetReg64(system, 0, Convert<uint64_t>(ret));
3277}
3278
3279static void SvcWrap_MapDeviceAddressSpaceByForce64(Core::System& system) {
3280 Result ret{};
3281
3282 Handle das_handle{};
3283 Handle process_handle{};
3284 uint64_t process_address{};
3285 uint64_t size{};
3286 uint64_t device_address{};
3287 uint32_t option{};
3288
3289 das_handle = Convert<Handle>(GetReg64(system, 0));
3290 process_handle = Convert<Handle>(GetReg64(system, 1));
3291 process_address = Convert<uint64_t>(GetReg64(system, 2));
3292 size = Convert<uint64_t>(GetReg64(system, 3));
3293 device_address = Convert<uint64_t>(GetReg64(system, 4));
3294 option = Convert<uint32_t>(GetReg64(system, 5));
3295
3296 ret = MapDeviceAddressSpaceByForce64(system, das_handle, process_handle, process_address, size, device_address, option);
3297
3298 SetReg64(system, 0, Convert<uint64_t>(ret));
3299}
3300
3301static void SvcWrap_MapDeviceAddressSpaceAligned64(Core::System& system) {
3302 Result ret{};
3303
3304 Handle das_handle{};
3305 Handle process_handle{};
3306 uint64_t process_address{};
3307 uint64_t size{};
3308 uint64_t device_address{};
3309 uint32_t option{};
3310
3311 das_handle = Convert<Handle>(GetReg64(system, 0));
3312 process_handle = Convert<Handle>(GetReg64(system, 1));
3313 process_address = Convert<uint64_t>(GetReg64(system, 2));
3314 size = Convert<uint64_t>(GetReg64(system, 3));
3315 device_address = Convert<uint64_t>(GetReg64(system, 4));
3316 option = Convert<uint32_t>(GetReg64(system, 5));
3317
3318 ret = MapDeviceAddressSpaceAligned64(system, das_handle, process_handle, process_address, size, device_address, option);
3319
3320 SetReg64(system, 0, Convert<uint64_t>(ret));
3321}
3322
3323static void SvcWrap_UnmapDeviceAddressSpace64(Core::System& system) {
3324 Result ret{};
3325
3326 Handle das_handle{};
3327 Handle process_handle{};
3328 uint64_t process_address{};
3329 uint64_t size{};
3330 uint64_t device_address{};
3331
3332 das_handle = Convert<Handle>(GetReg64(system, 0));
3333 process_handle = Convert<Handle>(GetReg64(system, 1));
3334 process_address = Convert<uint64_t>(GetReg64(system, 2));
3335 size = Convert<uint64_t>(GetReg64(system, 3));
3336 device_address = Convert<uint64_t>(GetReg64(system, 4));
3337
3338 ret = UnmapDeviceAddressSpace64(system, das_handle, process_handle, process_address, size, device_address);
3339
3340 SetReg64(system, 0, Convert<uint64_t>(ret));
3341}
3342
3343static void SvcWrap_InvalidateProcessDataCache64(Core::System& system) {
3344 Result ret{};
3345
3346 Handle process_handle{};
3347 uint64_t address{};
3348 uint64_t size{};
3349
3350 process_handle = Convert<Handle>(GetReg64(system, 0));
3351 address = Convert<uint64_t>(GetReg64(system, 1));
3352 size = Convert<uint64_t>(GetReg64(system, 2));
3353
3354 ret = InvalidateProcessDataCache64(system, process_handle, address, size);
3355
3356 SetReg64(system, 0, Convert<uint64_t>(ret));
3357}
3358
3359static void SvcWrap_StoreProcessDataCache64(Core::System& system) {
3360 Result ret{};
3361
3362 Handle process_handle{};
3363 uint64_t address{};
3364 uint64_t size{};
3365
3366 process_handle = Convert<Handle>(GetReg64(system, 0));
3367 address = Convert<uint64_t>(GetReg64(system, 1));
3368 size = Convert<uint64_t>(GetReg64(system, 2));
3369
3370 ret = StoreProcessDataCache64(system, process_handle, address, size);
3371
3372 SetReg64(system, 0, Convert<uint64_t>(ret));
3373}
3374
3375static void SvcWrap_FlushProcessDataCache64(Core::System& system) {
3376 Result ret{};
3377
3378 Handle process_handle{};
3379 uint64_t address{};
3380 uint64_t size{};
3381
3382 process_handle = Convert<Handle>(GetReg64(system, 0));
3383 address = Convert<uint64_t>(GetReg64(system, 1));
3384 size = Convert<uint64_t>(GetReg64(system, 2));
3385
3386 ret = FlushProcessDataCache64(system, process_handle, address, size);
3387
3388 SetReg64(system, 0, Convert<uint64_t>(ret));
3389}
3390
3391static void SvcWrap_DebugActiveProcess64(Core::System& system) {
3392 Result ret{};
3393
3394 Handle out_handle{};
3395 uint64_t process_id{};
3396
3397 process_id = Convert<uint64_t>(GetReg64(system, 1));
3398
3399 ret = DebugActiveProcess64(system, &out_handle, process_id);
3400
3401 SetReg64(system, 0, Convert<uint64_t>(ret));
3402 SetReg64(system, 1, Convert<uint64_t>(out_handle));
3403}
3404
3405static void SvcWrap_BreakDebugProcess64(Core::System& system) {
3406 Result ret{};
3407
3408 Handle debug_handle{};
3409
3410 debug_handle = Convert<Handle>(GetReg64(system, 0));
3411
3412 ret = BreakDebugProcess64(system, debug_handle);
3413
3414 SetReg64(system, 0, Convert<uint64_t>(ret));
3415}
3416
3417static void SvcWrap_TerminateDebugProcess64(Core::System& system) {
3418 Result ret{};
3419
3420 Handle debug_handle{};
3421
3422 debug_handle = Convert<Handle>(GetReg64(system, 0));
3423
3424 ret = TerminateDebugProcess64(system, debug_handle);
3425
3426 SetReg64(system, 0, Convert<uint64_t>(ret));
3427}
3428
3429static void SvcWrap_GetDebugEvent64(Core::System& system) {
3430 Result ret{};
3431
3432 uint64_t out_info{};
3433 Handle debug_handle{};
3434
3435 out_info = Convert<uint64_t>(GetReg64(system, 0));
3436 debug_handle = Convert<Handle>(GetReg64(system, 1));
3437
3438 ret = GetDebugEvent64(system, out_info, debug_handle);
3439
3440 SetReg64(system, 0, Convert<uint64_t>(ret));
3441}
3442
3443static void SvcWrap_ContinueDebugEvent64(Core::System& system) {
3444 Result ret{};
3445
3446 Handle debug_handle{};
3447 uint32_t flags{};
3448 uint64_t thread_ids{};
3449 int32_t num_thread_ids{};
3450
3451 debug_handle = Convert<Handle>(GetReg64(system, 0));
3452 flags = Convert<uint32_t>(GetReg64(system, 1));
3453 thread_ids = Convert<uint64_t>(GetReg64(system, 2));
3454 num_thread_ids = Convert<int32_t>(GetReg64(system, 3));
3455
3456 ret = ContinueDebugEvent64(system, debug_handle, flags, thread_ids, num_thread_ids);
3457
3458 SetReg64(system, 0, Convert<uint64_t>(ret));
3459}
3460
3461static void SvcWrap_GetProcessList64(Core::System& system) {
3462 Result ret{};
3463
3464 int32_t out_num_processes{};
3465 uint64_t out_process_ids{};
3466 int32_t max_out_count{};
3467
3468 out_process_ids = Convert<uint64_t>(GetReg64(system, 1));
3469 max_out_count = Convert<int32_t>(GetReg64(system, 2));
3470
3471 ret = GetProcessList64(system, &out_num_processes, out_process_ids, max_out_count);
3472
3473 SetReg64(system, 0, Convert<uint64_t>(ret));
3474 SetReg64(system, 1, Convert<uint64_t>(out_num_processes));
3475}
3476
3477static void SvcWrap_GetThreadList64(Core::System& system) {
3478 Result ret{};
3479
3480 int32_t out_num_threads{};
3481 uint64_t out_thread_ids{};
3482 int32_t max_out_count{};
3483 Handle debug_handle{};
3484
3485 out_thread_ids = Convert<uint64_t>(GetReg64(system, 1));
3486 max_out_count = Convert<int32_t>(GetReg64(system, 2));
3487 debug_handle = Convert<Handle>(GetReg64(system, 3));
3488
3489 ret = GetThreadList64(system, &out_num_threads, out_thread_ids, max_out_count, debug_handle);
3490
3491 SetReg64(system, 0, Convert<uint64_t>(ret));
3492 SetReg64(system, 1, Convert<uint64_t>(out_num_threads));
3493}
3494
3495static void SvcWrap_GetDebugThreadContext64(Core::System& system) {
3496 Result ret{};
3497
3498 uint64_t out_context{};
3499 Handle debug_handle{};
3500 uint64_t thread_id{};
3501 uint32_t context_flags{};
3502
3503 out_context = Convert<uint64_t>(GetReg64(system, 0));
3504 debug_handle = Convert<Handle>(GetReg64(system, 1));
3505 thread_id = Convert<uint64_t>(GetReg64(system, 2));
3506 context_flags = Convert<uint32_t>(GetReg64(system, 3));
3507
3508 ret = GetDebugThreadContext64(system, out_context, debug_handle, thread_id, context_flags);
3509
3510 SetReg64(system, 0, Convert<uint64_t>(ret));
3511}
3512
3513static void SvcWrap_SetDebugThreadContext64(Core::System& system) {
3514 Result ret{};
3515
3516 Handle debug_handle{};
3517 uint64_t thread_id{};
3518 uint64_t context{};
3519 uint32_t context_flags{};
3520
3521 debug_handle = Convert<Handle>(GetReg64(system, 0));
3522 thread_id = Convert<uint64_t>(GetReg64(system, 1));
3523 context = Convert<uint64_t>(GetReg64(system, 2));
3524 context_flags = Convert<uint32_t>(GetReg64(system, 3));
3525
3526 ret = SetDebugThreadContext64(system, debug_handle, thread_id, context, context_flags);
3527
3528 SetReg64(system, 0, Convert<uint64_t>(ret));
3529}
3530
3531static void SvcWrap_QueryDebugProcessMemory64(Core::System& system) {
3532 Result ret{};
3533
3534 PageInfo out_page_info{};
3535 uint64_t out_memory_info{};
3536 Handle process_handle{};
3537 uint64_t address{};
3538
3539 out_memory_info = Convert<uint64_t>(GetReg64(system, 0));
3540 process_handle = Convert<Handle>(GetReg64(system, 2));
3541 address = Convert<uint64_t>(GetReg64(system, 3));
3542
3543 ret = QueryDebugProcessMemory64(system, out_memory_info, &out_page_info, process_handle, address);
3544
3545 SetReg64(system, 0, Convert<uint64_t>(ret));
3546 SetReg64(system, 1, Convert<uint64_t>(out_page_info));
3547}
3548
3549static void SvcWrap_ReadDebugProcessMemory64(Core::System& system) {
3550 Result ret{};
3551
3552 uint64_t buffer{};
3553 Handle debug_handle{};
3554 uint64_t address{};
3555 uint64_t size{};
3556
3557 buffer = Convert<uint64_t>(GetReg64(system, 0));
3558 debug_handle = Convert<Handle>(GetReg64(system, 1));
3559 address = Convert<uint64_t>(GetReg64(system, 2));
3560 size = Convert<uint64_t>(GetReg64(system, 3));
3561
3562 ret = ReadDebugProcessMemory64(system, buffer, debug_handle, address, size);
3563
3564 SetReg64(system, 0, Convert<uint64_t>(ret));
3565}
3566
3567static void SvcWrap_WriteDebugProcessMemory64(Core::System& system) {
3568 Result ret{};
3569
3570 Handle debug_handle{};
3571 uint64_t buffer{};
3572 uint64_t address{};
3573 uint64_t size{};
3574
3575 debug_handle = Convert<Handle>(GetReg64(system, 0));
3576 buffer = Convert<uint64_t>(GetReg64(system, 1));
3577 address = Convert<uint64_t>(GetReg64(system, 2));
3578 size = Convert<uint64_t>(GetReg64(system, 3));
3579
3580 ret = WriteDebugProcessMemory64(system, debug_handle, buffer, address, size);
3581
3582 SetReg64(system, 0, Convert<uint64_t>(ret));
3583}
3584
3585static void SvcWrap_SetHardwareBreakPoint64(Core::System& system) {
3586 Result ret{};
3587
3588 HardwareBreakPointRegisterName name{};
3589 uint64_t flags{};
3590 uint64_t value{};
3591
3592 name = Convert<HardwareBreakPointRegisterName>(GetReg64(system, 0));
3593 flags = Convert<uint64_t>(GetReg64(system, 1));
3594 value = Convert<uint64_t>(GetReg64(system, 2));
3595
3596 ret = SetHardwareBreakPoint64(system, name, flags, value);
3597
3598 SetReg64(system, 0, Convert<uint64_t>(ret));
3599}
3600
3601static void SvcWrap_GetDebugThreadParam64(Core::System& system) {
3602 Result ret{};
3603
3604 uint64_t out_64{};
3605 uint32_t out_32{};
3606 Handle debug_handle{};
3607 uint64_t thread_id{};
3608 DebugThreadParam param{};
3609
3610 debug_handle = Convert<Handle>(GetReg64(system, 2));
3611 thread_id = Convert<uint64_t>(GetReg64(system, 3));
3612 param = Convert<DebugThreadParam>(GetReg64(system, 4));
3613
3614 ret = GetDebugThreadParam64(system, &out_64, &out_32, debug_handle, thread_id, param);
3615
3616 SetReg64(system, 0, Convert<uint64_t>(ret));
3617 SetReg64(system, 1, Convert<uint64_t>(out_64));
3618 SetReg64(system, 2, Convert<uint64_t>(out_32));
3619}
3620
3621static void SvcWrap_GetSystemInfo64(Core::System& system) {
3622 Result ret{};
3623
3624 uint64_t out{};
3625 SystemInfoType info_type{};
3626 Handle handle{};
3627 uint64_t info_subtype{};
3628
3629 info_type = Convert<SystemInfoType>(GetReg64(system, 1));
3630 handle = Convert<Handle>(GetReg64(system, 2));
3631 info_subtype = Convert<uint64_t>(GetReg64(system, 3));
3632
3633 ret = GetSystemInfo64(system, &out, info_type, handle, info_subtype);
3634
3635 SetReg64(system, 0, Convert<uint64_t>(ret));
3636 SetReg64(system, 1, Convert<uint64_t>(out));
3637}
3638
3639static void SvcWrap_CreatePort64(Core::System& system) {
3640 Result ret{};
3641
3642 Handle out_server_handle{};
3643 Handle out_client_handle{};
3644 int32_t max_sessions{};
3645 bool is_light{};
3646 uint64_t name{};
3647
3648 max_sessions = Convert<int32_t>(GetReg64(system, 2));
3649 is_light = Convert<bool>(GetReg64(system, 3));
3650 name = Convert<uint64_t>(GetReg64(system, 4));
3651
3652 ret = CreatePort64(system, &out_server_handle, &out_client_handle, max_sessions, is_light, name);
3653
3654 SetReg64(system, 0, Convert<uint64_t>(ret));
3655 SetReg64(system, 1, Convert<uint64_t>(out_server_handle));
3656 SetReg64(system, 2, Convert<uint64_t>(out_client_handle));
3657}
3658
3659static void SvcWrap_ManageNamedPort64(Core::System& system) {
3660 Result ret{};
3661
3662 Handle out_server_handle{};
3663 uint64_t name{};
3664 int32_t max_sessions{};
3665
3666 name = Convert<uint64_t>(GetReg64(system, 1));
3667 max_sessions = Convert<int32_t>(GetReg64(system, 2));
3668
3669 ret = ManageNamedPort64(system, &out_server_handle, name, max_sessions);
3670
3671 SetReg64(system, 0, Convert<uint64_t>(ret));
3672 SetReg64(system, 1, Convert<uint64_t>(out_server_handle));
3673}
3674
3675static void SvcWrap_ConnectToPort64(Core::System& system) {
3676 Result ret{};
3677
3678 Handle out_handle{};
3679 Handle port{};
3680
3681 port = Convert<Handle>(GetReg64(system, 1));
3682
3683 ret = ConnectToPort64(system, &out_handle, port);
3684
3685 SetReg64(system, 0, Convert<uint64_t>(ret));
3686 SetReg64(system, 1, Convert<uint64_t>(out_handle));
3687}
3688
3689static void SvcWrap_SetProcessMemoryPermission64(Core::System& system) {
3690 Result ret{};
3691
3692 Handle process_handle{};
3693 uint64_t address{};
3694 uint64_t size{};
3695 MemoryPermission perm{};
3696
3697 process_handle = Convert<Handle>(GetReg64(system, 0));
3698 address = Convert<uint64_t>(GetReg64(system, 1));
3699 size = Convert<uint64_t>(GetReg64(system, 2));
3700 perm = Convert<MemoryPermission>(GetReg64(system, 3));
3701
3702 ret = SetProcessMemoryPermission64(system, process_handle, address, size, perm);
3703
3704 SetReg64(system, 0, Convert<uint64_t>(ret));
3705}
3706
3707static void SvcWrap_MapProcessMemory64(Core::System& system) {
3708 Result ret{};
3709
3710 uint64_t dst_address{};
3711 Handle process_handle{};
3712 uint64_t src_address{};
3713 uint64_t size{};
3714
3715 dst_address = Convert<uint64_t>(GetReg64(system, 0));
3716 process_handle = Convert<Handle>(GetReg64(system, 1));
3717 src_address = Convert<uint64_t>(GetReg64(system, 2));
3718 size = Convert<uint64_t>(GetReg64(system, 3));
3719
3720 ret = MapProcessMemory64(system, dst_address, process_handle, src_address, size);
3721
3722 SetReg64(system, 0, Convert<uint64_t>(ret));
3723}
3724
3725static void SvcWrap_UnmapProcessMemory64(Core::System& system) {
3726 Result ret{};
3727
3728 uint64_t dst_address{};
3729 Handle process_handle{};
3730 uint64_t src_address{};
3731 uint64_t size{};
3732
3733 dst_address = Convert<uint64_t>(GetReg64(system, 0));
3734 process_handle = Convert<Handle>(GetReg64(system, 1));
3735 src_address = Convert<uint64_t>(GetReg64(system, 2));
3736 size = Convert<uint64_t>(GetReg64(system, 3));
3737
3738 ret = UnmapProcessMemory64(system, dst_address, process_handle, src_address, size);
3739
3740 SetReg64(system, 0, Convert<uint64_t>(ret));
3741}
3742
3743static void SvcWrap_QueryProcessMemory64(Core::System& system) {
3744 Result ret{};
3745
3746 PageInfo out_page_info{};
3747 uint64_t out_memory_info{};
3748 Handle process_handle{};
3749 uint64_t address{};
3750
3751 out_memory_info = Convert<uint64_t>(GetReg64(system, 0));
3752 process_handle = Convert<Handle>(GetReg64(system, 2));
3753 address = Convert<uint64_t>(GetReg64(system, 3));
3754
3755 ret = QueryProcessMemory64(system, out_memory_info, &out_page_info, process_handle, address);
3756
3757 SetReg64(system, 0, Convert<uint64_t>(ret));
3758 SetReg64(system, 1, Convert<uint64_t>(out_page_info));
3759}
3760
3761static void SvcWrap_MapProcessCodeMemory64(Core::System& system) {
3762 Result ret{};
3763
3764 Handle process_handle{};
3765 uint64_t dst_address{};
3766 uint64_t src_address{};
3767 uint64_t size{};
3768
3769 process_handle = Convert<Handle>(GetReg64(system, 0));
3770 dst_address = Convert<uint64_t>(GetReg64(system, 1));
3771 src_address = Convert<uint64_t>(GetReg64(system, 2));
3772 size = Convert<uint64_t>(GetReg64(system, 3));
3773
3774 ret = MapProcessCodeMemory64(system, process_handle, dst_address, src_address, size);
3775
3776 SetReg64(system, 0, Convert<uint64_t>(ret));
3777}
3778
3779static void SvcWrap_UnmapProcessCodeMemory64(Core::System& system) {
3780 Result ret{};
3781
3782 Handle process_handle{};
3783 uint64_t dst_address{};
3784 uint64_t src_address{};
3785 uint64_t size{};
3786
3787 process_handle = Convert<Handle>(GetReg64(system, 0));
3788 dst_address = Convert<uint64_t>(GetReg64(system, 1));
3789 src_address = Convert<uint64_t>(GetReg64(system, 2));
3790 size = Convert<uint64_t>(GetReg64(system, 3));
3791
3792 ret = UnmapProcessCodeMemory64(system, process_handle, dst_address, src_address, size);
3793
3794 SetReg64(system, 0, Convert<uint64_t>(ret));
3795}
3796
3797static void SvcWrap_CreateProcess64(Core::System& system) {
3798 Result ret{};
3799
3800 Handle out_handle{};
3801 uint64_t parameters{};
3802 uint64_t caps{};
3803 int32_t num_caps{};
3804
3805 parameters = Convert<uint64_t>(GetReg64(system, 1));
3806 caps = Convert<uint64_t>(GetReg64(system, 2));
3807 num_caps = Convert<int32_t>(GetReg64(system, 3));
3808
3809 ret = CreateProcess64(system, &out_handle, parameters, caps, num_caps);
3810
3811 SetReg64(system, 0, Convert<uint64_t>(ret));
3812 SetReg64(system, 1, Convert<uint64_t>(out_handle));
3813}
3814
3815static void SvcWrap_StartProcess64(Core::System& system) {
3816 Result ret{};
3817
3818 Handle process_handle{};
3819 int32_t priority{};
3820 int32_t core_id{};
3821 uint64_t main_thread_stack_size{};
3822
3823 process_handle = Convert<Handle>(GetReg64(system, 0));
3824 priority = Convert<int32_t>(GetReg64(system, 1));
3825 core_id = Convert<int32_t>(GetReg64(system, 2));
3826 main_thread_stack_size = Convert<uint64_t>(GetReg64(system, 3));
3827
3828 ret = StartProcess64(system, process_handle, priority, core_id, main_thread_stack_size);
3829
3830 SetReg64(system, 0, Convert<uint64_t>(ret));
3831}
3832
3833static void SvcWrap_TerminateProcess64(Core::System& system) {
3834 Result ret{};
3835
3836 Handle process_handle{};
3837
3838 process_handle = Convert<Handle>(GetReg64(system, 0));
3839
3840 ret = TerminateProcess64(system, process_handle);
3841
3842 SetReg64(system, 0, Convert<uint64_t>(ret));
3843}
3844
3845static void SvcWrap_GetProcessInfo64(Core::System& system) {
3846 Result ret{};
3847
3848 int64_t out_info{};
3849 Handle process_handle{};
3850 ProcessInfoType info_type{};
3851
3852 process_handle = Convert<Handle>(GetReg64(system, 1));
3853 info_type = Convert<ProcessInfoType>(GetReg64(system, 2));
3854
3855 ret = GetProcessInfo64(system, &out_info, process_handle, info_type);
3856
3857 SetReg64(system, 0, Convert<uint64_t>(ret));
3858 SetReg64(system, 1, Convert<uint64_t>(out_info));
3859}
3860
3861static void SvcWrap_CreateResourceLimit64(Core::System& system) {
3862 Result ret{};
3863
3864 Handle out_handle{};
3865
3866 ret = CreateResourceLimit64(system, &out_handle);
3867
3868 SetReg64(system, 0, Convert<uint64_t>(ret));
3869 SetReg64(system, 1, Convert<uint64_t>(out_handle));
3870}
3871
3872static void SvcWrap_SetResourceLimitLimitValue64(Core::System& system) {
3873 Result ret{};
3874
3875 Handle resource_limit_handle{};
3876 LimitableResource which{};
3877 int64_t limit_value{};
3878
3879 resource_limit_handle = Convert<Handle>(GetReg64(system, 0));
3880 which = Convert<LimitableResource>(GetReg64(system, 1));
3881 limit_value = Convert<int64_t>(GetReg64(system, 2));
3882
3883 ret = SetResourceLimitLimitValue64(system, resource_limit_handle, which, limit_value);
3884
3885 SetReg64(system, 0, Convert<uint64_t>(ret));
3886}
3887
3888static void SvcWrap_MapInsecureMemory64(Core::System& system) {
3889 Result ret{};
3890
3891 uint64_t address{};
3892 uint64_t size{};
3893
3894 address = Convert<uint64_t>(GetReg64(system, 0));
3895 size = Convert<uint64_t>(GetReg64(system, 1));
3896
3897 ret = MapInsecureMemory64(system, address, size);
3898
3899 SetReg64(system, 0, Convert<uint64_t>(ret));
3900}
3901
3902static void SvcWrap_UnmapInsecureMemory64(Core::System& system) {
3903 Result ret{};
3904
3905 uint64_t address{};
3906 uint64_t size{};
3907
3908 address = Convert<uint64_t>(GetReg64(system, 0));
3909 size = Convert<uint64_t>(GetReg64(system, 1));
3910
3911 ret = UnmapInsecureMemory64(system, address, size);
3912
3913 SetReg64(system, 0, Convert<uint64_t>(ret));
3914}
3915
3916static void Call32(Core::System& system, u32 imm) {
3917 switch (static_cast<SvcId>(imm)) {
3918 case SvcId::SetHeapSize:
3919 return SvcWrap_SetHeapSize64From32(system);
3920 case SvcId::SetMemoryPermission:
3921 return SvcWrap_SetMemoryPermission64From32(system);
3922 case SvcId::SetMemoryAttribute:
3923 return SvcWrap_SetMemoryAttribute64From32(system);
3924 case SvcId::MapMemory:
3925 return SvcWrap_MapMemory64From32(system);
3926 case SvcId::UnmapMemory:
3927 return SvcWrap_UnmapMemory64From32(system);
3928 case SvcId::QueryMemory:
3929 return SvcWrap_QueryMemory64From32(system);
3930 case SvcId::ExitProcess:
3931 return SvcWrap_ExitProcess64From32(system);
3932 case SvcId::CreateThread:
3933 return SvcWrap_CreateThread64From32(system);
3934 case SvcId::StartThread:
3935 return SvcWrap_StartThread64From32(system);
3936 case SvcId::ExitThread:
3937 return SvcWrap_ExitThread64From32(system);
3938 case SvcId::SleepThread:
3939 return SvcWrap_SleepThread64From32(system);
3940 case SvcId::GetThreadPriority:
3941 return SvcWrap_GetThreadPriority64From32(system);
3942 case SvcId::SetThreadPriority:
3943 return SvcWrap_SetThreadPriority64From32(system);
3944 case SvcId::GetThreadCoreMask:
3945 return SvcWrap_GetThreadCoreMask64From32(system);
3946 case SvcId::SetThreadCoreMask:
3947 return SvcWrap_SetThreadCoreMask64From32(system);
3948 case SvcId::GetCurrentProcessorNumber:
3949 return SvcWrap_GetCurrentProcessorNumber64From32(system);
3950 case SvcId::SignalEvent:
3951 return SvcWrap_SignalEvent64From32(system);
3952 case SvcId::ClearEvent:
3953 return SvcWrap_ClearEvent64From32(system);
3954 case SvcId::MapSharedMemory:
3955 return SvcWrap_MapSharedMemory64From32(system);
3956 case SvcId::UnmapSharedMemory:
3957 return SvcWrap_UnmapSharedMemory64From32(system);
3958 case SvcId::CreateTransferMemory:
3959 return SvcWrap_CreateTransferMemory64From32(system);
3960 case SvcId::CloseHandle:
3961 return SvcWrap_CloseHandle64From32(system);
3962 case SvcId::ResetSignal:
3963 return SvcWrap_ResetSignal64From32(system);
3964 case SvcId::WaitSynchronization:
3965 return SvcWrap_WaitSynchronization64From32(system);
3966 case SvcId::CancelSynchronization:
3967 return SvcWrap_CancelSynchronization64From32(system);
3968 case SvcId::ArbitrateLock:
3969 return SvcWrap_ArbitrateLock64From32(system);
3970 case SvcId::ArbitrateUnlock:
3971 return SvcWrap_ArbitrateUnlock64From32(system);
3972 case SvcId::WaitProcessWideKeyAtomic:
3973 return SvcWrap_WaitProcessWideKeyAtomic64From32(system);
3974 case SvcId::SignalProcessWideKey:
3975 return SvcWrap_SignalProcessWideKey64From32(system);
3976 case SvcId::GetSystemTick:
3977 return SvcWrap_GetSystemTick64From32(system);
3978 case SvcId::ConnectToNamedPort:
3979 return SvcWrap_ConnectToNamedPort64From32(system);
3980 case SvcId::SendSyncRequestLight:
3981 return SvcWrap_SendSyncRequestLight64From32(system);
3982 case SvcId::SendSyncRequest:
3983 return SvcWrap_SendSyncRequest64From32(system);
3984 case SvcId::SendSyncRequestWithUserBuffer:
3985 return SvcWrap_SendSyncRequestWithUserBuffer64From32(system);
3986 case SvcId::SendAsyncRequestWithUserBuffer:
3987 return SvcWrap_SendAsyncRequestWithUserBuffer64From32(system);
3988 case SvcId::GetProcessId:
3989 return SvcWrap_GetProcessId64From32(system);
3990 case SvcId::GetThreadId:
3991 return SvcWrap_GetThreadId64From32(system);
3992 case SvcId::Break:
3993 return SvcWrap_Break64From32(system);
3994 case SvcId::OutputDebugString:
3995 return SvcWrap_OutputDebugString64From32(system);
3996 case SvcId::ReturnFromException:
3997 return SvcWrap_ReturnFromException64From32(system);
3998 case SvcId::GetInfo:
3999 return SvcWrap_GetInfo64From32(system);
4000 case SvcId::FlushEntireDataCache:
4001 return SvcWrap_FlushEntireDataCache64From32(system);
4002 case SvcId::FlushDataCache:
4003 return SvcWrap_FlushDataCache64From32(system);
4004 case SvcId::MapPhysicalMemory:
4005 return SvcWrap_MapPhysicalMemory64From32(system);
4006 case SvcId::UnmapPhysicalMemory:
4007 return SvcWrap_UnmapPhysicalMemory64From32(system);
4008 case SvcId::GetDebugFutureThreadInfo:
4009 return SvcWrap_GetDebugFutureThreadInfo64From32(system);
4010 case SvcId::GetLastThreadInfo:
4011 return SvcWrap_GetLastThreadInfo64From32(system);
4012 case SvcId::GetResourceLimitLimitValue:
4013 return SvcWrap_GetResourceLimitLimitValue64From32(system);
4014 case SvcId::GetResourceLimitCurrentValue:
4015 return SvcWrap_GetResourceLimitCurrentValue64From32(system);
4016 case SvcId::SetThreadActivity:
4017 return SvcWrap_SetThreadActivity64From32(system);
4018 case SvcId::GetThreadContext3:
4019 return SvcWrap_GetThreadContext364From32(system);
4020 case SvcId::WaitForAddress:
4021 return SvcWrap_WaitForAddress64From32(system);
4022 case SvcId::SignalToAddress:
4023 return SvcWrap_SignalToAddress64From32(system);
4024 case SvcId::SynchronizePreemptionState:
4025 return SvcWrap_SynchronizePreemptionState64From32(system);
4026 case SvcId::GetResourceLimitPeakValue:
4027 return SvcWrap_GetResourceLimitPeakValue64From32(system);
4028 case SvcId::CreateIoPool:
4029 return SvcWrap_CreateIoPool64From32(system);
4030 case SvcId::CreateIoRegion:
4031 return SvcWrap_CreateIoRegion64From32(system);
4032 case SvcId::KernelDebug:
4033 return SvcWrap_KernelDebug64From32(system);
4034 case SvcId::ChangeKernelTraceState:
4035 return SvcWrap_ChangeKernelTraceState64From32(system);
4036 case SvcId::CreateSession:
4037 return SvcWrap_CreateSession64From32(system);
4038 case SvcId::AcceptSession:
4039 return SvcWrap_AcceptSession64From32(system);
4040 case SvcId::ReplyAndReceiveLight:
4041 return SvcWrap_ReplyAndReceiveLight64From32(system);
4042 case SvcId::ReplyAndReceive:
4043 return SvcWrap_ReplyAndReceive64From32(system);
4044 case SvcId::ReplyAndReceiveWithUserBuffer:
4045 return SvcWrap_ReplyAndReceiveWithUserBuffer64From32(system);
4046 case SvcId::CreateEvent:
4047 return SvcWrap_CreateEvent64From32(system);
4048 case SvcId::MapIoRegion:
4049 return SvcWrap_MapIoRegion64From32(system);
4050 case SvcId::UnmapIoRegion:
4051 return SvcWrap_UnmapIoRegion64From32(system);
4052 case SvcId::MapPhysicalMemoryUnsafe:
4053 return SvcWrap_MapPhysicalMemoryUnsafe64From32(system);
4054 case SvcId::UnmapPhysicalMemoryUnsafe:
4055 return SvcWrap_UnmapPhysicalMemoryUnsafe64From32(system);
4056 case SvcId::SetUnsafeLimit:
4057 return SvcWrap_SetUnsafeLimit64From32(system);
4058 case SvcId::CreateCodeMemory:
4059 return SvcWrap_CreateCodeMemory64From32(system);
4060 case SvcId::ControlCodeMemory:
4061 return SvcWrap_ControlCodeMemory64From32(system);
4062 case SvcId::SleepSystem:
4063 return SvcWrap_SleepSystem64From32(system);
4064 case SvcId::ReadWriteRegister:
4065 return SvcWrap_ReadWriteRegister64From32(system);
4066 case SvcId::SetProcessActivity:
4067 return SvcWrap_SetProcessActivity64From32(system);
4068 case SvcId::CreateSharedMemory:
4069 return SvcWrap_CreateSharedMemory64From32(system);
4070 case SvcId::MapTransferMemory:
4071 return SvcWrap_MapTransferMemory64From32(system);
4072 case SvcId::UnmapTransferMemory:
4073 return SvcWrap_UnmapTransferMemory64From32(system);
4074 case SvcId::CreateInterruptEvent:
4075 return SvcWrap_CreateInterruptEvent64From32(system);
4076 case SvcId::QueryPhysicalAddress:
4077 return SvcWrap_QueryPhysicalAddress64From32(system);
4078 case SvcId::QueryIoMapping:
4079 return SvcWrap_QueryIoMapping64From32(system);
4080 case SvcId::CreateDeviceAddressSpace:
4081 return SvcWrap_CreateDeviceAddressSpace64From32(system);
4082 case SvcId::AttachDeviceAddressSpace:
4083 return SvcWrap_AttachDeviceAddressSpace64From32(system);
4084 case SvcId::DetachDeviceAddressSpace:
4085 return SvcWrap_DetachDeviceAddressSpace64From32(system);
4086 case SvcId::MapDeviceAddressSpaceByForce:
4087 return SvcWrap_MapDeviceAddressSpaceByForce64From32(system);
4088 case SvcId::MapDeviceAddressSpaceAligned:
4089 return SvcWrap_MapDeviceAddressSpaceAligned64From32(system);
4090 case SvcId::UnmapDeviceAddressSpace:
4091 return SvcWrap_UnmapDeviceAddressSpace64From32(system);
4092 case SvcId::InvalidateProcessDataCache:
4093 return SvcWrap_InvalidateProcessDataCache64From32(system);
4094 case SvcId::StoreProcessDataCache:
4095 return SvcWrap_StoreProcessDataCache64From32(system);
4096 case SvcId::FlushProcessDataCache:
4097 return SvcWrap_FlushProcessDataCache64From32(system);
4098 case SvcId::DebugActiveProcess:
4099 return SvcWrap_DebugActiveProcess64From32(system);
4100 case SvcId::BreakDebugProcess:
4101 return SvcWrap_BreakDebugProcess64From32(system);
4102 case SvcId::TerminateDebugProcess:
4103 return SvcWrap_TerminateDebugProcess64From32(system);
4104 case SvcId::GetDebugEvent:
4105 return SvcWrap_GetDebugEvent64From32(system);
4106 case SvcId::ContinueDebugEvent:
4107 return SvcWrap_ContinueDebugEvent64From32(system);
4108 case SvcId::GetProcessList:
4109 return SvcWrap_GetProcessList64From32(system);
4110 case SvcId::GetThreadList:
4111 return SvcWrap_GetThreadList64From32(system);
4112 case SvcId::GetDebugThreadContext:
4113 return SvcWrap_GetDebugThreadContext64From32(system);
4114 case SvcId::SetDebugThreadContext:
4115 return SvcWrap_SetDebugThreadContext64From32(system);
4116 case SvcId::QueryDebugProcessMemory:
4117 return SvcWrap_QueryDebugProcessMemory64From32(system);
4118 case SvcId::ReadDebugProcessMemory:
4119 return SvcWrap_ReadDebugProcessMemory64From32(system);
4120 case SvcId::WriteDebugProcessMemory:
4121 return SvcWrap_WriteDebugProcessMemory64From32(system);
4122 case SvcId::SetHardwareBreakPoint:
4123 return SvcWrap_SetHardwareBreakPoint64From32(system);
4124 case SvcId::GetDebugThreadParam:
4125 return SvcWrap_GetDebugThreadParam64From32(system);
4126 case SvcId::GetSystemInfo:
4127 return SvcWrap_GetSystemInfo64From32(system);
4128 case SvcId::CreatePort:
4129 return SvcWrap_CreatePort64From32(system);
4130 case SvcId::ManageNamedPort:
4131 return SvcWrap_ManageNamedPort64From32(system);
4132 case SvcId::ConnectToPort:
4133 return SvcWrap_ConnectToPort64From32(system);
4134 case SvcId::SetProcessMemoryPermission:
4135 return SvcWrap_SetProcessMemoryPermission64From32(system);
4136 case SvcId::MapProcessMemory:
4137 return SvcWrap_MapProcessMemory64From32(system);
4138 case SvcId::UnmapProcessMemory:
4139 return SvcWrap_UnmapProcessMemory64From32(system);
4140 case SvcId::QueryProcessMemory:
4141 return SvcWrap_QueryProcessMemory64From32(system);
4142 case SvcId::MapProcessCodeMemory:
4143 return SvcWrap_MapProcessCodeMemory64From32(system);
4144 case SvcId::UnmapProcessCodeMemory:
4145 return SvcWrap_UnmapProcessCodeMemory64From32(system);
4146 case SvcId::CreateProcess:
4147 return SvcWrap_CreateProcess64From32(system);
4148 case SvcId::StartProcess:
4149 return SvcWrap_StartProcess64From32(system);
4150 case SvcId::TerminateProcess:
4151 return SvcWrap_TerminateProcess64From32(system);
4152 case SvcId::GetProcessInfo:
4153 return SvcWrap_GetProcessInfo64From32(system);
4154 case SvcId::CreateResourceLimit:
4155 return SvcWrap_CreateResourceLimit64From32(system);
4156 case SvcId::SetResourceLimitLimitValue:
4157 return SvcWrap_SetResourceLimitLimitValue64From32(system);
4158 case SvcId::CallSecureMonitor:
4159 return SvcWrap_CallSecureMonitor64From32(system);
4160 case SvcId::MapInsecureMemory:
4161 return SvcWrap_MapInsecureMemory64From32(system);
4162 case SvcId::UnmapInsecureMemory:
4163 return SvcWrap_UnmapInsecureMemory64From32(system);
4164 default:
4165 LOG_CRITICAL(Kernel_SVC, "Unknown SVC {:x}!", imm);
4166 break;
418 } 4167 }
419 return &SVC_Table_32[func_num];
420} 4168}
421 4169
422static const FunctionDef* GetSVCInfo64(u32 func_num) { 4170static void Call64(Core::System& system, u32 imm) {
423 if (func_num >= std::size(SVC_Table_64)) { 4171 switch (static_cast<SvcId>(imm)) {
424 LOG_ERROR(Kernel_SVC, "Unknown svc=0x{:02X}", func_num); 4172 case SvcId::SetHeapSize:
425 return nullptr; 4173 return SvcWrap_SetHeapSize64(system);
4174 case SvcId::SetMemoryPermission:
4175 return SvcWrap_SetMemoryPermission64(system);
4176 case SvcId::SetMemoryAttribute:
4177 return SvcWrap_SetMemoryAttribute64(system);
4178 case SvcId::MapMemory:
4179 return SvcWrap_MapMemory64(system);
4180 case SvcId::UnmapMemory:
4181 return SvcWrap_UnmapMemory64(system);
4182 case SvcId::QueryMemory:
4183 return SvcWrap_QueryMemory64(system);
4184 case SvcId::ExitProcess:
4185 return SvcWrap_ExitProcess64(system);
4186 case SvcId::CreateThread:
4187 return SvcWrap_CreateThread64(system);
4188 case SvcId::StartThread:
4189 return SvcWrap_StartThread64(system);
4190 case SvcId::ExitThread:
4191 return SvcWrap_ExitThread64(system);
4192 case SvcId::SleepThread:
4193 return SvcWrap_SleepThread64(system);
4194 case SvcId::GetThreadPriority:
4195 return SvcWrap_GetThreadPriority64(system);
4196 case SvcId::SetThreadPriority:
4197 return SvcWrap_SetThreadPriority64(system);
4198 case SvcId::GetThreadCoreMask:
4199 return SvcWrap_GetThreadCoreMask64(system);
4200 case SvcId::SetThreadCoreMask:
4201 return SvcWrap_SetThreadCoreMask64(system);
4202 case SvcId::GetCurrentProcessorNumber:
4203 return SvcWrap_GetCurrentProcessorNumber64(system);
4204 case SvcId::SignalEvent:
4205 return SvcWrap_SignalEvent64(system);
4206 case SvcId::ClearEvent:
4207 return SvcWrap_ClearEvent64(system);
4208 case SvcId::MapSharedMemory:
4209 return SvcWrap_MapSharedMemory64(system);
4210 case SvcId::UnmapSharedMemory:
4211 return SvcWrap_UnmapSharedMemory64(system);
4212 case SvcId::CreateTransferMemory:
4213 return SvcWrap_CreateTransferMemory64(system);
4214 case SvcId::CloseHandle:
4215 return SvcWrap_CloseHandle64(system);
4216 case SvcId::ResetSignal:
4217 return SvcWrap_ResetSignal64(system);
4218 case SvcId::WaitSynchronization:
4219 return SvcWrap_WaitSynchronization64(system);
4220 case SvcId::CancelSynchronization:
4221 return SvcWrap_CancelSynchronization64(system);
4222 case SvcId::ArbitrateLock:
4223 return SvcWrap_ArbitrateLock64(system);
4224 case SvcId::ArbitrateUnlock:
4225 return SvcWrap_ArbitrateUnlock64(system);
4226 case SvcId::WaitProcessWideKeyAtomic:
4227 return SvcWrap_WaitProcessWideKeyAtomic64(system);
4228 case SvcId::SignalProcessWideKey:
4229 return SvcWrap_SignalProcessWideKey64(system);
4230 case SvcId::GetSystemTick:
4231 return SvcWrap_GetSystemTick64(system);
4232 case SvcId::ConnectToNamedPort:
4233 return SvcWrap_ConnectToNamedPort64(system);
4234 case SvcId::SendSyncRequestLight:
4235 return SvcWrap_SendSyncRequestLight64(system);
4236 case SvcId::SendSyncRequest:
4237 return SvcWrap_SendSyncRequest64(system);
4238 case SvcId::SendSyncRequestWithUserBuffer:
4239 return SvcWrap_SendSyncRequestWithUserBuffer64(system);
4240 case SvcId::SendAsyncRequestWithUserBuffer:
4241 return SvcWrap_SendAsyncRequestWithUserBuffer64(system);
4242 case SvcId::GetProcessId:
4243 return SvcWrap_GetProcessId64(system);
4244 case SvcId::GetThreadId:
4245 return SvcWrap_GetThreadId64(system);
4246 case SvcId::Break:
4247 return SvcWrap_Break64(system);
4248 case SvcId::OutputDebugString:
4249 return SvcWrap_OutputDebugString64(system);
4250 case SvcId::ReturnFromException:
4251 return SvcWrap_ReturnFromException64(system);
4252 case SvcId::GetInfo:
4253 return SvcWrap_GetInfo64(system);
4254 case SvcId::FlushEntireDataCache:
4255 return SvcWrap_FlushEntireDataCache64(system);
4256 case SvcId::FlushDataCache:
4257 return SvcWrap_FlushDataCache64(system);
4258 case SvcId::MapPhysicalMemory:
4259 return SvcWrap_MapPhysicalMemory64(system);
4260 case SvcId::UnmapPhysicalMemory:
4261 return SvcWrap_UnmapPhysicalMemory64(system);
4262 case SvcId::GetDebugFutureThreadInfo:
4263 return SvcWrap_GetDebugFutureThreadInfo64(system);
4264 case SvcId::GetLastThreadInfo:
4265 return SvcWrap_GetLastThreadInfo64(system);
4266 case SvcId::GetResourceLimitLimitValue:
4267 return SvcWrap_GetResourceLimitLimitValue64(system);
4268 case SvcId::GetResourceLimitCurrentValue:
4269 return SvcWrap_GetResourceLimitCurrentValue64(system);
4270 case SvcId::SetThreadActivity:
4271 return SvcWrap_SetThreadActivity64(system);
4272 case SvcId::GetThreadContext3:
4273 return SvcWrap_GetThreadContext364(system);
4274 case SvcId::WaitForAddress:
4275 return SvcWrap_WaitForAddress64(system);
4276 case SvcId::SignalToAddress:
4277 return SvcWrap_SignalToAddress64(system);
4278 case SvcId::SynchronizePreemptionState:
4279 return SvcWrap_SynchronizePreemptionState64(system);
4280 case SvcId::GetResourceLimitPeakValue:
4281 return SvcWrap_GetResourceLimitPeakValue64(system);
4282 case SvcId::CreateIoPool:
4283 return SvcWrap_CreateIoPool64(system);
4284 case SvcId::CreateIoRegion:
4285 return SvcWrap_CreateIoRegion64(system);
4286 case SvcId::KernelDebug:
4287 return SvcWrap_KernelDebug64(system);
4288 case SvcId::ChangeKernelTraceState:
4289 return SvcWrap_ChangeKernelTraceState64(system);
4290 case SvcId::CreateSession:
4291 return SvcWrap_CreateSession64(system);
4292 case SvcId::AcceptSession:
4293 return SvcWrap_AcceptSession64(system);
4294 case SvcId::ReplyAndReceiveLight:
4295 return SvcWrap_ReplyAndReceiveLight64(system);
4296 case SvcId::ReplyAndReceive:
4297 return SvcWrap_ReplyAndReceive64(system);
4298 case SvcId::ReplyAndReceiveWithUserBuffer:
4299 return SvcWrap_ReplyAndReceiveWithUserBuffer64(system);
4300 case SvcId::CreateEvent:
4301 return SvcWrap_CreateEvent64(system);
4302 case SvcId::MapIoRegion:
4303 return SvcWrap_MapIoRegion64(system);
4304 case SvcId::UnmapIoRegion:
4305 return SvcWrap_UnmapIoRegion64(system);
4306 case SvcId::MapPhysicalMemoryUnsafe:
4307 return SvcWrap_MapPhysicalMemoryUnsafe64(system);
4308 case SvcId::UnmapPhysicalMemoryUnsafe:
4309 return SvcWrap_UnmapPhysicalMemoryUnsafe64(system);
4310 case SvcId::SetUnsafeLimit:
4311 return SvcWrap_SetUnsafeLimit64(system);
4312 case SvcId::CreateCodeMemory:
4313 return SvcWrap_CreateCodeMemory64(system);
4314 case SvcId::ControlCodeMemory:
4315 return SvcWrap_ControlCodeMemory64(system);
4316 case SvcId::SleepSystem:
4317 return SvcWrap_SleepSystem64(system);
4318 case SvcId::ReadWriteRegister:
4319 return SvcWrap_ReadWriteRegister64(system);
4320 case SvcId::SetProcessActivity:
4321 return SvcWrap_SetProcessActivity64(system);
4322 case SvcId::CreateSharedMemory:
4323 return SvcWrap_CreateSharedMemory64(system);
4324 case SvcId::MapTransferMemory:
4325 return SvcWrap_MapTransferMemory64(system);
4326 case SvcId::UnmapTransferMemory:
4327 return SvcWrap_UnmapTransferMemory64(system);
4328 case SvcId::CreateInterruptEvent:
4329 return SvcWrap_CreateInterruptEvent64(system);
4330 case SvcId::QueryPhysicalAddress:
4331 return SvcWrap_QueryPhysicalAddress64(system);
4332 case SvcId::QueryIoMapping:
4333 return SvcWrap_QueryIoMapping64(system);
4334 case SvcId::CreateDeviceAddressSpace:
4335 return SvcWrap_CreateDeviceAddressSpace64(system);
4336 case SvcId::AttachDeviceAddressSpace:
4337 return SvcWrap_AttachDeviceAddressSpace64(system);
4338 case SvcId::DetachDeviceAddressSpace:
4339 return SvcWrap_DetachDeviceAddressSpace64(system);
4340 case SvcId::MapDeviceAddressSpaceByForce:
4341 return SvcWrap_MapDeviceAddressSpaceByForce64(system);
4342 case SvcId::MapDeviceAddressSpaceAligned:
4343 return SvcWrap_MapDeviceAddressSpaceAligned64(system);
4344 case SvcId::UnmapDeviceAddressSpace:
4345 return SvcWrap_UnmapDeviceAddressSpace64(system);
4346 case SvcId::InvalidateProcessDataCache:
4347 return SvcWrap_InvalidateProcessDataCache64(system);
4348 case SvcId::StoreProcessDataCache:
4349 return SvcWrap_StoreProcessDataCache64(system);
4350 case SvcId::FlushProcessDataCache:
4351 return SvcWrap_FlushProcessDataCache64(system);
4352 case SvcId::DebugActiveProcess:
4353 return SvcWrap_DebugActiveProcess64(system);
4354 case SvcId::BreakDebugProcess:
4355 return SvcWrap_BreakDebugProcess64(system);
4356 case SvcId::TerminateDebugProcess:
4357 return SvcWrap_TerminateDebugProcess64(system);
4358 case SvcId::GetDebugEvent:
4359 return SvcWrap_GetDebugEvent64(system);
4360 case SvcId::ContinueDebugEvent:
4361 return SvcWrap_ContinueDebugEvent64(system);
4362 case SvcId::GetProcessList:
4363 return SvcWrap_GetProcessList64(system);
4364 case SvcId::GetThreadList:
4365 return SvcWrap_GetThreadList64(system);
4366 case SvcId::GetDebugThreadContext:
4367 return SvcWrap_GetDebugThreadContext64(system);
4368 case SvcId::SetDebugThreadContext:
4369 return SvcWrap_SetDebugThreadContext64(system);
4370 case SvcId::QueryDebugProcessMemory:
4371 return SvcWrap_QueryDebugProcessMemory64(system);
4372 case SvcId::ReadDebugProcessMemory:
4373 return SvcWrap_ReadDebugProcessMemory64(system);
4374 case SvcId::WriteDebugProcessMemory:
4375 return SvcWrap_WriteDebugProcessMemory64(system);
4376 case SvcId::SetHardwareBreakPoint:
4377 return SvcWrap_SetHardwareBreakPoint64(system);
4378 case SvcId::GetDebugThreadParam:
4379 return SvcWrap_GetDebugThreadParam64(system);
4380 case SvcId::GetSystemInfo:
4381 return SvcWrap_GetSystemInfo64(system);
4382 case SvcId::CreatePort:
4383 return SvcWrap_CreatePort64(system);
4384 case SvcId::ManageNamedPort:
4385 return SvcWrap_ManageNamedPort64(system);
4386 case SvcId::ConnectToPort:
4387 return SvcWrap_ConnectToPort64(system);
4388 case SvcId::SetProcessMemoryPermission:
4389 return SvcWrap_SetProcessMemoryPermission64(system);
4390 case SvcId::MapProcessMemory:
4391 return SvcWrap_MapProcessMemory64(system);
4392 case SvcId::UnmapProcessMemory:
4393 return SvcWrap_UnmapProcessMemory64(system);
4394 case SvcId::QueryProcessMemory:
4395 return SvcWrap_QueryProcessMemory64(system);
4396 case SvcId::MapProcessCodeMemory:
4397 return SvcWrap_MapProcessCodeMemory64(system);
4398 case SvcId::UnmapProcessCodeMemory:
4399 return SvcWrap_UnmapProcessCodeMemory64(system);
4400 case SvcId::CreateProcess:
4401 return SvcWrap_CreateProcess64(system);
4402 case SvcId::StartProcess:
4403 return SvcWrap_StartProcess64(system);
4404 case SvcId::TerminateProcess:
4405 return SvcWrap_TerminateProcess64(system);
4406 case SvcId::GetProcessInfo:
4407 return SvcWrap_GetProcessInfo64(system);
4408 case SvcId::CreateResourceLimit:
4409 return SvcWrap_CreateResourceLimit64(system);
4410 case SvcId::SetResourceLimitLimitValue:
4411 return SvcWrap_SetResourceLimitLimitValue64(system);
4412 case SvcId::CallSecureMonitor:
4413 return SvcWrap_CallSecureMonitor64(system);
4414 case SvcId::MapInsecureMemory:
4415 return SvcWrap_MapInsecureMemory64(system);
4416 case SvcId::UnmapInsecureMemory:
4417 return SvcWrap_UnmapInsecureMemory64(system);
4418 default:
4419 LOG_CRITICAL(Kernel_SVC, "Unknown SVC {:x}!", imm);
4420 break;
426 } 4421 }
427 return &SVC_Table_64[func_num];
428} 4422}
4423// clang-format on
429 4424
430void Call(Core::System& system, u32 immediate) { 4425void Call(Core::System& system, u32 imm) {
431 auto& kernel = system.Kernel(); 4426 auto& kernel = system.Kernel();
432 kernel.EnterSVCProfile(); 4427 kernel.EnterSVCProfile();
433 4428
434 auto* thread = GetCurrentThreadPointer(kernel); 4429 if (system.CurrentProcess()->Is64BitProcess()) {
435 thread->SetIsCallingSvc(); 4430 Call64(system, imm);
436
437 const FunctionDef* info = system.CurrentProcess()->Is64BitProcess() ? GetSVCInfo64(immediate)
438 : GetSVCInfo32(immediate);
439 if (info) {
440 if (info->func) {
441 info->func(system);
442 } else {
443 LOG_CRITICAL(Kernel_SVC, "Unimplemented SVC function {}(..)", info->name);
444 }
445 } else { 4431 } else {
446 LOG_CRITICAL(Kernel_SVC, "Unknown SVC function 0x{:X}", immediate); 4432 Call32(system, imm);
447 } 4433 }
448 4434
449 kernel.ExitSVCProfile(); 4435 kernel.ExitSVCProfile();
HIC SVNT DRACONES