From f68de21ad1cd267029b60ee3767d219c46f5fba0 Mon Sep 17 00:00:00 2001 From: bunnei Date: Thu, 10 Apr 2014 19:58:28 -0400 Subject: [PATCH] added initial modules for setting up SysCall HLE --- src/core/core.cpp | 18 + src/core/core.vcxproj | 4 + src/core/core.vcxproj.filters | 15 + src/core/hle/function_wrappers.h | 726 +++++++++++++++++++++++++++++++ src/core/hle/hle.h | 35 ++ src/core/hle/hle_syscall.cpp | 22 + src/core/hle/hle_syscall.h | 42 ++ 7 files changed, 862 insertions(+) create mode 100644 src/core/hle/function_wrappers.h create mode 100644 src/core/hle/hle.h create mode 100644 src/core/hle/hle_syscall.cpp create mode 100644 src/core/hle/hle_syscall.h 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 @@ + @@ -182,6 +183,9 @@ + + + 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 @@ {7ae34319-6d72-4d12-bc62-9b438ba9241f} + + {8b62769e-3e2a-4a57-a7bc-b3b2933c2bc7} + @@ -75,6 +78,9 @@ + + hle + @@ -148,6 +154,15 @@ + + hle + + + hle + + + hle + 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 WrapV_V() { + func(); +} + +template void WrapU_V() { + RETURN(func()); +} + +template void WrapI_VC() { + u32 retval = func(Memory::GetPointer(PARAM(0)), Memory::GetCharPointer(PARAM(1))); + RETURN(retval); +} + +template void WrapU_IVI() { + u32 retval = func(PARAM(0), Memory::GetPointer(PARAM(1)), PARAM(2)); + RETURN(retval); +} + +template void WrapI_CIIU() { + u32 retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template 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 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 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 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 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 void WrapU_IV() { + u32 retval = func(PARAM(0), Memory::GetPointer(PARAM(1))); + RETURN(retval); +} + +template void WrapF_V() { + RETURNF(func()); +} + +// TODO: Not sure about the floating point parameter passing +template void WrapF_IFU() { + RETURNF(func(PARAM(0), PARAMF(0), PARAM(1))); +} + +template void WrapU_U() { + u32 retval = func(PARAM(0)); + RETURN(retval); +} + +template void WrapU_UI() { + u32 retval = func(PARAM(0), PARAM(1)); + RETURN(retval); +} + +template void WrapI_U() { + int retval = func(PARAM(0)); + RETURN(retval); +} + +template void WrapI_UI() { + int retval = func(PARAM(0), PARAM(1)); + RETURN(retval); +} + +template void WrapI_UIIU() { + int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template void WrapU_IUI() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2)); + RETURN(retval); +} + +template void WrapI_UU() { + int retval = func(PARAM(0), PARAM(1)); + RETURN(retval); +} + +template void WrapI_UFF() { + // Not sure about the float arguments. + int retval = func(PARAM(0), PARAMF(0), PARAMF(1)); + RETURN(retval); +} + +template void WrapI_UUU() { + int retval = func(PARAM(0), PARAM(1), PARAM(2)); + RETURN(retval); +} + +template void WrapI_UUUI() { + int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template void WrapI_UUUIIII() { + int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5), PARAM(6)); + RETURN(retval); +} + +template void WrapI_UUUU() { + int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template void WrapI_UUUUU() { + int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4)); + RETURN(retval); +} + +template void WrapI_V() { + int retval = func(); + RETURN(retval); +} + +template void WrapU_I() { + u32 retval = func(PARAM(0)); + RETURN(retval); +} + +template void WrapU_IIU() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2)); + RETURN(retval); +} + +template void WrapI_I() { + int retval = func(PARAM(0)); + RETURN(retval); +} + +template void WrapV_U() { + func(PARAM(0)); +} + +template void WrapV_I() { + func(PARAM(0)); +} + +template void WrapV_UU() { + func(PARAM(0), PARAM(1)); +} + +template void WrapV_II() { + func(PARAM(0), PARAM(1)); +} + +template void WrapV_UC() { + func(PARAM(0), Memory::GetCharPointer(PARAM(1))); +} + +template void WrapI_UC() { + int retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1))); + RETURN(retval); +} + +template void WrapI_UCI() { + int retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2)); + RETURN(retval); +} + +template void WrapU_UIIIII() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5)); + RETURN(retval); +} + +template void WrapU_UIIIU() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4)); + RETURN(retval); +} + +template void WrapU_UIIIIII() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5), PARAM(6)); + RETURN(retval); +} + +template void WrapU_UU() { + u32 retval = func(PARAM(0), PARAM(1)); + RETURN(retval); +} + +template void WrapU_UUI() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2)); + RETURN(retval); +} + +template void WrapU_UUII() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template void WrapU_CUUU() { + u32 retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template void WrapV_UIUII() { + func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4)); +} + +template void WrapU_UIUII() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4)); + RETURN(retval); +} + +template void WrapI_UIUII() { + int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4)); + RETURN(retval); +} + +template void WrapU_UIUI() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template void WrapI_UIUI() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template void WrapU_UIU() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2)); + RETURN(retval); +} + +template void WrapU_UIUU() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template void WrapU_UII() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2)); + RETURN(retval); +} + +template void WrapU_UIIU() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template void WrapI_UIIUU() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4)); + RETURN(retval); +} + +template void WrapI_UUII() { + int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template void WrapI_UUIII() { + int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4)); + RETURN(retval); +} + +template void WrapV_UIII() { + func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); +} + +template void WrapV_UIIIII() { + func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5)); +} + +template void WrapV_UII() { + func(PARAM(0), PARAM(1), PARAM(2)); +} + +template void WrapU_IU() { + int retval = func(PARAM(0), PARAM(1)); + RETURN(retval); +} + +template void WrapI_IU() { + int retval = func(PARAM(0), PARAM(1)); + RETURN(retval); +} + +template void WrapI_UUI() { + int retval = func(PARAM(0), PARAM(1), PARAM(2)); + RETURN(retval); +} + +template void WrapI_UUIU() { + int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template void WrapI_II() { + int retval = func(PARAM(0), PARAM(1)); + RETURN(retval); +} + +template void WrapI_III() { + int retval = func(PARAM(0), PARAM(1), PARAM(2)); + RETURN(retval); +} + +template void WrapI_IUI() { + int retval = func(PARAM(0), PARAM(1), PARAM(2)); + RETURN(retval); +} + +template void WrapI_IIII() { + int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template void WrapI_UIII() { + int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template void WrapI_IIIUI() { + int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4)); + RETURN(retval); +} + +template void WrapI_IUUII() { + int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4)); + RETURN(retval); +} + +template void WrapI_ICIUU() { + int retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2), PARAM(3), PARAM(4)); + RETURN(retval); +} + +template void WrapI_IIU() { + int retval = func(PARAM(0), PARAM(1), PARAM(2)); + RETURN(retval); +} + +template void WrapV_IU() { + func(PARAM(0), PARAM(1)); +} + +template void WrapV_UI() { + func(PARAM(0), PARAM(1)); +} + +template void WrapU_C() { + u32 retval = func(Memory::GetCharPointer(PARAM(0))); + RETURN(retval); +} + +template void WrapU_CCCU() { + u32 retval = func(Memory::GetCharPointer(PARAM(0)), + Memory::GetCharPointer(PARAM(1)), Memory::GetCharPointer(PARAM(2)), + PARAM(3)); + RETURN(retval); +} + +template void WrapI_C() { + int retval = func(Memory::GetCharPointer(PARAM(0))); + RETURN(retval); +} + +template void WrapI_CU() { + int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1)); + RETURN(retval); +} + +template void WrapI_CUI() { + int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2)); + RETURN(retval); +} + +template void WrapI_ICIU() { + int retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template void WrapI_CIU() { + int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2)); + RETURN(retval); +} + +template void WrapI_CUU() { + int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2)); + RETURN(retval); +} + +template void WrapI_CUUU() { + int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), + PARAM(3)); + RETURN(retval); +} + +template void WrapI_CCII() { + int retval = func(Memory::GetCharPointer(PARAM(0)), Memory::GetCharPointer(PARAM(1)), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template void WrapI_CUUIUU() { + int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), + PARAM(3), PARAM(4), PARAM(5)); + RETURN(retval); +} + +template void WrapI_CIIUII() { + int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), + PARAM(3), PARAM(4), PARAM(5)); + RETURN(retval); +} + +template void WrapI_CIUUU() { + int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), + PARAM(3), PARAM(4)); + RETURN(retval); +} + +template void WrapI_CUUUUU() { + int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), + PARAM(3), PARAM(4), PARAM(5)); + RETURN(retval); +} + +template void WrapU_CU() { + u32 retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1)); + RETURN((u32) retval); +} + +template void WrapU_UC() { + u32 retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1))); + RETURN(retval); +} + +template void WrapU_CUU() { + u32 retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2)); + RETURN((u32) retval); +} + +template void WrapU_III() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2)); + RETURN(retval); +} + +template void WrapU_II() { + u32 retval = func(PARAM(0), PARAM(1)); + RETURN(retval); +} + +template void WrapU_IIII() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template void WrapU_IUU() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2)); + RETURN(retval); +} + +template void WrapU_IUUU() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template void WrapU_IUUUU() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4)); + RETURN(retval); +} + +template void WrapU_UUU() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2)); + RETURN(retval); +} + +template void WrapV_IUU() { + func(PARAM(0), PARAM(1), PARAM(2)); +} + +template void WrapV_IIU() { + func(PARAM(0), PARAM(1), PARAM(2)); +} + +template void WrapV_UIU() { + func(PARAM(0), PARAM(1), PARAM(2)); +} + +template void WrapI_UIU() { + int retval = func(PARAM(0), PARAM(1), PARAM(2)); + RETURN(retval); +} + +template void WrapV_IUUUU() { + func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4)); +} + +template void WrapV_UUU() { + func(PARAM(0), PARAM(1), PARAM(2)); +} + +template void WrapV_UUUU() { + func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); +} + +template void WrapV_CUIU() { + func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), PARAM(3)); +} + +template void WrapI_CUIU() { + int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template void WrapV_UCUIU() { + func(PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2), PARAM(3), + PARAM(4)); +} + +template void WrapI_UCUIU() { + int retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2), + PARAM(3), PARAM(4)); + RETURN(retval); +} + +template void WrapV_CUIIU() { + func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), PARAM(3), + PARAM(4)); +} + +template void WrapI_CUIIU() { + int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), + PARAM(3), PARAM(4)); + RETURN(retval); +} + +template void WrapU_UUUU() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template void WrapU_UCUU() { + u32 retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template void WrapU_UUUI() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template void WrapU_UUUIU() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4)); + RETURN(retval); +} + +template void WrapU_UUUIUI() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5)); + RETURN(retval); +} + +template void WrapU_UUIU() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template void WrapU_UIII() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template void WrapI_IUUUU() { + int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4)); + RETURN(retval); +} + +template void WrapI_IUUUUU() { + int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5)); + RETURN(retval); +} + +template void WrapI_IUII() { + int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} +template void WrapU_UUUUU() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4)); + RETURN(retval); +} + +template void WrapV_UUUUU() { + func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4)); +} + +template void WrapU_CC() { + int retval = func(Memory::GetCharPointer(PARAM(0)), + Memory::GetCharPointer(PARAM(1))); + RETURN(retval); +} + +template void WrapV_CI() { + func(Memory::GetCharPointer(PARAM(0)), PARAM(1)); +} + +template void WrapU_CI() { + int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1)); + RETURN(retval); +} + +template void WrapU_CII() { + int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2)); + RETURN(retval); +} + +template void WrapU_CIUIU() { + int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), + PARAM(3), PARAM(4)); + RETURN(retval); +} + +template void WrapU_CIUIUI() { + u32 retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), + PARAM(3), PARAM(4), PARAM(5)); + RETURN(retval); +} + +template void WrapU_UUUUUU() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), + PARAM(5)); + RETURN(retval); +} + +template void WrapI_IUUU() { + int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template void WrapI_IUU() { + int retval = func(PARAM(0), PARAM(1), PARAM(2)); + RETURN(retval); +} + +template void WrapU_UUUUUUU() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5), PARAM(6)); + RETURN(retval); +} + +template void WrapI_UIUU() { + u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); + RETURN(retval); +} + +template void WrapI_IC() { + int retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1))); + RETURN(retval); +} + +template void WrapI_ICCUI() { + int retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)), Memory::GetCharPointer(PARAM(2)), PARAM(3), PARAM(4)); + RETURN(retval); +} + +template void WrapI_ICCI() { + int retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)), Memory::GetCharPointer(PARAM(2)), PARAM(3)); + RETURN(retval); +} + +template void WrapI_CII() { + int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2)); + RETURN(retval); +} + +template void WrapI_ICI() { + int retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2)); + RETURN(retval); +} + +template 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 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, "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 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 { +// const char* GetTypeName() { +// return "Handle"; +// } +//}; + + +typedef u32 Handle; +typedef s32 Result; + + +Result ConnectToPort(Handle* out, const char* port_name);