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