diff options
Diffstat (limited to '')
| -rw-r--r-- | src/core/core.cpp | 18 | ||||
| -rw-r--r-- | src/core/core.vcxproj | 4 | ||||
| -rw-r--r-- | src/core/core.vcxproj.filters | 15 | ||||
| -rw-r--r-- | src/core/hle/function_wrappers.h | 726 | ||||
| -rw-r--r-- | src/core/hle/hle.h | 35 | ||||
| -rw-r--r-- | src/core/hle/hle_syscall.cpp | 22 | ||||
| -rw-r--r-- | src/core/hle/hle_syscall.h | 42 |
7 files changed, 862 insertions, 0 deletions
diff --git a/src/core/core.cpp b/src/core/core.cpp index 28f6b6c58..acb0a6e82 100644 --- a/src/core/core.cpp +++ b/src/core/core.cpp @@ -24,6 +24,24 @@ void RunLoop() { /// Step the CPU one instruction void SingleStep() { + + char current_instr[512]; + + if (g_app_core->GetPC() == 0x080D1534) { + g_disasm->disasm(g_app_core->GetPC(), Memory::Read32(g_app_core->GetPC()), current_instr); + + + NOTICE_LOG(ARM11, "0x%08X 0x%08X 0x%08X 0x%08X 0x%08X 0x%08X", + g_app_core->GetReg(0), + g_app_core->GetReg(1), + g_app_core->GetReg(2), + g_app_core->GetReg(3), Memory::Read32(g_app_core->GetReg(0)), Memory::Read32(g_app_core->GetReg(1))); + + + NOTICE_LOG(ARM11, "0x%08X\t%s", g_app_core->GetPC(), current_instr); + } + + g_app_core->Step(); HW::Update(); } diff --git a/src/core/core.vcxproj b/src/core/core.vcxproj index 1800b5512..55ce508a6 100644 --- a/src/core/core.vcxproj +++ b/src/core/core.vcxproj @@ -152,6 +152,7 @@ <ClCompile Include="elf\elf_reader.cpp" /> <ClCompile Include="file_sys\directory_file_system.cpp" /> <ClCompile Include="file_sys\meta_file_system.cpp" /> + <ClCompile Include="hle\hle_syscall.cpp" /> <ClCompile Include="hw\hw.cpp" /> <ClCompile Include="hw\hw_lcd.cpp" /> <ClCompile Include="loader.cpp" /> @@ -182,6 +183,9 @@ <ClInclude Include="file_sys\directory_file_system.h" /> <ClInclude Include="file_sys\file_sys.h" /> <ClInclude Include="file_sys\meta_file_system.h" /> + <ClInclude Include="hle\function_wrappers.h" /> + <ClInclude Include="hle\hle.h" /> + <ClInclude Include="hle\hle_syscall.h" /> <ClInclude Include="hw\hw.h" /> <ClInclude Include="hw\hw_lcd.h" /> <ClInclude Include="loader.h" /> diff --git a/src/core/core.vcxproj.filters b/src/core/core.vcxproj.filters index 2efac8127..7bac04a2d 100644 --- a/src/core/core.vcxproj.filters +++ b/src/core/core.vcxproj.filters @@ -22,6 +22,9 @@ <Filter Include="elf"> <UniqueIdentifier>{7ae34319-6d72-4d12-bc62-9b438ba9241f}</UniqueIdentifier> </Filter> + <Filter Include="hle"> + <UniqueIdentifier>{8b62769e-3e2a-4a57-a7bc-b3b2933c2bc7}</UniqueIdentifier> + </Filter> </ItemGroup> <ItemGroup> <ClCompile Include="arm\disassembler\arm_disasm.cpp"> @@ -75,6 +78,9 @@ <ClCompile Include="mem_map_funcs.cpp" /> <ClCompile Include="system.cpp" /> <ClCompile Include="core_timing.cpp" /> + <ClCompile Include="hle\hle_syscall.cpp"> + <Filter>hle</Filter> + </ClCompile> </ItemGroup> <ItemGroup> <ClInclude Include="arm\disassembler\arm_disasm.h"> @@ -148,6 +154,15 @@ <ClInclude Include="loader.h" /> <ClInclude Include="mem_map.h" /> <ClInclude Include="system.h" /> + <ClInclude Include="hle\hle.h"> + <Filter>hle</Filter> + </ClInclude> + <ClInclude Include="hle\function_wrappers.h"> + <Filter>hle</Filter> + </ClInclude> + <ClInclude Include="hle\hle_syscall.h"> + <Filter>hle</Filter> + </ClInclude> </ItemGroup> <ItemGroup> <Text Include="CMakeLists.txt" /> diff --git a/src/core/hle/function_wrappers.h b/src/core/hle/function_wrappers.h new file mode 100644 index 000000000..22588d95d --- /dev/null +++ b/src/core/hle/function_wrappers.h @@ -0,0 +1,726 @@ +// Copyright (c) 2012- PPSSPP Project. + +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, version 2.0 or later versions. + +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License 2.0 for more details. + +// A copy of the GPL 2.0 should have been included with the program. +// If not, see http://www.gnu.org/licenses/ + +// Official git repository and contact information can be found at +// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/. + +#pragma once + +#include "common/common_types.h" +#include "core/mem_map.h" +#include "core/hle/hle.h" + +// For easy parameter parsing and return value processing. + +//32bit wrappers +template<void func()> void WrapV_V() { + func(); +} + +template<u32 func()> void WrapU_V() { + RETURN(func()); +} + +template<int func(void *, const char *)> void WrapI_VC() { + u32 retval = func(Memory::GetPointer(PARAM(0)), Memory::GetCharPointer(PARAM(1))); + RETURN(retval); +} + +template<u32 func(int, void *, int)> void WrapU_IVI() { + u32 retval = func(PARAM(0), Memory::GetPointer(PARAM(1)), PARAM(2)); + RETURN(retval); +} + +template<int func(const char *, int, int, u32)> void WrapI_CIIU() { + u32 retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template<int func(int, const char *, u32, void *, void *, u32, int)> void WrapI_ICUVVUI() { + u32 retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2), Memory::GetPointer(PARAM(3)),Memory::GetPointer(PARAM(4)), PARAM(5), PARAM(6) ); + RETURN(retval); +} + +// Hm, do so many params get passed in registers? +template<int func(const char *, int, const char *, int, int, int, int, int)> void WrapI_CICIIIII() { + u32 retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), Memory::GetCharPointer(PARAM(2)), + PARAM(3), PARAM(4), PARAM(5), PARAM(6), PARAM(7)); + RETURN(retval); +} + +// Hm, do so many params get passed in registers? +template<int func(const char *, int, int, int, int, int, int)> void WrapI_CIIIIII() { + u32 retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), + PARAM(3), PARAM(4), PARAM(5), PARAM(6)); + RETURN(retval); +} + +// Hm, do so many params get passed in registers? +template<int func(int, int, int, int, int, int, u32)> void WrapI_IIIIIIU() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5), PARAM(6)); + RETURN(retval); +} + +// Hm, do so many params get passed in registers? +template<int func(int, int, int, int, int, int, int, int, u32)> void WrapI_IIIIIIIIU() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5), PARAM(6), PARAM(7), PARAM(8)); + RETURN(retval); +} + +template<u32 func(int, void *)> void WrapU_IV() { + u32 retval = func(PARAM(0), Memory::GetPointer(PARAM(1))); + RETURN(retval); +} + +template<float func()> void WrapF_V() { + RETURNF(func()); +} + +// TODO: Not sure about the floating point parameter passing +template<float func(int, float, u32)> void WrapF_IFU() { + RETURNF(func(PARAM(0), PARAMF(0), PARAM(1))); +} + +template<u32 func(u32)> void WrapU_U() { + u32 retval = func(PARAM(0)); + RETURN(retval); +} + +template<u32 func(u32, int)> void WrapU_UI() { + u32 retval = func(PARAM(0), PARAM(1)); + RETURN(retval); +} + +template<int func(u32)> void WrapI_U() { + int retval = func(PARAM(0)); + RETURN(retval); +} + +template<int func(u32, int)> void WrapI_UI() { + int retval = func(PARAM(0), PARAM(1)); + RETURN(retval); +} + +template<int func(u32, int, int, u32)> void WrapI_UIIU() { + int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template<u32 func(int, u32, int)> void WrapU_IUI() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2)); + RETURN(retval); +} + +template<int func(u32, u32)> void WrapI_UU() { + int retval = func(PARAM(0), PARAM(1)); + RETURN(retval); +} + +template<int func(u32, float, float)> void WrapI_UFF() { + // Not sure about the float arguments. + int retval = func(PARAM(0), PARAMF(0), PARAMF(1)); + RETURN(retval); +} + +template<int func(u32, u32, u32)> void WrapI_UUU() { + int retval = func(PARAM(0), PARAM(1), PARAM(2)); + RETURN(retval); +} + +template<int func(u32, u32, u32, int)> void WrapI_UUUI() { + int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template<int func(u32, u32, u32, int, int, int,int )> void WrapI_UUUIIII() { + int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5), PARAM(6)); + RETURN(retval); +} + +template<int func(u32, u32, u32, u32)> void WrapI_UUUU() { + int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template<int func(u32, u32, u32, u32, u32)> void WrapI_UUUUU() { + int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4)); + RETURN(retval); +} + +template<int func()> void WrapI_V() { + int retval = func(); + RETURN(retval); +} + +template<u32 func(int)> void WrapU_I() { + u32 retval = func(PARAM(0)); + RETURN(retval); +} + +template<u32 func(int, int, u32)> void WrapU_IIU() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2)); + RETURN(retval); +} + +template<int func(int)> void WrapI_I() { + int retval = func(PARAM(0)); + RETURN(retval); +} + +template<void func(u32)> void WrapV_U() { + func(PARAM(0)); +} + +template<void func(int)> void WrapV_I() { + func(PARAM(0)); +} + +template<void func(u32, u32)> void WrapV_UU() { + func(PARAM(0), PARAM(1)); +} + +template<void func(int, int)> void WrapV_II() { + func(PARAM(0), PARAM(1)); +} + +template<void func(u32, const char *)> void WrapV_UC() { + func(PARAM(0), Memory::GetCharPointer(PARAM(1))); +} + +template<int func(u32, const char *)> void WrapI_UC() { + int retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1))); + RETURN(retval); +} + +template<int func(u32, const char *, int)> void WrapI_UCI() { + int retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2)); + RETURN(retval); +} + +template<u32 func(u32, int , int , int, int, int)> void WrapU_UIIIII() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5)); + RETURN(retval); +} + +template<u32 func(u32, int , int , int, u32)> void WrapU_UIIIU() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4)); + RETURN(retval); +} + +template<u32 func(u32, int , int , int, int, int, int)> void WrapU_UIIIIII() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5), PARAM(6)); + RETURN(retval); +} + +template<u32 func(u32, u32)> void WrapU_UU() { + u32 retval = func(PARAM(0), PARAM(1)); + RETURN(retval); +} + +template<u32 func(u32, u32, int)> void WrapU_UUI() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2)); + RETURN(retval); +} + +template<u32 func(u32, u32, int, int)> void WrapU_UUII() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template<u32 func(const char *, u32, u32, u32)> void WrapU_CUUU() { + u32 retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template<void func(u32, int, u32, int, int)> void WrapV_UIUII() { + func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4)); +} + +template<u32 func(u32, int, u32, int, int)> void WrapU_UIUII() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4)); + RETURN(retval); +} + +template<int func(u32, int, u32, int, int)> void WrapI_UIUII() { + int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4)); + RETURN(retval); +} + +template<u32 func(u32, int, u32, int)> void WrapU_UIUI() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template<int func(u32, int, u32, int)> void WrapI_UIUI() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template<u32 func(u32, int, u32)> void WrapU_UIU() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2)); + RETURN(retval); +} + +template<u32 func(u32, int, u32, u32)> void WrapU_UIUU() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template<u32 func(u32, int, int)> void WrapU_UII() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2)); + RETURN(retval); +} + +template<u32 func(u32, int, int, u32)> void WrapU_UIIU() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template<int func(u32, int, int, u32, u32)> void WrapI_UIIUU() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4)); + RETURN(retval); +} + +template<int func(u32, u32, int, int)> void WrapI_UUII() { + int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template<int func(u32, u32, int, int, int)> void WrapI_UUIII() { + int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4)); + RETURN(retval); +} + +template<void func(u32, int, int, int)> void WrapV_UIII() { + func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); +} + +template<void func(u32, int, int, int, int, int)> void WrapV_UIIIII() { + func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5)); +} + +template<void func(u32, int, int)> void WrapV_UII() { + func(PARAM(0), PARAM(1), PARAM(2)); +} + +template<u32 func(int, u32)> void WrapU_IU() { + int retval = func(PARAM(0), PARAM(1)); + RETURN(retval); +} + +template<int func(int, u32)> void WrapI_IU() { + int retval = func(PARAM(0), PARAM(1)); + RETURN(retval); +} + +template<int func(u32, u32, int)> void WrapI_UUI() { + int retval = func(PARAM(0), PARAM(1), PARAM(2)); + RETURN(retval); +} + +template<int func(u32, u32, int, u32)> void WrapI_UUIU() { + int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template<int func(int, int)> void WrapI_II() { + int retval = func(PARAM(0), PARAM(1)); + RETURN(retval); +} + +template<int func(int, int, int)> void WrapI_III() { + int retval = func(PARAM(0), PARAM(1), PARAM(2)); + RETURN(retval); +} + +template<int func(int, u32, int)> void WrapI_IUI() { + int retval = func(PARAM(0), PARAM(1), PARAM(2)); + RETURN(retval); +} + +template<int func(int, int, int, int)> void WrapI_IIII() { + int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template<int func(u32, int, int, int)> void WrapI_UIII() { + int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template<int func(int, int, int, u32, int)> void WrapI_IIIUI() { + int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4)); + RETURN(retval); +} + +template<int func(int, u32, u32, int, int)> void WrapI_IUUII() { + int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4)); + RETURN(retval); +} + +template<int func(int, const char *, int, u32, u32)> void WrapI_ICIUU() { + int retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2), PARAM(3), PARAM(4)); + RETURN(retval); +} + +template<int func(int, int, u32)> void WrapI_IIU() { + int retval = func(PARAM(0), PARAM(1), PARAM(2)); + RETURN(retval); +} + +template<void func(int, u32)> void WrapV_IU() { + func(PARAM(0), PARAM(1)); +} + +template<void func(u32, int)> void WrapV_UI() { + func(PARAM(0), PARAM(1)); +} + +template<u32 func(const char *)> void WrapU_C() { + u32 retval = func(Memory::GetCharPointer(PARAM(0))); + RETURN(retval); +} + +template<u32 func(const char *, const char *, const char *, u32)> void WrapU_CCCU() { + u32 retval = func(Memory::GetCharPointer(PARAM(0)), + Memory::GetCharPointer(PARAM(1)), Memory::GetCharPointer(PARAM(2)), + PARAM(3)); + RETURN(retval); +} + +template<int func(const char *)> void WrapI_C() { + int retval = func(Memory::GetCharPointer(PARAM(0))); + RETURN(retval); +} + +template<int func(const char *, u32)> void WrapI_CU() { + int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1)); + RETURN(retval); +} + +template<int func(const char *, u32, int)> void WrapI_CUI() { + int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2)); + RETURN(retval); +} + +template<int func(int, const char *, int, u32)> void WrapI_ICIU() { + int retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template<int func(const char *, int, u32)> void WrapI_CIU() { + int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2)); + RETURN(retval); +} + +template<int func(const char *, u32, u32)> void WrapI_CUU() { + int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2)); + RETURN(retval); +} + +template<int func(const char *, u32, u32, u32)> void WrapI_CUUU() { + int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), + PARAM(3)); + RETURN(retval); +} + +template<int func(const char *, const char*, int, int)> void WrapI_CCII() { + int retval = func(Memory::GetCharPointer(PARAM(0)), Memory::GetCharPointer(PARAM(1)), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template<int func(const char *, u32, u32, int, u32, u32)> void WrapI_CUUIUU() { + int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), + PARAM(3), PARAM(4), PARAM(5)); + RETURN(retval); +} + +template<int func(const char *, int, int, u32, int, int)> void WrapI_CIIUII() { + int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), + PARAM(3), PARAM(4), PARAM(5)); + RETURN(retval); +} + +template<int func(const char *, int, u32, u32, u32)> void WrapI_CIUUU() { + int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), + PARAM(3), PARAM(4)); + RETURN(retval); +} + +template<int func(const char *, u32, u32, u32, u32, u32)> void WrapI_CUUUUU() { + int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), + PARAM(3), PARAM(4), PARAM(5)); + RETURN(retval); +} + +template<u32 func(const char *, u32)> void WrapU_CU() { + u32 retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1)); + RETURN((u32) retval); +} + +template<u32 func(u32, const char *)> void WrapU_UC() { + u32 retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1))); + RETURN(retval); +} + +template<u32 func(const char *, u32, u32)> void WrapU_CUU() { + u32 retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2)); + RETURN((u32) retval); +} + +template<u32 func(int, int, int)> void WrapU_III() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2)); + RETURN(retval); +} + +template<u32 func(int, int)> void WrapU_II() { + u32 retval = func(PARAM(0), PARAM(1)); + RETURN(retval); +} + +template<u32 func(int, int, int, int)> void WrapU_IIII() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template<u32 func(int, u32, u32)> void WrapU_IUU() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2)); + RETURN(retval); +} + +template<u32 func(int, u32, u32, u32)> void WrapU_IUUU() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template<u32 func(int, u32, u32, u32, u32)> void WrapU_IUUUU() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4)); + RETURN(retval); +} + +template<u32 func(u32, u32, u32)> void WrapU_UUU() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2)); + RETURN(retval); +} + +template<void func(int, u32, u32)> void WrapV_IUU() { + func(PARAM(0), PARAM(1), PARAM(2)); +} + +template<void func(int, int, u32)> void WrapV_IIU() { + func(PARAM(0), PARAM(1), PARAM(2)); +} + +template<void func(u32, int, u32)> void WrapV_UIU() { + func(PARAM(0), PARAM(1), PARAM(2)); +} + +template<int func(u32, int, u32)> void WrapI_UIU() { + int retval = func(PARAM(0), PARAM(1), PARAM(2)); + RETURN(retval); +} + +template<void func(int, u32, u32, u32, u32)> void WrapV_IUUUU() { + func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4)); +} + +template<void func(u32, u32, u32)> void WrapV_UUU() { + func(PARAM(0), PARAM(1), PARAM(2)); +} + +template<void func(u32, u32, u32, u32)> void WrapV_UUUU() { + func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); +} + +template<void func(const char *, u32, int, u32)> void WrapV_CUIU() { + func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), PARAM(3)); +} + +template<int func(const char *, u32, int, u32)> void WrapI_CUIU() { + int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template<void func(u32, const char *, u32, int, u32)> void WrapV_UCUIU() { + func(PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2), PARAM(3), + PARAM(4)); +} + +template<int func(u32, const char *, u32, int, u32)> void WrapI_UCUIU() { + int retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2), + PARAM(3), PARAM(4)); + RETURN(retval); +} + +template<void func(const char *, u32, int, int, u32)> void WrapV_CUIIU() { + func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), PARAM(3), + PARAM(4)); +} + +template<int func(const char *, u32, int, int, u32)> void WrapI_CUIIU() { + int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), + PARAM(3), PARAM(4)); + RETURN(retval); +} + +template<u32 func(u32, u32, u32, u32)> void WrapU_UUUU() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template<u32 func(u32, const char *, u32, u32)> void WrapU_UCUU() { + u32 retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template<u32 func(u32, u32, u32, int)> void WrapU_UUUI() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template<u32 func(u32, u32, u32, int, u32)> void WrapU_UUUIU() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4)); + RETURN(retval); +} + +template<u32 func(u32, u32, u32, int, u32, int)> void WrapU_UUUIUI() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5)); + RETURN(retval); +} + +template<u32 func(u32, u32, int, u32)> void WrapU_UUIU() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template<u32 func(u32, int, int, int)> void WrapU_UIII() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template<int func(int, u32, u32, u32, u32)> void WrapI_IUUUU() { + int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4)); + RETURN(retval); +} + +template<int func(int, u32, u32, u32, u32, u32)> void WrapI_IUUUUU() { + int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5)); + RETURN(retval); +} + +template<int func(int, u32, int, int)> void WrapI_IUII() { + int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} +template<u32 func(u32, u32, u32, u32, u32)> void WrapU_UUUUU() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4)); + RETURN(retval); +} + +template<void func(u32, u32, u32, u32, u32)> void WrapV_UUUUU() { + func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4)); +} + +template<u32 func(const char *, const char *)> void WrapU_CC() { + int retval = func(Memory::GetCharPointer(PARAM(0)), + Memory::GetCharPointer(PARAM(1))); + RETURN(retval); +} + +template<void func(const char *, int)> void WrapV_CI() { + func(Memory::GetCharPointer(PARAM(0)), PARAM(1)); +} + +template<u32 func(const char *, int)> void WrapU_CI() { + int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1)); + RETURN(retval); +} + +template<u32 func(const char *, int, int)> void WrapU_CII() { + int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2)); + RETURN(retval); +} + +template<int func(const char *, int, u32, int, u32)> void WrapU_CIUIU() { + int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), + PARAM(3), PARAM(4)); + RETURN(retval); +} + +template<u32 func(const char *, int, u32, int, u32, int)> void WrapU_CIUIUI() { + u32 retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), + PARAM(3), PARAM(4), PARAM(5)); + RETURN(retval); +} + +template<u32 func(u32, u32, u32, u32, u32, u32)> void WrapU_UUUUUU() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), + PARAM(5)); + RETURN(retval); +} + +template<int func(int, u32, u32, u32)> void WrapI_IUUU() { + int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template<int func(int, u32, u32)> void WrapI_IUU() { + int retval = func(PARAM(0), PARAM(1), PARAM(2)); + RETURN(retval); +} + +template<u32 func(u32, u32, u32, u32, u32, u32, u32)> void WrapU_UUUUUUU() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5), PARAM(6)); + RETURN(retval); +} + +template<int func(u32, int, u32, u32)> void WrapI_UIUU() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template<int func(int, const char *)> void WrapI_IC() { + int retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1))); + RETURN(retval); +} + +template <int func(int, const char *, const char *, u32, int)> void WrapI_ICCUI() { + int retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)), Memory::GetCharPointer(PARAM(2)), PARAM(3), PARAM(4)); + RETURN(retval); +} + +template <int func(int, const char *, const char *, int)> void WrapI_ICCI() { + int retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)), Memory::GetCharPointer(PARAM(2)), PARAM(3)); + RETURN(retval); +} + +template <int func(const char *, int, int)> void WrapI_CII() { + int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2)); + RETURN(retval); +} + +template <int func(int, const char *, int)> void WrapI_ICI() { + int retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2)); + RETURN(retval); +} + +template<int func(int, void *, void *, void *, void *, u32, int)> void WrapI_IVVVVUI(){ + u32 retval = func(PARAM(0), Memory::GetPointer(PARAM(1)), Memory::GetPointer(PARAM(2)), Memory::GetPointer(PARAM(3)), Memory::GetPointer(PARAM(4)), PARAM(5), PARAM(6) ); + RETURN(retval); +} + +template<int func(int, const char *, u32, void *, int, int, int)> void WrapI_ICUVIII(){ + u32 retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2), Memory::GetPointer(PARAM(3)), PARAM(4), PARAM(5), PARAM(6)); + RETURN(retval); +} diff --git a/src/core/hle/hle.h b/src/core/hle/hle.h new file mode 100644 index 000000000..6780b52c4 --- /dev/null +++ b/src/core/hle/hle.h @@ -0,0 +1,35 @@ +// Copyright 2014 Citra Emulator Project +// Licensed under GPLv2 +// Refer to the license.txt file included. + +#pragma once + +#include "common/common_types.h" +#include "core/core.h" + +//////////////////////////////////////////////////////////////////////////////////////////////////// + +typedef void (*HLEFunc)(); +typedef void (*SysCallFunc)(); + +struct HLEFunction { + u32 id; + HLEFunc func; + const char* name; + u32 flags; +}; + +struct HLEModule { + const char* name; + int num_funcs; + const HLEFunction* func_table; +}; + +struct SysCall { + u8 id; + SysCallFunc func; + const char* name; +}; + +#define PARAM(n) Core::g_app_core->GetReg(n) +#define RETURN(n) Core::g_app_core->SetReg(0, n) diff --git a/src/core/hle/hle_syscall.cpp b/src/core/hle/hle_syscall.cpp new file mode 100644 index 000000000..c8a516848 --- /dev/null +++ b/src/core/hle/hle_syscall.cpp @@ -0,0 +1,22 @@ +// Copyright 2014 Citra Emulator Project +// Licensed under GPLv2 +// Refer to the license.txt file included. + +#include "core/hle/function_wrappers.h" +#include "core/hle/hle_syscall.h" + +//////////////////////////////////////////////////////////////////////////////////////////////////// + + + +Result SVC_ConnectToPort(void* out, const char* port_name) { + NOTICE_LOG(OSHLE, "SVC_ConnectToPort called, port_name: %s", port_name); + return 0; +} + +const SysCall SysCallTable[] = { + {0x2D, WrapI_VC<SVC_ConnectToPort>, "svcConnectToPort"}, +}; + +void Register_SysCalls() { +} diff --git a/src/core/hle/hle_syscall.h b/src/core/hle/hle_syscall.h new file mode 100644 index 000000000..506dcfc78 --- /dev/null +++ b/src/core/hle/hle_syscall.h @@ -0,0 +1,42 @@ +// Copyright 2014 Citra Emulator Project +// Licensed under GPLv2 +// Refer to the license.txt file included. + +#pragma once + +#include "common/common_types.h" + +//////////////////////////////////////////////////////////////////////////////////////////////////// + +//template <class T> +//class KernelObject { +//public: +// virtual ~KernelObject() {} +// +// T GetNative() const { +// return m_native; +// } +// +// void SetNative(const T& native) { +// m_native = native; +// } +// +// virtual const char *GetTypeName() {return "[BAD KERNEL OBJECT TYPE]";} +// virtual const char *GetName() {return "[UNKNOWN KERNEL OBJECT]";} +// +//private: +// T m_native; +//}; + +//class Handle : public KernelObject<u32> { +// const char* GetTypeName() { +// return "Handle"; +// } +//}; + + +typedef u32 Handle; +typedef s32 Result; + + +Result ConnectToPort(Handle* out, const char* port_name); |