stuff/suyu
stuff/suyu
1
0
Fork 0
mirror of https://git.suyu.dev/suyu/suyu.git synced 2024-11-27 22:06:27 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions 1
suyu/src/core/hle/kernel/svc_wrap.h

553 lines
19 KiB
C++
Raw Normal View History

yuzu: Update license text to be consistent across project.
2018-01-13 16:22:39 -05:00
// Copyright 2018 yuzu emulator team
License change
2014-12-17 00:38:14 -05:00
// Licensed under GPLv2 or any later version
SVC: Cleaned up function wrappers to pass in correct argument types.
2014-06-06 23:31:29 -04:00
// Refer to the license.txt file included.
added initial modules for setting up SysCall HLE
2014-04-10 19:58:28 -04:00
#pragma once
#include "common/common_types.h"
Move ThreadContext to core/core.h and deal with the fallout
2014-12-22 01:30:09 -05:00
#include "core/arm/arm_interface.h"
Remove empty newlines in #include blocks. This makes clang-format useful on those. Also add a bunch of forgotten transitive includes, which otherwise prevented compilation.
2016-09-20 11:21:23 -04:00
#include "core/core.h"
kernel: Fix svcWaitSynch to always acquire requested wait objects.
2015-06-07 23:39:37 -04:00
#include "core/hle/result.h"
added initial modules for setting up SysCall HLE
2014-04-10 19:58:28 -04:00
hle: Move SVC code to kernel namespace.
2018-01-02 20:40:30 -05:00
namespace Kernel {
added initial modules for setting up SysCall HLE
2014-04-10 19:58:28 -04:00
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
static inline u64 Param(const Core::System& system, int n) {
return system.CurrentArmInterface().GetReg(n);
svc_wrap: Convert the PARAM macro into a function This can just be a regular function, getting rid of the need to also explicitly undef the define at the end of the file. Given FuncReturn() was already converted into a function, it's #undef can also be removed.
2018-09-18 04:25:35 -04:00
}
SVC: Added support for svc_GetSystemTick. Changed HLE function return methods to be static inline functions.
2014-08-14 20:01:02 -04:00
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
static inline u32 Param32(const Core::System& system, int n) {
return static_cast<u32>(system.CurrentArmInterface().GetReg(n));
}
SVC: Added support for svc_GetSystemTick. Changed HLE function return methods to be static inline functions.
2014-08-14 20:01:02 -04:00
/**
function_wrappers: Cleanup, fix warnings, remove unused code.
2017-12-31 15:46:30 -05:00
* HLE a function return from the current ARM userland process
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
* @param system System context
* @param result Result to return
SVC: Added support for svc_GetSystemTick. Changed HLE function return methods to be static inline functions.
2014-08-14 20:01:02 -04:00
*/
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
static inline void FuncReturn(Core::System& system, u64 result) {
system.CurrentArmInterface().SetReg(0, result);
SVC: Added support for svc_GetSystemTick. Changed HLE function return methods to be static inline functions.
2014-08-14 20:01:02 -04:00
}
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
static inline void FuncReturn32(Core::System& system, u32 result) {
system.CurrentArmInterface().SetReg(0, (u64)result);
}
SVC: Cleaned up function wrappers to pass in correct argument types.
2014-06-06 23:31:29 -04:00
////////////////////////////////////////////////////////////////////////////////////////////////////
SVC: Change return type of handlers to ResultCode
2015-01-23 00:36:58 -05:00
// Function wrappers that return type ResultCode
added initial modules for setting up SysCall HLE
2014-04-10 19:58:28 -04:00
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
template <ResultCode func(Core::System&, u64)>
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
void SvcWrap64(Core::System& system) {
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
FuncReturn(system, func(system, Param(system, 0)).raw);
Merge remote-tracking branch 'upstream/master' into nx # Conflicts: # src/core/CMakeLists.txt # src/core/arm/dynarmic/arm_dynarmic.cpp # src/core/arm/dyncom/arm_dyncom.cpp # src/core/hle/kernel/process.cpp # src/core/hle/kernel/thread.cpp # src/core/hle/kernel/thread.h # src/core/hle/kernel/vm_manager.cpp # src/core/loader/3dsx.cpp # src/core/loader/elf.cpp # src/core/loader/ncch.cpp # src/core/memory.cpp # src/core/memory.h # src/core/memory_setup.h
2017-10-09 23:56:20 -04:00
}
Implement MapPhysicalMemory/UnmapPhysicalMemory This implements svcMapPhysicalMemory/svcUnmapPhysicalMemory for Yuzu, which can be used to map memory at a desired address by games since 3.0.0. It also properly parses SystemResourceSize from NPDM, and makes information available via svcGetInfo. This is needed for games like Super Smash Bros. and Diablo 3 -- this PR's implementation does not run into the "ASCII reads" issue mentioned in the comments of #2626, which was caused by the following bugs in Yuzu's memory management that this PR also addresses: * Yuzu's memory coalescing does not properly merge blocks. This results in a polluted address space/svcQueryMemory results that would be impossible to replicate on hardware, which can lead to game code making the wrong assumptions about memory layout. * This implements better merging for AllocatedMemoryBlocks. * Yuzu's implementation of svcMirrorMemory unprotected the entire virtual memory range containing the range being mirrored. This could lead to games attempting to map data at that unprotected range/attempting to access that range after yuzu improperly unmapped it. * This PR fixes it by simply calling ReprotectRange instead of Reprotect.
2019-07-07 12:42:54 -04:00
template <ResultCode func(Core::System&, u64, u64)>
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
void SvcWrap64(Core::System& system) {
Implement MapPhysicalMemory/UnmapPhysicalMemory This implements svcMapPhysicalMemory/svcUnmapPhysicalMemory for Yuzu, which can be used to map memory at a desired address by games since 3.0.0. It also properly parses SystemResourceSize from NPDM, and makes information available via svcGetInfo. This is needed for games like Super Smash Bros. and Diablo 3 -- this PR's implementation does not run into the "ASCII reads" issue mentioned in the comments of #2626, which was caused by the following bugs in Yuzu's memory management that this PR also addresses: * Yuzu's memory coalescing does not properly merge blocks. This results in a polluted address space/svcQueryMemory results that would be impossible to replicate on hardware, which can lead to game code making the wrong assumptions about memory layout. * This implements better merging for AllocatedMemoryBlocks. * Yuzu's implementation of svcMirrorMemory unprotected the entire virtual memory range containing the range being mirrored. This could lead to games attempting to map data at that unprotected range/attempting to access that range after yuzu improperly unmapped it. * This PR fixes it by simply calling ReprotectRange instead of Reprotect.
2019-07-07 12:42:54 -04:00
FuncReturn(system, func(system, Param(system, 0), Param(system, 1)).raw);
}
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
template <ResultCode func(Core::System&, u32)>
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
void SvcWrap64(Core::System& system) {
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
FuncReturn(system, func(system, static_cast<u32>(Param(system, 0))).raw);
svc: Implement MapMemory.
2017-12-28 21:38:38 -05:00
}
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
template <ResultCode func(Core::System&, u32, u32)>
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
void SvcWrap64(Core::System& system) {
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
FuncReturn(
system,
func(system, static_cast<u32>(Param(system, 0)), static_cast<u32>(Param(system, 1))).raw);
svc: Implement SetHeapSize.
2017-12-28 15:29:52 -05:00
}
kernel/svc: Implement svcMapProcessCodeMemory This is utilized for mapping code modules into memory. Notably, the ldr service would call this in order to map objects into memory.
2019-04-11 23:21:13 -04:00
template <ResultCode func(Core::System&, u32, u64, u64, u64)>
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
void SvcWrap64(Core::System& system) {
kernel/svc: Implement svcMapProcessCodeMemory This is utilized for mapping code modules into memory. Notably, the ldr service would call this in order to map objects into memory.
2019-04-11 23:21:13 -04:00
FuncReturn(system, func(system, static_cast<u32>(Param(system, 0)), Param(system, 1),
Param(system, 2), Param(system, 3))
.raw);
}
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
template <ResultCode func(Core::System&, u32*)>
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
void SvcWrap64(Core::System& system) {
svc: Implement svcCreateResourceLimit() This function simply creates a ResourceLimit instance and attempts to create a handle for it within the current process' handle table. If the kernal fails to either create the ResourceLimit instance or create a handle for the ResourceLimit instance, it returns a failure code (OUT_OF_RESOURCE, and HANDLE_TABLE_FULL respectively). Finally, it exits by providing the output parameter with the handle value for the ResourceLimit instance and returning that it was successful. Note: We do not return OUT_OF_RESOURCE because, if yuzu runs out of available memory, then new will currently throw. We *could* allocate the kernel instance with std::nothrow, however this would be inconsistent with how all other kernel objects are currently allocated.
2018-11-26 18:23:12 -05:00
u32 param = 0;
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
const u32 retval = func(system, &param).raw;
system.CurrentArmInterface().SetReg(1, param);
FuncReturn(system, retval);
svc: Implement svcCreateResourceLimit() This function simply creates a ResourceLimit instance and attempts to create a handle for it within the current process' handle table. If the kernal fails to either create the ResourceLimit instance or create a handle for the ResourceLimit instance, it returns a failure code (OUT_OF_RESOURCE, and HANDLE_TABLE_FULL respectively). Finally, it exits by providing the output parameter with the handle value for the ResourceLimit instance and returning that it was successful. Note: We do not return OUT_OF_RESOURCE because, if yuzu runs out of available memory, then new will currently throw. We *could* allocate the kernel instance with std::nothrow, however this would be inconsistent with how all other kernel objects are currently allocated.
2018-11-26 18:23:12 -05:00
}
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
template <ResultCode func(Core::System&, u32*, u32)>
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
void SvcWrap64(Core::System& system) {
function_wrappers: Cleanup, fix warnings, remove unused code.
2017-12-31 15:46:30 -05:00
u32 param_1 = 0;
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
const u32 retval = func(system, &param_1, static_cast<u32>(Param(system, 1))).raw;
system.CurrentArmInterface().SetReg(1, param_1);
FuncReturn(system, retval);
Merge remote-tracking branch 'upstream/master' into nx # Conflicts: # src/core/CMakeLists.txt # src/core/arm/dynarmic/arm_dynarmic.cpp # src/core/arm/dyncom/arm_dyncom.cpp # src/core/hle/kernel/process.cpp # src/core/hle/kernel/thread.cpp # src/core/hle/kernel/thread.h # src/core/hle/kernel/vm_manager.cpp # src/core/loader/3dsx.cpp # src/core/loader/elf.cpp # src/core/loader/ncch.cpp # src/core/memory.cpp # src/core/memory.h # src/core/memory_setup.h
2017-10-09 23:56:20 -04:00
}
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
template <ResultCode func(Core::System&, u32*, u32*)>
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
void SvcWrap64(Core::System& system) {
kernel/svc: Implement svcCreateEvent() svcCreateEvent operates by creating both a readable and writable event and then attempts to add both to the current process' handle table. If adding either of the events to the handle table fails, then the relevant error from the handle table is returned. If adding the readable event after the writable event to the table fails, then the writable event is removed from the handle table and the relevant error from the handle table is returned. Note that since we do not currently test resource limits, we don't check the resource limit table yet.
2018-12-04 15:11:18 -05:00
u32 param_1 = 0;
u32 param_2 = 0;
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
const u32 retval = func(system, &param_1, &param_2).raw;
kernel/svc: Implement svcCreateEvent() svcCreateEvent operates by creating both a readable and writable event and then attempts to add both to the current process' handle table. If adding either of the events to the handle table fails, then the relevant error from the handle table is returned. If adding the readable event after the writable event to the table fails, then the writable event is removed from the handle table and the relevant error from the handle table is returned. Note that since we do not currently test resource limits, we don't check the resource limit table yet.
2018-12-04 15:11:18 -05:00
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
auto& arm_interface = system.CurrentArmInterface();
kernel/svc: Implement svcCreateEvent() svcCreateEvent operates by creating both a readable and writable event and then attempts to add both to the current process' handle table. If adding either of the events to the handle table fails, then the relevant error from the handle table is returned. If adding the readable event after the writable event to the table fails, then the writable event is removed from the handle table and the relevant error from the handle table is returned. Note that since we do not currently test resource limits, we don't check the resource limit table yet.
2018-12-04 15:11:18 -05:00
arm_interface.SetReg(1, param_1);
arm_interface.SetReg(2, param_2);
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
FuncReturn(system, retval);
kernel/svc: Implement svcCreateEvent() svcCreateEvent operates by creating both a readable and writable event and then attempts to add both to the current process' handle table. If adding either of the events to the handle table fails, then the relevant error from the handle table is returned. If adding the readable event after the writable event to the table fails, then the writable event is removed from the handle table and the relevant error from the handle table is returned. Note that since we do not currently test resource limits, we don't check the resource limit table yet.
2018-12-04 15:11:18 -05:00
}
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
template <ResultCode func(Core::System&, u32*, u64)>
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
void SvcWrap64(Core::System& system) {
function_wrappers: Cleanup, fix warnings, remove unused code.
2017-12-31 15:46:30 -05:00
u32 param_1 = 0;
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
const u32 retval = func(system, &param_1, Param(system, 1)).raw;
system.CurrentArmInterface().SetReg(1, param_1);
FuncReturn(system, retval);
kernel/svc: Correct output parameter for svcGetProcessId svcGetProcessId's out parameter is a pointer to a 64-bit value, not a 32-bit one.
2018-12-18 22:30:53 -05:00
}
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
template <ResultCode func(Core::System&, u32*, u64, u32)>
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
void SvcWrap64(Core::System& system) {
kernel/svc: Implement svcGetProcessList This service function simply copies out a specified number of kernel process IDs, while simultaneously reporting the total number of processes.
2019-03-20 15:03:52 -04:00
u32 param_1 = 0;
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
const u32 retval =
func(system, &param_1, Param(system, 1), static_cast<u32>(Param(system, 2))).raw;
system.CurrentArmInterface().SetReg(1, param_1);
FuncReturn(system, retval);
kernel/svc: Implement svcGetProcessList This service function simply copies out a specified number of kernel process IDs, while simultaneously reporting the total number of processes.
2019-03-20 15:03:52 -04:00
}
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
template <ResultCode func(Core::System&, u64*, u32)>
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
void SvcWrap64(Core::System& system) {
kernel/svc: Correct output parameter for svcGetProcessId svcGetProcessId's out parameter is a pointer to a 64-bit value, not a 32-bit one.
2018-12-18 22:30:53 -05:00
u64 param_1 = 0;
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
const u32 retval = func(system, &param_1, static_cast<u32>(Param(system, 1))).raw;
system.CurrentArmInterface().SetReg(1, param_1);
FuncReturn(system, retval);
Merge remote-tracking branch 'upstream/master' into nx # Conflicts: # src/core/CMakeLists.txt # src/core/arm/dynarmic/arm_dynarmic.cpp # src/core/arm/dyncom/arm_dyncom.cpp # src/core/hle/kernel/process.cpp # src/core/hle/kernel/thread.cpp # src/core/hle/kernel/thread.h # src/core/hle/kernel/vm_manager.cpp # src/core/loader/3dsx.cpp # src/core/loader/elf.cpp # src/core/loader/ncch.cpp # src/core/memory.cpp # src/core/memory.h # src/core/memory_setup.h
2017-10-09 23:56:20 -04:00
}
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
template <ResultCode func(Core::System&, u64, u32)>
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
void SvcWrap64(Core::System& system) {
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
FuncReturn(system, func(system, Param(system, 0), static_cast<u32>(Param(system, 1))).raw);
kernel/svc: Implement svcGetThreadContext() Now that we have all of the rearranging and proper structure sizes in place, it's fairly trivial to implement svcGetThreadContext(). In the 64-bit case we can more or less just write out the context as is, minus some minor value sanitizing. In the 32-bit case we'll need to clear out the registers that wouldn't normally be accessible from a 32-bit AArch32 exectuable (or process).
2018-09-29 19:58:21 -04:00
}
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
template <ResultCode func(Core::System&, u64*, u64)>
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
void SvcWrap64(Core::System& system) {
function_wrappers: Cleanup, fix warnings, remove unused code.
2017-12-31 15:46:30 -05:00
u64 param_1 = 0;
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
const u32 retval = func(system, &param_1, Param(system, 1)).raw;
system.CurrentArmInterface().SetReg(1, param_1);
FuncReturn(system, retval);
Thread: Implement priority boost for starved threads. SVC: Return correct error code on invalid CreateThread processor ID. SVC: Assert when creating a thread with an invalid userland priority.
2015-03-23 23:55:21 -04:00
}
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
template <ResultCode func(Core::System&, u64*, u32, u32)>
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
void SvcWrap64(Core::System& system) {
svc: Implement svcGetProcessInfo A fairly basic service function, which only appears to currently support retrieving the process state. This also alters the ProcessStatus enum to contain all of the values that a kernel process seems to be able of reporting with regards to state.
2018-10-13 14:31:46 -04:00
u64 param_1 = 0;
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
const u32 retval = func(system, &param_1, static_cast<u32>(Param(system, 1)),
static_cast<u32>(Param(system, 2)))
.raw;
system.CurrentArmInterface().SetReg(1, param_1);
FuncReturn(system, retval);
svc: Implement svcGetProcessInfo A fairly basic service function, which only appears to currently support retrieving the process state. This also alters the ProcessStatus enum to contain all of the values that a kernel process seems to be able of reporting with regards to state.
2018-10-13 14:31:46 -04:00
}
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
template <ResultCode func(Core::System&, u32, u64)>
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
void SvcWrap64(Core::System& system) {
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
FuncReturn(system, func(system, static_cast<u32>(Param(system, 0)), Param(system, 1)).raw);
svc: Stub out SetThreadActivity, GetThreadContext.
2018-04-02 23:50:17 -04:00
}
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
template <ResultCode func(Core::System&, u32, u32, u64)>
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
void SvcWrap64(Core::System& system) {
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
FuncReturn(system, func(system, static_cast<u32>(Param(system, 0)),
static_cast<u32>(Param(system, 1)), Param(system, 2))
.raw);
svc: Stub GetThreadCoreMask.
2018-03-29 21:07:49 -04:00
}
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
template <ResultCode func(Core::System&, u32, u32*, u64*)>
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
void SvcWrap64(Core::System& system) {
svc: Stub GetThreadCoreMask.
2018-03-29 21:07:49 -04:00
u32 param_1 = 0;
u64 param_2 = 0;
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
const ResultCode retval = func(system, static_cast<u32>(Param(system, 2)), &param_1, &param_2);
svc: Stub GetThreadCoreMask.
2018-03-29 21:07:49 -04:00
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
system.CurrentArmInterface().SetReg(1, param_1);
system.CurrentArmInterface().SetReg(2, param_2);
FuncReturn(system, retval.raw);
svc: Stub SetMemoryAttribute
2018-01-07 21:23:42 -05:00
}
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
template <ResultCode func(Core::System&, u64, u64, u32, u32)>
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
void SvcWrap64(Core::System& system) {
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
FuncReturn(system, func(system, Param(system, 0), Param(system, 1),
static_cast<u32>(Param(system, 2)), static_cast<u32>(Param(system, 3)))
.raw);
svc: Enable svcQueryProcessMemory svcQueryProcessMemory is trivial to implement, given all the behavior necessary for it is present, it just needs a handler for it.
2018-12-12 13:42:21 -05:00
}
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
template <ResultCode func(Core::System&, u64, u64, u32, u64)>
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
void SvcWrap64(Core::System& system) {
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
FuncReturn(system, func(system, Param(system, 0), Param(system, 1),
static_cast<u32>(Param(system, 2)), Param(system, 3))
.raw);
Kernel/SVC: Partially implemented svcReplyAndReceive. It behaves mostly as WaitSynchronizationN with wait_all = false, except for IPC buffer translation. The target thread of an IPC response will now wake up when responding. IPC buffer translation is currently not implemented. Error passing back to svcSendSyncRequest is currently not implemented.
2017-06-20 20:27:20 -04:00
}
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
template <ResultCode func(Core::System&, u32, u64, u32)>
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
void SvcWrap64(Core::System& system) {
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
FuncReturn(system, func(system, static_cast<u32>(Param(system, 0)), Param(system, 1),
static_cast<u32>(Param(system, 2)))
.raw);
added initial modules for setting up SysCall HLE
2014-04-10 19:58:28 -04:00
}
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
template <ResultCode func(Core::System&, u64, u64, u64)>
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
void SvcWrap64(Core::System& system) {
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
FuncReturn(system, func(system, Param(system, 0), Param(system, 1), Param(system, 2)).raw);
Stubbed SetMemoryPermission
2018-11-03 11:01:34 -04:00
}
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
template <ResultCode func(Core::System&, u64, u64, u32)>
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
void SvcWrap64(Core::System& system) {
Changed all casts in svc_wrap.h to be static_cast instead
2018-10-09 21:49:08 -04:00
FuncReturn(
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
system,
func(system, Param(system, 0), Param(system, 1), static_cast<u32>(Param(system, 2))).raw);
}
template <ResultCode func(Core::System&, u32, u64, u64, u32)>
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
void SvcWrap64(Core::System& system) {
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
FuncReturn(system, func(system, static_cast<u32>(Param(system, 0)), Param(system, 1),
Param(system, 2), static_cast<u32>(Param(system, 3)))
.raw);
svc: Implement svcMapSharedMemory.
2018-01-14 17:15:31 -05:00
}
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
template <ResultCode func(Core::System&, u32, u64, u64)>
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
void SvcWrap64(Core::System& system) {
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
FuncReturn(
system,
func(system, static_cast<u32>(Param(system, 0)), Param(system, 1), Param(system, 2)).raw);
Add UnmapSharedMemory C++11 requires spaces on the Identifier Add inttypes include clang
2018-02-22 14:16:43 -05:00
}
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
template <ResultCode func(Core::System&, u32*, u64, u64, s64)>
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
void SvcWrap64(Core::System& system) {
SVC: Fixed WaitSynchronization with multiple handles when at least one of them is ready.
2018-01-09 11:53:50 -05:00
u32 param_1 = 0;
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
const u32 retval = func(system, &param_1, Param(system, 1), static_cast<u32>(Param(system, 2)),
static_cast<s64>(Param(system, 3)))
.raw;
system.CurrentArmInterface().SetReg(1, param_1);
FuncReturn(system, retval);
function_wrappers: Fixed incorrect wrapper, added another.
2014-07-06 22:17:34 -04:00
}
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
template <ResultCode func(Core::System&, u64, u64, u32, s64)>
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
void SvcWrap64(Core::System& system) {
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
FuncReturn(system, func(system, Param(system, 0), Param(system, 1),
static_cast<u32>(Param(system, 2)), static_cast<s64>(Param(system, 3)))
.raw);
svc: Implement svcWaitProcessWideKeyAtomic.
2018-01-06 16:14:12 -05:00
}
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
template <ResultCode func(Core::System&, u64*, u64, u64, u64)>
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
void SvcWrap64(Core::System& system) {
Merge remote-tracking branch 'upstream/master' into nx # Conflicts: # src/core/CMakeLists.txt # src/core/arm/dynarmic/arm_dynarmic.cpp # src/core/arm/dyncom/arm_dyncom.cpp # src/core/hle/kernel/process.cpp # src/core/hle/kernel/thread.cpp # src/core/hle/kernel/thread.h # src/core/hle/kernel/vm_manager.cpp # src/core/loader/3dsx.cpp # src/core/loader/elf.cpp # src/core/loader/ncch.cpp # src/core/memory.cpp # src/core/memory.h # src/core/memory_setup.h
2017-10-09 23:56:20 -04:00
u64 param_1 = 0;
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
const u32 retval =
func(system, &param_1, Param(system, 1), Param(system, 2), Param(system, 3)).raw;
system.CurrentArmInterface().SetReg(1, param_1);
FuncReturn(system, retval);
Merge remote-tracking branch 'upstream/master' into nx # Conflicts: # src/core/CMakeLists.txt # src/core/arm/dynarmic/arm_dynarmic.cpp # src/core/arm/dyncom/arm_dyncom.cpp # src/core/hle/kernel/process.cpp # src/core/hle/kernel/thread.cpp # src/core/hle/kernel/thread.h # src/core/hle/kernel/vm_manager.cpp # src/core/loader/3dsx.cpp # src/core/loader/elf.cpp # src/core/loader/ncch.cpp # src/core/memory.cpp # src/core/memory.h # src/core/memory_setup.h
2017-10-09 23:56:20 -04:00
}
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
template <ResultCode func(Core::System&, u32*, u64, u64, u64, u32, s32)>
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
void SvcWrap64(Core::System& system) {
function_wrappers: Fixed incorrect wrapper, added another.
2014-07-06 22:17:34 -04:00
u32 param_1 = 0;
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
const u32 retval = func(system, &param_1, Param(system, 1), Param(system, 2), Param(system, 3),
static_cast<u32>(Param(system, 4)), static_cast<s32>(Param(system, 5)))
.raw;
system.CurrentArmInterface().SetReg(1, param_1);
FuncReturn(system, retval);
added initial modules for setting up SysCall HLE
2014-04-10 19:58:28 -04:00
}
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
template <ResultCode func(Core::System&, u32*, u64, u64, u32)>
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
void SvcWrap64(Core::System& system) {
svc: Stub ResetSignal and CreateTransferMemory
2018-01-07 21:24:19 -05:00
u32 param_1 = 0;
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
const u32 retval = func(system, &param_1, Param(system, 1), Param(system, 2),
static_cast<u32>(Param(system, 3)))
.raw;
system.CurrentArmInterface().SetReg(1, param_1);
FuncReturn(system, retval);
Added CreateSharedMemory & UNIMPLEMENTED() for non existent services. (#113) * Added svcCreateSharedMemory * Services which are not implemented now throw UNIMPLEMENTED() * clang-format * changed perms to u32 * removed camelcase
2018-01-19 19:35:25 -05:00
}
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
template <ResultCode func(Core::System&, Handle*, u64, u32, u32)>
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
void SvcWrap64(Core::System& system) {
Added CreateSharedMemory & UNIMPLEMENTED() for non existent services. (#113) * Added svcCreateSharedMemory * Services which are not implemented now throw UNIMPLEMENTED() * clang-format * changed perms to u32 * removed camelcase
2018-01-19 19:35:25 -05:00
u32 param_1 = 0;
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
const u32 retval = func(system, &param_1, Param(system, 1), static_cast<u32>(Param(system, 2)),
static_cast<u32>(Param(system, 3)))
.raw;
system.CurrentArmInterface().SetReg(1, param_1);
FuncReturn(system, retval);
svc: Stub ResetSignal and CreateTransferMemory
2018-01-07 21:24:19 -05:00
}
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
template <ResultCode func(Core::System&, u64, u32, s32, s64)>
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
void SvcWrap64(Core::System& system) {
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
FuncReturn(system, func(system, Param(system, 0), static_cast<u32>(Param(system, 1)),
static_cast<s32>(Param(system, 2)), static_cast<s64>(Param(system, 3)))
.raw);
Kernel/Arbiters: Add stubs for 4.x SignalToAddress/WaitForAddres SVCs.
2018-06-21 02:49:43 -04:00
}
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
template <ResultCode func(Core::System&, u64, u32, s32, s32)>
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
void SvcWrap64(Core::System& system) {
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
FuncReturn(system, func(system, Param(system, 0), static_cast<u32>(Param(system, 1)),
static_cast<s32>(Param(system, 2)), static_cast<s32>(Param(system, 3)))
.raw);
Kernel/Arbiters: Add stubs for 4.x SignalToAddress/WaitForAddres SVCs.
2018-06-21 02:49:43 -04:00
}
SVC: Cleaned up function wrappers to pass in correct argument types.
2014-06-06 23:31:29 -04:00
////////////////////////////////////////////////////////////////////////////////////////////////////
// Function wrappers that return type u32
added initial modules for setting up SysCall HLE
2014-04-10 19:58:28 -04:00
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
template <u32 func(Core::System&)>
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
void SvcWrap64(Core::System& system) {
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
FuncReturn(system, func(system));
SVC: Added support for svc_GetSystemTick. Changed HLE function return methods to be static inline functions.
2014-08-14 20:01:02 -04:00
}
svc: Implement GetSystemTick.
2018-01-11 21:59:31 -05:00
////////////////////////////////////////////////////////////////////////////////////////////////////
// Function wrappers that return type u64
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
template <u64 func(Core::System&)>
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
void SvcWrap64(Core::System& system) {
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
FuncReturn(system, func(system));
svc: Implement GetSystemTick.
2018-01-11 21:59:31 -05:00
}
SVC: Added support for svc_GetSystemTick. Changed HLE function return methods to be static inline functions.
2014-08-14 20:01:02 -04:00
////////////////////////////////////////////////////////////////////////////////////////////////////
function_wrappers: Cleanup, fix warnings, remove unused code.
2017-12-31 15:46:30 -05:00
/// Function wrappers that return type void
SVC: Added support for svc_GetSystemTick. Changed HLE function return methods to be static inline functions.
2014-08-14 20:01:02 -04:00
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
template <void func(Core::System&)>
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
void SvcWrap64(Core::System& system) {
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
func(system);
added initial modules for setting up SysCall HLE
2014-04-10 19:58:28 -04:00
}
kernel/svc: Provide implementations for svcDumpInfo/svcDumpInfoNew These are fairly trivial to implement, we can just do nothing. This also provides a spot for us to potentially dump out any relevant info in the future (e.g. for debugging purposes with homebrew, etc). While we're at it, we can also correct the names of both of these supervisor calls.
2019-12-07 21:12:14 -05:00
template <void func(Core::System&, u32)>
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
void SvcWrap64(Core::System& system) {
kernel/svc: Provide implementations for svcDumpInfo/svcDumpInfoNew These are fairly trivial to implement, we can just do nothing. This also provides a spot for us to potentially dump out any relevant info in the future (e.g. for debugging purposes with homebrew, etc). While we're at it, we can also correct the names of both of these supervisor calls.
2019-12-07 21:12:14 -05:00
func(system, static_cast<u32>(Param(system, 0)));
}
template <void func(Core::System&, u32, u64, u64, u64)>
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
void SvcWrap64(Core::System& system) {
kernel/svc: Provide implementations for svcDumpInfo/svcDumpInfoNew These are fairly trivial to implement, we can just do nothing. This also provides a spot for us to potentially dump out any relevant info in the future (e.g. for debugging purposes with homebrew, etc). While we're at it, we can also correct the names of both of these supervisor calls.
2019-12-07 21:12:14 -05:00
func(system, static_cast<u32>(Param(system, 0)), Param(system, 1), Param(system, 2),
Param(system, 3));
}
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
template <void func(Core::System&, s64)>
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
void SvcWrap64(Core::System& system) {
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
func(system, static_cast<s64>(Param(system, 0)));
svc: added missing function wrapper for SleepThread
2014-06-01 10:41:41 -04:00
}
kernel/svc: Correct function signature of SignalProcessWideKey This function doesn't actually return a result code, so we can amend the signature of it to match.
2019-12-11 07:11:47 -05:00
template <void func(Core::System&, u64, s32)>
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
void SvcWrap64(Core::System& system) {
kernel/svc: Correct function signature of SignalProcessWideKey This function doesn't actually return a result code, so we can amend the signature of it to match.
2019-12-11 07:11:47 -05:00
func(system, Param(system, 0), static_cast<s32>(Param(system, 1)));
}
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
template <void func(Core::System&, u64, u64)>
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
void SvcWrap64(Core::System& system) {
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
func(system, Param(system, 0), Param(system, 1));
added stubbed function for WaitSynchronizationN
2014-05-17 23:37:25 -04:00
}
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
template <void func(Core::System&, u64, u64, u64)>
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
void SvcWrap64(Core::System& system) {
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
func(system, Param(system, 0), Param(system, 1), Param(system, 2));
Implement svcBreak
2015-05-17 01:06:59 -04:00
}
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
template <void func(Core::System&, u32, u64, u64)>
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
void SvcWrap64(Core::System& system) {
kernel/svc: Deglobalize the supervisor call handlers Adjusts the interface of the wrappers to take a system reference, which allows accessing a system instance without using the global accessors. This also allows getting rid of all global accessors within the supervisor call handling code. While this does make the wrappers themselves slightly more noisy, this will be further cleaned up in a follow-up. This eliminates the global system accessors in the current code while preserving the existing interface.
2019-04-06 18:46:18 -04:00
func(system, static_cast<u32>(Param(system, 0)), Param(system, 1), Param(system, 2));
Fixed incorrect types for svcBreak svcBreak reason should be a u32, not a u64.
2018-10-09 21:23:50 -04:00
}
SVC: Implement 32-bits wrappers and update Dynarmic.
2020-06-19 19:40:07 -04:00
// Used by QueryMemory32, ArbitrateLock32
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
template <ResultCode func(Core::System&, u32, u32, u32)>
void SvcWrap32(Core::System& system) {
FuncReturn32(system,
func(system, Param32(system, 0), Param32(system, 1), Param32(system, 2)).raw);
}
SVC: Implement 32-bits wrappers and update Dynarmic.
2020-06-19 19:40:07 -04:00
// Used by Break32
template <void func(Core::System&, u32, u32, u32)>
void SvcWrap32(Core::System& system) {
func(system, Param32(system, 0), Param32(system, 1), Param32(system, 2));
}
// Used by ExitProcess32, ExitThread32
template <void func(Core::System&)>
void SvcWrap32(Core::System& system) {
func(system);
}
SVC: Add GetCurrentProcessorNumber32, CreateTransferMemory32, SetMemoryAttribute32
2020-06-18 20:33:04 -04:00
// Used by GetCurrentProcessorNumber32
template <u32 func(Core::System&)>
void SvcWrap32(Core::System& system) {
SVC: Implement 32-bits wrappers and update Dynarmic.
2020-06-19 19:40:07 -04:00
FuncReturn32(system, func(system));
}
// Used by SleepThread32
template <void func(Core::System&, u32, u32)>
void SvcWrap32(Core::System& system) {
func(system, Param32(system, 0), Param32(system, 1));
}
// Used by CreateThread32
template <ResultCode func(Core::System&, Handle*, u32, u32, u32, u32, s32)>
void SvcWrap32(Core::System& system) {
Handle param_1 = 0;
const u32 retval = func(system, &param_1, Param32(system, 0), Param32(system, 1),
Param32(system, 2), Param32(system, 3), Param32(system, 4))
.raw;
system.CurrentArmInterface().SetReg(1, param_1);
FuncReturn(system, retval);
SVC: Add GetCurrentProcessorNumber32, CreateTransferMemory32, SetMemoryAttribute32
2020-06-18 20:33:04 -04:00
}
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
// Used by GetInfo32
template <ResultCode func(Core::System&, u32*, u32*, u32, u32, u32, u32)>
void SvcWrap32(Core::System& system) {
u32 param_1 = 0;
u32 param_2 = 0;
const u32 retval = func(system, &param_1, &param_2, Param32(system, 0), Param32(system, 1),
Param32(system, 2), Param32(system, 3))
.raw;
system.CurrentArmInterface().SetReg(1, param_1);
system.CurrentArmInterface().SetReg(2, param_2);
FuncReturn(system, retval);
}
// Used by GetThreadPriority32, ConnectToNamedPort32
template <ResultCode func(Core::System&, u32*, u32)>
void SvcWrap32(Core::System& system) {
u32 param_1 = 0;
const u32 retval = func(system, &param_1, Param32(system, 1)).raw;
system.CurrentArmInterface().SetReg(1, param_1);
FuncReturn(system, retval);
}
// Used by GetThreadId32
template <ResultCode func(Core::System&, u32*, u32*, u32)>
void SvcWrap32(Core::System& system) {
u32 param_1 = 0;
u32 param_2 = 0;
const u32 retval = func(system, &param_1, &param_2, Param32(system, 1)).raw;
system.CurrentArmInterface().SetReg(1, param_1);
system.CurrentArmInterface().SetReg(2, param_2);
FuncReturn(system, retval);
}
SVC: Implement 32-bits wrappers and update Dynarmic.
2020-06-19 19:40:07 -04:00
// Used by GetSystemTick32
template <void func(Core::System&, u32*, u32*)>
void SvcWrap32(Core::System& system) {
u32 param_1 = 0;
u32 param_2 = 0;
func(system, &param_1, &param_2);
system.CurrentArmInterface().SetReg(0, param_1);
system.CurrentArmInterface().SetReg(1, param_2);
}
// Used by CreateEvent32
template <ResultCode func(Core::System&, Handle*, Handle*)>
void SvcWrap32(Core::System& system) {
Handle param_1 = 0;
Handle param_2 = 0;
const u32 retval = func(system, &param_1, &param_2).raw;
system.CurrentArmInterface().SetReg(1, param_1);
system.CurrentArmInterface().SetReg(2, param_2);
FuncReturn(system, retval);
}
// Used by GetThreadId32
template <ResultCode func(Core::System&, Handle, u32*, u32*, u32*)>
void SvcWrap32(Core::System& system) {
u32 param_1 = 0;
u32 param_2 = 0;
u32 param_3 = 0;
const u32 retval = func(system, Param32(system, 2), &param_1, &param_2, &param_3).raw;
system.CurrentArmInterface().SetReg(1, param_1);
system.CurrentArmInterface().SetReg(2, param_2);
system.CurrentArmInterface().SetReg(3, param_3);
FuncReturn(system, retval);
}
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
// Used by SignalProcessWideKey32
template <void func(Core::System&, u32, s32)>
void SvcWrap32(Core::System& system) {
func(system, static_cast<u32>(Param(system, 0)), static_cast<s32>(Param(system, 1)));
}
SVC: Add GetThreadPriority32 & SetThreadPriority32
2020-06-18 18:15:19 -04:00
// Used by SetThreadPriority32
template <ResultCode func(Core::System&, Handle, u32)>
void SvcWrap32(Core::System& system) {
const u32 retval =
func(system, static_cast<Handle>(Param(system, 0)), static_cast<u32>(Param(system, 1))).raw;
FuncReturn(system, retval);
}
// Used by SetThreadCoreMask32
template <ResultCode func(Core::System&, Handle, u32, u32, u32)>
void SvcWrap32(Core::System& system) {
const u32 retval =
func(system, static_cast<Handle>(Param(system, 0)), static_cast<u32>(Param(system, 1)),
static_cast<u32>(Param(system, 2)), static_cast<u32>(Param(system, 3)))
.raw;
FuncReturn(system, retval);
}
SVC: Implement 32-bits wrappers and update Dynarmic.
2020-06-19 19:40:07 -04:00
// Used by WaitProcessWideKeyAtomic32
template <ResultCode func(Core::System&, u32, u32, Handle, u32, u32)>
void SvcWrap32(Core::System& system) {
const u32 retval =
func(system, static_cast<u32>(Param(system, 0)), static_cast<u32>(Param(system, 1)),
static_cast<Handle>(Param(system, 2)), static_cast<u32>(Param(system, 3)),
static_cast<u32>(Param(system, 4)))
.raw;
FuncReturn(system, retval);
}
// Used by WaitForAddress32
template <ResultCode func(Core::System&, u32, u32, s32, u32, u32)>
void SvcWrap32(Core::System& system) {
const u32 retval = func(system, static_cast<u32>(Param(system, 0)),
static_cast<u32>(Param(system, 1)), static_cast<s32>(Param(system, 2)),
static_cast<u32>(Param(system, 3)), static_cast<u32>(Param(system, 4)))
.raw;
FuncReturn(system, retval);
}
// Used by SignalToAddress32
template <ResultCode func(Core::System&, u32, u32, s32, s32)>
void SvcWrap32(Core::System& system) {
const u32 retval =
func(system, static_cast<u32>(Param(system, 0)), static_cast<u32>(Param(system, 1)),
static_cast<s32>(Param(system, 2)), static_cast<s32>(Param(system, 3)))
.raw;
FuncReturn(system, retval);
}
// Used by SendSyncRequest32, ArbitrateUnlock32
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
template <ResultCode func(Core::System&, u32)>
void SvcWrap32(Core::System& system) {
FuncReturn(system, func(system, static_cast<u32>(Param(system, 0))).raw);
}
SVC: Add GetCurrentProcessorNumber32, CreateTransferMemory32, SetMemoryAttribute32
2020-06-18 20:33:04 -04:00
// Used by CreateTransferMemory32
template <ResultCode func(Core::System&, Handle*, u32, u32, u32)>
void SvcWrap32(Core::System& system) {
Handle handle = 0;
const u32 retval =
func(system, &handle, Param32(system, 1), Param32(system, 2), Param32(system, 3)).raw;
system.CurrentArmInterface().SetReg(1, handle);
FuncReturn(system, retval);
}
core: hle: Implement separate A32/A64 SVC interfaces.
2020-03-02 00:06:41 -05:00
// Used by WaitSynchronization32
template <ResultCode func(Core::System&, u32, u32, s32, u32, Handle*)>
void SvcWrap32(Core::System& system) {
u32 param_1 = 0;
const u32 retval = func(system, Param32(system, 0), Param32(system, 1), Param32(system, 2),
Param32(system, 3), &param_1)
.raw;
system.CurrentArmInterface().SetReg(1, param_1);
FuncReturn(system, retval);
}
hle: Move SVC code to kernel namespace.
2018-01-02 20:40:30 -05:00
} // namespace Kernel
Reference in a new issue Copy permalink