catto
/
shadPS4
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #69 from GPUCode/main 

core: Cleanup and reorganize
This commit is contained in:
georgemoralis 2023-11-06 06:55:36 +02:00 committed by GitHub
parent 89cf4dbfcb 79c9d9ebd1
commit a01e057632
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
77 changed files with 810 additions and 644 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

78
CMakeLists.txt
View File

@ -30,12 +30,12 @@ endfunction()
add_subdirectory(third-party)
include_directories(src)
set(LIBC_SOURCES src/core/hle/libraries/Libc/Libc.cpp
src/core/hle/libraries/Libc/Libc.h
src/core/hle/libraries/Libc/printf.h
src/core/hle/libraries/Libc/va_ctx.h
src/core/hle/libraries/Libc/libc_cxa.cpp
src/core/hle/libraries/Libc/libc_cxa.h
set(LIBC_SOURCES src/core/hle/libraries/libc/Libc.cpp
src/core/hle/libraries/libc/Libc.h
src/core/hle/libraries/libc/printf.h
src/core/hle/libraries/libc/va_ctx.h
src/core/hle/libraries/libc/libc_cxa.cpp
src/core/hle/libraries/libc/libc_cxa.h
src/core/hle/libraries/libc/libc_stdio.cpp
src/core/hle/libraries/libc/libc_stdio.h
src/core/hle/libraries/libc/libc_math.cpp
@ -45,8 +45,8 @@ set(LIBC_SOURCES src/core/hle/libraries/Libc/Libc.cpp
src/core/hle/libraries/libc/libc_stdlib.cpp
src/core/hle/libraries/libc/libc_stdlib.h
)
set(USERSERVICE_SOURCES src/core/hle/libraries/libuserservice/user_service.cpp
src/core/hle/libraries/libuserservice/user_service.h
set(USERSERVICE_SOURCES src/core/hle/libraries/libuserservice/libuserservice.cpp
src/core/hle/libraries/libuserservice/libuserservice.h
)
set(PAD_SOURCES src/core/hle/libraries/libpad/pad.cpp
@ -78,6 +78,8 @@ add_executable(shadps4
src/common/singleton.h
src/common/string_util.cpp
src/common/string_util.h
src/common/timer.cpp
src/common/timer.h
src/common/types.h
src/common/version.h
${LIBC_SOURCES}
@ -86,50 +88,48 @@ add_executable(shadps4
${SYSTEMSERVICE_SOURCES}
${FILESYSTEM_SOURCES}
${HOST_SOURCES}
src/Lib/Timer.cpp
src/Lib/Timer.h
src/main.cpp
src/core/PS4/Loader/Elf.cpp
src/core/PS4/Loader/Elf.h
src/core/loader/elf.cpp
src/core/loader/elf.h
src/GUI/ElfViewer.cpp
src/GUI/ElfViewer.h
src/Util/config.cpp
src/Util/config.h
src/core/virtual_memory.cpp
src/core/virtual_memory.h
src/core/PS4/Linker.cpp
src/core/PS4/Linker.h
src/core/PS4/Stubs.cpp
src/core/PS4/Stubs.h
src/core/PS4/Util/aerolib.cpp
src/core/PS4/HLE/Kernel/Objects/physical_memory.h
src/core/PS4/HLE/Kernel/Objects/physical_memory.cpp
src/core/linker.cpp
src/core/linker.h
src/core/aerolib/stubs.cpp
src/core/aerolib/stubs.h
src/core/aerolib/aerolib.cpp
src/core/aerolib/aerolib.h
src/core/hle/kernel/Objects/physical_memory.h
src/core/hle/kernel/Objects/physical_memory.cpp
src/core/PS4/HLE/Graphics/video_out.cpp
src/core/PS4/HLE/Graphics/video_out.h
src/core/PS4/HLE/Kernel/event_queues.cpp
src/core/PS4/HLE/Kernel/event_queues.h
src/core/PS4/HLE/Kernel/cpu_management.cpp
src/core/PS4/HLE/Kernel/cpu_management.h
src/core/PS4/Util/aerolib.h
src/core/PS4/Loader/SymbolsResolver.h
src/core/PS4/Loader/SymbolsResolver.cpp
src/core/PS4/HLE/Libs.cpp
src/core/PS4/HLE/Libs.h
src/core/PS4/HLE/LibKernel.cpp
src/core/PS4/HLE/LibKernel.h
src/core/PS4/HLE/LibSceGnmDriver.cpp
src/core/PS4/HLE/LibSceGnmDriver.h
src/core/PS4/HLE/Kernel/ThreadManagement.cpp
src/core/PS4/HLE/Kernel/ThreadManagement.h
src/core/PS4/HLE/ErrorCodes.h
src/core/PS4/HLE/Kernel/memory_management.cpp
src/core/PS4/HLE/Kernel/memory_management.h
src/core/hle/kernel/event_queues.cpp
src/core/hle/kernel/event_queues.h
src/core/hle/kernel/cpu_management.cpp
src/core/hle/kernel/cpu_management.h
src/core/loader/symbols_resolver.h
src/core/loader/symbols_resolver.cpp
src/core/hle/libraries/libs.cpp
src/core/hle/libraries/libs.h
src/core/hle/libraries/libkernel/libkernel.cpp
src/core/hle/libraries/libkernel/libkernel.h
src/core/hle/libraries/libscegnmdriver/libscegnmdriver.cpp
src/core/hle/libraries/libscegnmdriver/libscegnmdriver.h
src/core/hle/kernel/thread_management.cpp
src/core/hle/kernel/thread_management.h
src/core/hle/kernel/memory_management.cpp
src/core/hle/kernel/memory_management.h
src/core/hle/error_codes.h
src/core/PS4/GPU/gpu_memory.cpp
src/core/PS4/GPU/gpu_memory.h
src/emulator.cpp
src/emulator.h
src/core/PS4/HLE/Kernel/Objects/event_queue.h
src/core/PS4/HLE/Kernel/Objects/event_queue.cpp
src/core/hle/kernel/Objects/event_queue.h
src/core/hle/kernel/Objects/event_queue.cpp
src/core/PS4/HLE/Graphics/Objects/video_out_ctx.cpp
src/core/PS4/HLE/Graphics/Objects/video_out_ctx.h
src/core/PS4/HLE/Graphics/graphics_ctx.h

11
src/GUI/ElfViewer.cpp
View File

@ -1,14 +1,12 @@
#include "ElfViewer.h"
#include "core/loader/elf.h"
#include "GUI/ElfViewer.h"
#include "imgui.h"
ElfViewer::ElfViewer(Elf* elf)
{
ElfViewer::ElfViewer(Core::Loader::Elf* elf) {
this->elf = elf;
}
//function to display Self/Elf window
void ElfViewer::display(bool enabled)
{
void ElfViewer::Display(bool enabled) {
int SELF_HEADER = 0;
int ELF_HEADER = 1;
int SEG_HEADER_START = 100;
@ -97,5 +95,4 @@ void ElfViewer::display(bool enabled)
}
ImGui::EndChild();
ImGui::End();
}

14
src/GUI/ElfViewer.h
View File

@ -1,11 +1,15 @@
#pragma once
#include "../core/PS4/Loader/Elf.h"
namespace Core::Loader {
class Elf;
}
class ElfViewer {
private:
Elf* elf;
public:
ElfViewer(Elf* elf);
void display(bool enabled);//display imgui window
explicit ElfViewer(Core::Loader::Elf* elf);
void Display(bool enabled);
private:
Core::Loader::Elf* elf;
};

34
src/Lib/Timer.h
View File

@ -1,34 +0,0 @@
#pragma once
#include "common/types.h"
namespace Lib {
class Timer final
{
public:
Timer();
~Timer() = default;
void Start();
void Pause();
void Resume();
bool IsPaused() const;
double GetTimeMsec() const;// return time in milliseconds
double GetTimeSec() const;// return time in seconds
u64 GetTicks() const;// return time in ticks
u64 GetFrequency() const;// return ticks frequency
[[nodiscard]] static u64 getQueryPerformanceCounter();
public:
Timer(const Timer&) = delete;
Timer& operator=(const Timer&) = delete;
Timer(Timer&&) = delete;
Timer& operator=(Timer&&) = delete;
private:
bool m_is_timer_paused = true;
u64 m_Frequency = 0;
u64 m_StartTime = 0;
u64 m_PauseTime = 0;
};
}

25
src/Lib/Timer.cpp → src/common/timer.cpp
View File

@ -1,10 +1,12 @@
#include "Timer.h"
#include "common/timer.h"
#ifdef _WIN64
#include <windows.h>
#endif
Lib::Timer::Timer() {
namespace Common {
Timer::Timer() {
#ifdef _WIN64
LARGE_INTEGER f;
QueryPerformanceFrequency(&f);
@ -14,7 +16,7 @@ Lib::Timer::Timer() {
#endif
}
void Lib::Timer::Start() {
void Timer::Start() {
#ifdef _WIN64
LARGE_INTEGER c;
QueryPerformanceCounter(&c);
@ -25,7 +27,7 @@ void Lib::Timer::Start() {
m_is_timer_paused = false;
}
void Lib::Timer::Pause() {
void Timer::Pause() {
#ifdef _WIN64
LARGE_INTEGER c;
QueryPerformanceCounter(&c);
@ -36,7 +38,7 @@ void Lib::Timer::Pause() {
m_is_timer_paused = true;
}
void Lib::Timer::Resume() {
void Timer::Resume() {
u64 current_time = 0;
#ifdef _WIN64
LARGE_INTEGER c;
@ -49,9 +51,7 @@ void Lib::Timer::Resume() {
m_is_timer_paused = false;
}
bool Lib::Timer::IsPaused() const { return m_is_timer_paused; }
double Lib::Timer::GetTimeMsec() const {
double Timer::GetTimeMsec() const {
if (m_is_timer_paused) {
return 1000.0 * (static_cast<double>(m_PauseTime - m_StartTime)) / static_cast<double>(m_Frequency);
}
@ -67,7 +67,7 @@ double Lib::Timer::GetTimeMsec() const {
return 1000.0 * (static_cast<double>(current_time - m_StartTime)) / static_cast<double>(m_Frequency);
}
double Lib::Timer::GetTimeSec() const {
double Timer::GetTimeSec() const {
if (m_is_timer_paused) {
return (static_cast<double>(m_PauseTime - m_StartTime)) / static_cast<double>(m_Frequency);
}
@ -83,7 +83,7 @@ double Lib::Timer::GetTimeSec() const {
return (static_cast<double>(current_time - m_StartTime)) / static_cast<double>(m_Frequency);
}
u64 Lib::Timer::GetTicks() const {
u64 Timer::GetTicks() const {
if (m_is_timer_paused) {
return (m_PauseTime - m_StartTime);
}
@ -99,11 +99,10 @@ u64 Lib::Timer::GetTicks() const {
return (current_time - m_StartTime);
}
u64 Lib::Timer::GetFrequency() const { return m_Frequency; }
u64 Lib::Timer::getQueryPerformanceCounter() {
u64 Timer::getQueryPerformanceCounter() {
LARGE_INTEGER c;
QueryPerformanceCounter(&c);
return c.QuadPart;
}
} // namespace Common

43
src/common/timer.h Normal file
View File

@ -0,0 +1,43 @@
#pragma once
#include "common/types.h"
namespace Common {
class Timer final {
public:
Timer();
~Timer() = default;
void Start();
void Pause();
void Resume();
bool IsPaused() const {
return m_is_timer_paused;
}
u64 GetFrequency() const {
return m_Frequency;
}
double GetTimeMsec() const;
double GetTimeSec() const;
u64 GetTicks() const;
[[nodiscard]] static u64 getQueryPerformanceCounter();
public:
Timer(const Timer&) = delete;
Timer& operator=(const Timer&) = delete;
Timer(Timer&&) = delete;
Timer& operator=(Timer&&) = delete;
private:
bool m_is_timer_paused = true;
u64 m_Frequency{};
u64 m_StartTime{};
u64 m_PauseTime{};
};
} // namespace Common

11
src/core/PS4/HLE/Graphics/Objects/video_out_ctx.cpp
View File

@ -1,8 +1,6 @@
#include "video_out_ctx.h"
#include <core/PS4/HLE/LibKernel.h>
#include "common/debug.h"
#include <core/hle/libraries/libkernel/time_management.h>
#include "core/PS4/HLE/Graphics/Objects/video_out_ctx.h"
#include "core/hle/libraries/libkernel/time_management.h"
namespace HLE::Graphics::Objects {
@ -12,6 +10,7 @@ void VideoOutCtx::Init(u32 width, u32 height) {
m_video_out_ctx.m_resolution.paneWidth = width;
m_video_out_ctx.m_resolution.paneHeight = height;
}
int VideoOutCtx::Open() {
std::scoped_lock lock{m_mutex};
@ -112,7 +111,7 @@ bool FlipQueue::flip(u32 micros) {
std::scoped_lock cfg_lock{request->cfg->m_mutex};
for (auto& flip_eq : request->cfg->m_flip_evtEq) {
if (flip_eq != nullptr) {
flip_eq->triggerEvent(SCE_VIDEO_OUT_EVENT_FLIP, HLE::Kernel::Objects::EVFILT_VIDEO_OUT, reinterpret_cast<void*>(request->flip_arg));
flip_eq->triggerEvent(SCE_VIDEO_OUT_EVENT_FLIP, Core::Kernel::EVFILT_VIDEO_OUT, reinterpret_cast<void*>(request->flip_arg));
}
}
}
@ -131,4 +130,4 @@ bool FlipQueue::flip(u32 micros) {
return true;
}
}; // namespace HLE::Graphics::Objects
} // namespace HLE::Graphics::Objects

5
src/core/PS4/HLE/Graphics/Objects/video_out_ctx.h
View File

@ -24,7 +24,7 @@ struct VideoConfigInternal {
bool isOpened = false;
SceVideoOutFlipStatus m_flip_status;
SceVideoOutVblankStatus m_vblank_status;
std::vector<HLE::Libs::LibKernel::EventQueues::SceKernelEqueue> m_flip_evtEq;
std::vector<Core::Kernel::SceKernelEqueue> m_flip_evtEq;
int m_flip_rate = 0;
VideoOutBufferInfo buffers[16];
std::vector<VideoOutBufferSetInternal> buffers_sets;
@ -78,4 +78,5 @@ class VideoOutCtx {
FlipQueue m_flip_queue;
HLE::Libs::Graphics::GraphicCtx* m_graphic_ctx = nullptr;
};
}; // namespace HLE::Graphics::Objects
} // namespace HLE::Graphics::Objects

60
src/core/PS4/HLE/Graphics/video_out.cpp
View File

@ -1,19 +1,17 @@
#include "video_out.h"
#include <core/PS4/GPU/gpu_memory.h>
#include <core/PS4/GPU/video_out_buffer.h>
#include <core/PS4/HLE/ErrorCodes.h>
#include <core/PS4/HLE/LibSceGnmDriver.h>
#include <core/PS4/HLE/Libs.h>
#include <core/PS4/HLE/UserManagement/UsrMngCodes.h>
#include <Util/config.h>
#include <cstdio>
#include <string>
#include <magic_enum.hpp>
#include "common/log.h"
#include "common/debug.h"
#include <stdio.h>
#include <magic_enum.hpp>
#include <string>
#include "core/loader/symbols_resolver.h"
#include "core/PS4/HLE/Graphics/video_out.h"
#include "core/PS4/GPU/gpu_memory.h"
#include "core/PS4/GPU/video_out_buffer.h"
#include "core/hle/error_codes.h"
#include "core/hle/libraries/libscegnmdriver/libscegnmdriver.h"
#include "core/hle/libraries/libs.h"
#include "core/hle/libraries/libuserservice/usr_mng_codes.h"
#include "Util/config.h"
#include "Objects/video_out_ctx.h"
#include "common/singleton.h"
#include "emulator.h"
@ -60,7 +58,7 @@ void PS4_SYSV_ABI sceVideoOutSetBufferAttribute(SceVideoOutBufferAttribute* attr
LOG_INFO_IF(log_file_videoout, "height = {}\n", height);
LOG_INFO_IF(log_file_videoout, "pitchInPixel = {}\n", pitchInPixel);
memset(attribute, 0, sizeof(SceVideoOutBufferAttribute));
std::memset(attribute, 0, sizeof(SceVideoOutBufferAttribute));
attribute->pixelFormat = pixelFormat;
attribute->tilingMode = tilingMode;
@ -71,21 +69,23 @@ void PS4_SYSV_ABI sceVideoOutSetBufferAttribute(SceVideoOutBufferAttribute* attr
attribute->option = SCE_VIDEO_OUT_BUFFER_ATTRIBUTE_OPTION_NONE;
}
static void flip_reset_event_func(HLE::Kernel::Objects::EqueueEvent* event) {
static void flip_reset_event_func(Core::Kernel::EqueueEvent* event) {
event->isTriggered = false;
event->event.fflags = 0;
event->event.data = 0;
}
static void flip_trigger_event_func(HLE::Kernel::Objects::EqueueEvent* event, void* trigger_data) {
static void flip_trigger_event_func(Core::Kernel::EqueueEvent* event, void* trigger_data) {
event->isTriggered = true;
event->event.fflags++;
event->event.data = reinterpret_cast<intptr_t>(trigger_data);
}
static void flip_delete_event_func(LibKernel::EventQueues::SceKernelEqueue eq, HLE::Kernel::Objects::EqueueEvent* event) {
static void flip_delete_event_func(Core::Kernel::SceKernelEqueue eq, Core::Kernel::EqueueEvent* event) {
BREAKPOINT(); // TODO
}
s32 PS4_SYSV_ABI sceVideoOutAddFlipEvent(LibKernel::EventQueues::SceKernelEqueue eq, s32 handle, void* udata) {
s32 PS4_SYSV_ABI sceVideoOutAddFlipEvent(Core::Kernel::SceKernelEqueue eq, s32 handle, void* udata) {
PRINT_FUNCTION_NAME();
auto* videoOut = Common::Singleton<HLE::Graphics::Objects::VideoOutCtx>::Instance();
@ -100,10 +100,10 @@ s32 PS4_SYSV_ABI sceVideoOutAddFlipEvent(LibKernel::EventQueues::SceKernelEqueue
return SCE_VIDEO_OUT_ERROR_INVALID_EVENT_QUEUE;
}
HLE::Kernel::Objects::EqueueEvent event;
Core::Kernel::EqueueEvent event{};
event.isTriggered = false;
event.event.ident = SCE_VIDEO_OUT_EVENT_FLIP;
event.event.filter = HLE::Kernel::Objects::EVFILT_VIDEO_OUT;
event.event.filter = Core::Kernel::EVFILT_VIDEO_OUT;
event.event.udata = udata;
event.event.fflags = 0;
event.event.data = 0;
@ -213,18 +213,21 @@ s32 PS4_SYSV_ABI sceVideoOutRegisterBuffers(s32 handle, s32 startIndex, void* co
return registration_index;
}
s32 PS4_SYSV_ABI sceVideoOutSetFlipRate(s32 handle, s32 rate) {
PRINT_FUNCTION_NAME();
auto* videoOut = Common::Singleton<HLE::Graphics::Objects::VideoOutCtx>::Instance();
videoOut->getCtx(handle)->m_flip_rate = rate;
return SCE_OK;
}
s32 PS4_SYSV_ABI sceVideoOutIsFlipPending(s32 handle) {
PRINT_FUNCTION_NAME();
auto* videoOut = Common::Singleton<HLE::Graphics::Objects::VideoOutCtx>::Instance();
s32 pending = videoOut->getCtx(handle)->m_flip_status.flipPendingNum;
return pending;
}
s32 PS4_SYSV_ABI sceVideoOutSubmitFlip(s32 handle, s32 bufferIndex, s32 flipMode, s64 flipArg) {
PRINT_FUNCTION_NAME();
auto* videoOut = Common::Singleton<HLE::Graphics::Objects::VideoOutCtx>::Instance();
@ -249,9 +252,10 @@ s32 PS4_SYSV_ABI sceVideoOutSubmitFlip(s32 handle, s32 bufferIndex, s32 flipMode
LOG_TRACE_IF(log_file_videoout, "sceVideoOutSubmitFlip flip queue is full\n");
return SCE_VIDEO_OUT_ERROR_FLIP_QUEUE_FULL;
}
HLE::Libs::LibSceGnmDriver::sceGnmFlushGarlic(); // hackish should be done that neccesary for niko's homebrew
Core::Libraries::LibSceGnmDriver::sceGnmFlushGarlic(); // hackish should be done that neccesary for niko's homebrew
return SCE_OK;
}
s32 PS4_SYSV_ABI sceVideoOutGetFlipStatus(s32 handle, SceVideoOutFlipStatus* status) {
PRINT_FUNCTION_NAME();
auto* videoOut = Common::Singleton<HLE::Graphics::Objects::VideoOutCtx>::Instance();
@ -268,12 +272,14 @@ s32 PS4_SYSV_ABI sceVideoOutGetFlipStatus(s32 handle, SceVideoOutFlipStatus* sta
LOG_INFO_IF(log_file_videoout, "currentBuffer = {}\n", status->currentBuffer);
return 0;
}
s32 PS4_SYSV_ABI sceVideoOutGetResolutionStatus(s32 handle, SceVideoOutResolutionStatus* status) {
PRINT_FUNCTION_NAME();
auto* videoOut = Common::Singleton<HLE::Graphics::Objects::VideoOutCtx>::Instance();
*status = videoOut->getCtx(handle)->m_resolution;
return SCE_OK;
}
s32 PS4_SYSV_ABI sceVideoOutOpen(SceUserServiceUserId userId, s32 busType, s32 index, const void* param) {
PRINT_FUNCTION_NAME();
if (userId != SCE_USER_SERVICE_USER_ID_SYSTEM && userId != 0) {
@ -299,14 +305,20 @@ s32 PS4_SYSV_ABI sceVideoOutOpen(SceUserServiceUserId userId, s32 busType, s32 i
return handle;
}
s32 PS4_SYSV_ABI sceVideoOutClose(s32 handle) {
auto* videoOut = Common::Singleton<HLE::Graphics::Objects::VideoOutCtx>::Instance();
videoOut->Close(handle);
return SCE_OK;
}
s32 PS4_SYSV_ABI sceVideoOutUnregisterBuffers(s32 handle, s32 attributeIndex) { BREAKPOINT(); }
void videoOutRegisterLib(SymbolsResolver* sym) {
s32 PS4_SYSV_ABI sceVideoOutUnregisterBuffers(s32 handle, s32 attributeIndex) {
BREAKPOINT();
return 0;
}
void videoOutRegisterLib(Core::Loader::SymbolsResolver* sym) {
using namespace Core;
LIB_FUNCTION("SbU3dwp80lQ", "libSceVideoOut", 1, "libSceVideoOut", 0, 0, sceVideoOutGetFlipStatus);
LIB_FUNCTION("U46NwOiJpys", "libSceVideoOut", 1, "libSceVideoOut", 0, 0, sceVideoOutSubmitFlip);
LIB_FUNCTION("w3BY+tAEiQY", "libSceVideoOut", 1, "libSceVideoOut", 0, 0, sceVideoOutRegisterBuffers);

12
src/core/PS4/HLE/Graphics/video_out.h
View File

@ -1,8 +1,11 @@
#pragma once
#include <core/PS4/HLE/Kernel/event_queues.h>
#include <core/PS4/Loader/SymbolsResolver.h>
#include <string>
#include "core/hle/kernel/event_queues.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace HLE::Libs::Graphics::VideoOut {
@ -95,12 +98,12 @@ struct VideoOutBufferSetInternal {
void videoOutInit(u32 width, u32 height);
std::string getPixelFormatString(s32 format);
void videoOutRegisterLib(SymbolsResolver* sym);
void videoOutRegisterLib(Core::Loader::SymbolsResolver* sym);
bool videoOutFlip(u32 micros);
void PS4_SYSV_ABI sceVideoOutSetBufferAttribute(SceVideoOutBufferAttribute* attribute, u32 pixelFormat, u32 tilingMode, u32 aspectRatio, u32 width,
u32 height, u32 pitchInPixel);
s32 PS4_SYSV_ABI sceVideoOutAddFlipEvent(LibKernel::EventQueues::SceKernelEqueue eq, s32 handle, void* udata);
s32 PS4_SYSV_ABI sceVideoOutAddFlipEvent(Core::Kernel::SceKernelEqueue eq, s32 handle, void* udata);
s32 PS4_SYSV_ABI sceVideoOutRegisterBuffers(s32 handle, s32 startIndex, void* const* addresses, s32 bufferNum,
const SceVideoOutBufferAttribute* attribute);
s32 PS4_SYSV_ABI sceVideoOutSetFlipRate(s32 handle, s32 rate);
@ -110,4 +113,5 @@ s32 PS4_SYSV_ABI sceVideoOutGetFlipStatus(s32 handle, SceVideoOutFlipStatus* sta
s32 PS4_SYSV_ABI sceVideoOutGetResolutionStatus(s32 handle, SceVideoOutResolutionStatus* status);
s32 PS4_SYSV_ABI sceVideoOutOpen(SceUserServiceUserId userId, s32 busType, s32 index, const void* param);
s32 PS4_SYSV_ABI sceVideoOutClose(s32 handle);
} // namespace HLE::Libs::Graphics::VideoOut

13
src/core/PS4/HLE/Kernel/cpu_management.cpp
View File

@ -1,13 +0,0 @@
#include "cpu_management.h"
#include "Util/config.h"
#include "common/log.h"
#include <core/PS4/HLE/Libs.h>
namespace HLE::Libs::LibKernel::CPUManagement {
int PS4_SYSV_ABI sceKernelIsNeoMode() {
PRINT_FUNCTION_NAME();
bool isNeo = Config::isNeoMode();
return isNeo ? 1 : 0;
}
}; // namespace HLE::Libs::LibKernel::CPUManagement

12
src/core/PS4/HLE/Kernel/event_queues.h
View File

@ -1,12 +0,0 @@
#pragma once
#include "Objects/event_queue.h"
namespace HLE::Libs::LibKernel::EventQueues {
using SceKernelUseconds = u32;
using SceKernelEqueue = Kernel::Objects::EqueueInternal*;
int PS4_SYSV_ABI sceKernelCreateEqueue(SceKernelEqueue* eq, const char* name);
int PS4_SYSV_ABI sceKernelWaitEqueue(SceKernelEqueue eq, HLE::Kernel::Objects::SceKernelEvent* ev, int num, int* out, SceKernelUseconds *timo);
}; // namespace HLE::Libs::LibKernel::EventQueues

10
src/core/PS4/HLE/LibKernel.h
View File

@ -1,10 +0,0 @@
#include "../Loader/SymbolsResolver.h"
namespace HLE::Libs::LibKernel {
void LibKernel_Register(SymbolsResolver* sym);
// functions
int32_t PS4_SYSV_ABI sceKernelReleaseDirectMemory(off_t start, size_t len);
}; // namespace HLE::Libs::LibKernel

27
src/core/PS4/HLE/LibSceGnmDriver.cpp
View File

@ -1,27 +0,0 @@
#include "LibSceGnmDriver.h"
#include "Libs.h"
#include "../Loader/Elf.h"
#include "common/log.h"
#include "common/debug.h"
#include <core/PS4/GPU/gpu_memory.h>
#include <emulator.h>
namespace HLE::Libs::LibSceGnmDriver {
int32_t sceGnmSubmitDone()
{
PRINT_DUMMY_FUNCTION_NAME();
return 0;
}
void sceGnmFlushGarlic() { PRINT_FUNCTION_NAME();
GPU::flushGarlic(Emu::getGraphicCtx());
}
void LibSceGnmDriver_Register(SymbolsResolver* sym)
{
LIB_FUNCTION("yvZ73uQUqrk", "libSceGnmDriver", 1, "libSceGnmDriver", 1, 1, sceGnmSubmitDone);
LIB_FUNCTION("iBt3Oe00Kvc", "libSceGnmDriver", 1, "libSceGnmDriver", 1, 1, sceGnmFlushGarlic);
}
};

9
src/core/PS4/HLE/LibSceGnmDriver.h
View File

@ -1,9 +0,0 @@
#pragma once
#include "../Loader/SymbolsResolver.h"
namespace HLE::Libs::LibSceGnmDriver {
void LibSceGnmDriver_Register(SymbolsResolver* sym);
int32_t sceGnmSubmitDone();
void sceGnmFlushGarlic();
}; // namespace HLE::Libs::LibSceGnmDriver

23
src/core/PS4/HLE/Libs.cpp
View File

@ -1,23 +0,0 @@
#include "Libs.h"
#include "LibKernel.h"
#include "LibSceGnmDriver.h"
#include <core/PS4/HLE/Graphics/video_out.h>
#include "core/hle/libraries/libuserservice/user_service.h"
#include "core/hle/libraries/libpad/pad.h"
#include <core/hle/libraries/libsystemservice/system_service.h>
#include "core/hle/libraries/libc/libc.h"
namespace HLE::Libs {
void Init_HLE_Libs(SymbolsResolver *sym) {
LibKernel::LibKernel_Register(sym);
Graphics::VideoOut::videoOutRegisterLib(sym);
LibSceGnmDriver::LibSceGnmDriver_Register(sym);
Core::Libraries::LibUserService::userServiceSymbolsRegister(sym);
Core::Libraries::LibPad::padSymbolsRegister(sym);
Core::Libraries::LibSystemService::systemServiceSymbolsRegister(sym);
Core::Libraries::LibC::libcSymbolsRegister(sym);
}
} // namespace HLE::Libs

4
src/core/PS4/Stubs.h
View File

@ -1,4 +0,0 @@
#include "common/types.h"
u64 UnresolvedStub();
u64 GetStub(const char *nid);

38
src/core/PS4/Util/aerolib.cpp
View File

@ -1,38 +0,0 @@
#include "aerolib.h"
#include "common/types.h"
#include <string.h>
#include "common/log.h"
namespace aerolib {
// Use a direct table here + binary search as contents are static
nid_entry nids[] = {
#define STUB(nid, name) \
{ nid, #name },
#include "aerolib.inl"
#undef STUB
};
nid_entry* find_by_nid(const char* nid) {
s64 l = 0;
s64 r = sizeof(nids) / sizeof(nids[0]) - 1;
while (l <= r) {
size_t m = l + (r - l) / 2;
int cmp = strcmp(nids[m].nid, nid);
if (cmp == 0)
return &nids[m];
else if (cmp < 0)
l = m + 1;
else
r = m - 1;
}
return nullptr;
}
} // namespace aerolib

11
src/core/PS4/Util/aerolib.h
View File

@ -1,11 +0,0 @@
#include <stdint.h>
namespace aerolib {
struct nid_entry {
const char* nid;
const char* name;
};
nid_entry* find_by_nid(const char* nid);
};

33
src/core/aerolib/aerolib.cpp Normal file
View File

@ -0,0 +1,33 @@
#include <cstring>
#include "common/types.h"
#include "core/aerolib/aerolib.h"
namespace Core::AeroLib {
// Use a direct table here + binary search as contents are static
static constexpr NidEntry NIDS[] = {
#define STUB(nid, name) \
{ nid, #name },
#include "aerolib.inl"
#undef STUB
};
const NidEntry* FindByNid(const char* nid) {
s64 l = 0;
s64 r = sizeof(NIDS) / sizeof(NIDS[0]) - 1;
while (l <= r) {
const size_t m = l + (r - l) / 2;
const int cmp = std::strcmp(NIDS[m].nid, nid);
if (cmp == 0) {
return &NIDS[m];
} else if (cmp < 0) {
l = m + 1;
} else {
r = m - 1;
}
}
return nullptr;
}
} // namespace Core::AeroLib

14
src/core/aerolib/aerolib.h Normal file
View File

@ -0,0 +1,14 @@
#pragma once
#include <cstdint>
namespace Core::AeroLib {
struct NidEntry {
const char* nid;
const char* name;
};
const NidEntry* FindByNid(const char* nid);
} // namespace Core::AeroLib

0
src/core/PS4/Util/aerolib.inl → src/core/aerolib/aerolib.inl
View File

16
src/core/PS4/Stubs.cpp → src/core/aerolib/stubs.cpp
View File

@ -1,8 +1,8 @@
#include "Stubs.h"
#include "Util/aerolib.h"
#include "common/log.h"
#include "core/aerolib/aerolib.h"
#include "core/aerolib/stubs.h"
namespace Core::AeroLib {
// Helper to provide stub implementations for missing functions
//
@ -16,7 +16,7 @@
// and to longer compile / CI times
//
// Must match STUBS_LIST define
#define MAX_STUBS 128
constexpr u32 MAX_STUBS = 128;
u64 UnresolvedStub() {
LOG_ERROR("Unresolved Stub: called, returning zero to {}\n", __builtin_return_address(0));
@ -29,7 +29,7 @@ static u64 UnknownStub() {
}
static aerolib::nid_entry* stub_nids[MAX_STUBS];
static const NidEntry* stub_nids[MAX_STUBS];
static std::string stub_nids_unknown[MAX_STUBS];
template <int stub_index>
@ -69,7 +69,7 @@ u64 GetStub(const char* nid) {
return (u64)&UnknownStub;
}
auto entry = aerolib::find_by_nid(nid);
const auto entry = FindByNid(nid);
if (!entry) {
stub_nids_unknown[UsedStubEntries] = nid;
} else {
@ -78,3 +78,5 @@ u64 GetStub(const char* nid) {
return (u64)stub_handlers[UsedStubEntries++];
}
} // namespace Core::AeroLib

11
src/core/aerolib/stubs.h Normal file
View File

@ -0,0 +1,11 @@
#pragma once
#include "common/types.h"
namespace Core::AeroLib {
u64 UnresolvedStub();
u64 GetStub(const char* nid);
} // namespace Core::AeroLib

1
src/core/PS4/HLE/ErrorCodes.h → src/core/hle/error_codes.h
View File

@ -1,4 +1,5 @@
#pragma once
constexpr int SCE_OK = 0;
constexpr int SCE_KERNEL_ERROR_EBADF = 0x80020009;

15
src/core/PS4/HLE/Kernel/Objects/event_queue.cpp → src/core/hle/kernel/Objects/event_queue.cpp
View File

@ -1,11 +1,10 @@
#include "event_queue.h"
#include <Lib/Timer.h>
#include "common/debug.h"
#include "common/timer.h"
#include "core/hle/kernel/objects/event_queue.h"
namespace HLE::Kernel::Objects {
EqueueInternal::~EqueueInternal() {}
namespace Core::Kernel {
EqueueInternal::~EqueueInternal() = default;
int EqueueInternal::addEvent(const EqueueEvent& event) {
std::scoped_lock lock{m_mutex};
@ -27,7 +26,7 @@ int EqueueInternal::waitForEvents(SceKernelEvent* ev, int num, u32 micros) {
std::unique_lock lock{m_mutex};
u32 timeElapsed = 0;
Lib::Timer t;
Common::Timer t;
t.Start();
for (;;) {
@ -87,4 +86,4 @@ int EqueueInternal::getTriggeredEvents(SceKernelEvent* ev, int num) {
return ret;
}
}; // namespace HLE::Kernel::Objects
} // namespace Core::Kernel

11
src/core/PS4/HLE/Kernel/Objects/event_queue.h → src/core/hle/kernel/Objects/event_queue.h
View File

@ -1,11 +1,11 @@
#pragma once
#include "common/types.h"
#include <mutex>
#include <string>
#include <vector>
#include "common/types.h"
namespace HLE::Kernel::Objects {
namespace Core::Kernel {
constexpr s16 EVFILT_READ = -1;
constexpr s16 EVFILT_WRITE = -2;
@ -33,11 +33,9 @@ constexpr s16 EVFILT_SYSCOUNT = 22;
class EqueueInternal;
struct EqueueEvent;
using SceKernelEqueue = Kernel::Objects::EqueueInternal*;
using TriggerFunc = void (*)(EqueueEvent* event, void* trigger_data);
using ResetFunc = void (*)(EqueueEvent* event);
using DeleteFunc = void (*)(SceKernelEqueue eq, EqueueEvent* event);
using DeleteFunc = void (*)(EqueueInternal* eq, EqueueEvent* event);
struct SceKernelEvent {
u64 ident = 0; /* identifier for this event */
@ -76,4 +74,5 @@ class EqueueInternal {
std::vector<EqueueEvent> m_events;
std::condition_variable m_cond;
};
}; // namespace HLE::Kernel::Objects
} // namespace Core::Kernel

18
src/core/PS4/HLE/Kernel/Objects/physical_memory.cpp → src/core/hle/kernel/Objects/physical_memory.cpp
View File

@ -1,10 +1,13 @@
#include "physical_memory.h"
#include "core/hle/kernel/objects/physical_memory.h"
namespace HLE::Kernel::Objects {
namespace Core::Kernel {
static u64 AlignUp(u64 pos, u64 align) { return (align != 0 ? (pos + (align - 1)) & ~(align - 1) : pos); }
static u64 AlignUp(u64 pos, u64 align) {
return (align != 0 ? (pos + (align - 1)) & ~(align - 1) : pos);
}
bool PhysicalMemory::Alloc(u64 searchStart, u64 searchEnd, u64 len, u64 alignment, u64* physAddrOut, int memoryType) {
bool PhysicalMemory::Alloc(u64 searchStart, u64 searchEnd, u64 len, u64 alignment,
u64* physAddrOut, int memoryType) {
std::scoped_lock lock{m_mutex};
u64 find_free_pos = 0;
@ -39,7 +42,9 @@ bool PhysicalMemory::Alloc(u64 searchStart, u64 searchEnd, u64 len, u64 alignmen
return false;
}
bool PhysicalMemory::Map(u64 virtual_addr, u64 phys_addr, u64 len, int prot, VirtualMemory::MemoryMode cpu_mode, GPU::MemoryMode gpu_mode) {
bool PhysicalMemory::Map(u64 virtual_addr, u64 phys_addr, u64 len, int prot,
VirtualMemory::MemoryMode cpu_mode, GPU::MemoryMode gpu_mode) {
std::scoped_lock lock{m_mutex};
for (auto& b : m_allocatedBlocks) {
if (phys_addr >= b.start_addr && phys_addr < b.start_addr + b.size) {
@ -59,4 +64,5 @@ bool PhysicalMemory::Map(u64 virtual_addr, u64 phys_addr, u64 len, int prot, Vir
return false;
}
} // namespace HLE::Kernel::Objects
} // namespace Core::Kernel

12
src/core/PS4/HLE/Kernel/Objects/physical_memory.h → src/core/hle/kernel/Objects/physical_memory.h
View File

@ -1,11 +1,13 @@
#pragma once
#include "common/types.h"
#include <core/virtual_memory.h>
#include <core/PS4/GPU/gpu_memory.h>
#include <mutex>
#include <vector>
namespace HLE::Kernel::Objects {
#include "common/types.h"
#include "core/virtual_memory.h"
#include "core/PS4/GPU/gpu_memory.h"
namespace Core::Kernel {
class PhysicalMemory {
public:
@ -31,4 +33,4 @@ class PhysicalMemory {
std::mutex m_mutex;
};
} // namespace HLE::Kernel::Objects
} // namespace Core::Kernel

13
src/core/hle/kernel/cpu_management.cpp Normal file
View File

@ -0,0 +1,13 @@
#include "common/log.h"
#include "core/hle/kernel/cpu_management.h"
#include "core/hle/libraries/libs.h"
#include "Util/config.h"
namespace Core::Kernel {
int PS4_SYSV_ABI sceKernelIsNeoMode() {
PRINT_FUNCTION_NAME();
return Config::isNeoMode();
}
} // namespace Core::Kernel

7
src/core/PS4/HLE/Kernel/cpu_management.h → src/core/hle/kernel/cpu_management.h
View File

@ -1,6 +1,9 @@
#pragma once
#include "common/types.h"
namespace HLE::Libs::LibKernel::CPUManagement {
namespace Core::Kernel {
int PS4_SYSV_ABI sceKernelIsNeoMode();
};
} // namespace Core::Kernel

29
src/core/PS4/HLE/Kernel/event_queues.cpp → src/core/hle/kernel/event_queues.cpp
View File

@ -1,11 +1,11 @@
#include "event_queues.h"
#include <core/PS4/HLE/ErrorCodes.h>
#include <core/PS4/HLE/Libs.h>
#include "common/log.h"
#include "common/debug.h"
#include "common/log.h"
#include "core/hle/kernel/event_queues.h"
#include "core/hle/error_codes.h"
#include "core/hle/libraries/libs.h"
namespace Core::Kernel {
namespace HLE::Libs::LibKernel::EventQueues {
constexpr bool log_file_equeues = true; // disable it to disable logging
int PS4_SYSV_ABI sceKernelCreateEqueue(SceKernelEqueue* eq, const char* name) {
@ -28,15 +28,15 @@ int PS4_SYSV_ABI sceKernelCreateEqueue(SceKernelEqueue* eq, const char* name) {
LOG_TRACE_IF(log_file_equeues, "sceKernelCreateEqueue returned SCE_KERNEL_ERROR_ENAMETOOLONG name size exceeds 32 bytes\n");
return SCE_KERNEL_ERROR_ENAMETOOLONG;
}
*eq = new Kernel::Objects::EqueueInternal;
*eq = new EqueueInternal;
(*eq)->setName(std::string(name));
LOG_INFO_IF(log_file_equeues, "sceKernelCreateEqueue created with name \"{}\"\n", name);
return SCE_OK;
}
int PS4_SYSV_ABI sceKernelWaitEqueue(SceKernelEqueue eq, HLE::Kernel::Objects::SceKernelEvent* ev, int num, int* out, SceKernelUseconds* timo) {
int PS4_SYSV_ABI sceKernelWaitEqueue(SceKernelEqueue eq, SceKernelEvent* ev,
int num, int* out, SceKernelUseconds* timo) {
PRINT_FUNCTION_NAME();
if (eq == nullptr) {
@ -50,17 +50,22 @@ int PS4_SYSV_ABI sceKernelWaitEqueue(SceKernelEqueue eq, HLE::Kernel::Objects::S
if (num < 1) {
return SCE_KERNEL_ERROR_EINVAL;
}
if (timo == nullptr) { // wait until an event arrives without timing out
*out = eq->waitForEvents(ev, num, 0);
}
if (timo != nullptr) {
if (*timo == 0) {//only events that have already arrived at the time of this function call can be received
// Only events that have already arrived at the time of this function call can be received
if (*timo == 0) {
BREAKPOINT();
} else { // wait until an event arrives with timing out
} else {
// Wait until an event arrives with timing out
BREAKPOINT();
}
}
return SCE_OK;
}
}; // namespace HLE::Libs::LibKernel::EventQueues
} // namespace Core::Kernel

14
src/core/hle/kernel/event_queues.h Normal file
View File

@ -0,0 +1,14 @@
#pragma once
#include "core/hle/kernel/objects/event_queue.h"
namespace Core::Kernel {
using SceKernelUseconds = u32;
using SceKernelEqueue = EqueueInternal*;
int PS4_SYSV_ABI sceKernelCreateEqueue(SceKernelEqueue* eq, const char* name);
int PS4_SYSV_ABI sceKernelWaitEqueue(SceKernelEqueue eq, SceKernelEvent* ev,
int num, int* out, SceKernelUseconds *timo);
} // namespace Core::Kernel

33
src/core/PS4/HLE/Kernel/memory_management.cpp → src/core/hle/kernel/memory_management.cpp
View File

@ -1,25 +1,22 @@
#include "memory_management.h"
#include <bit>
#include <magic_enum.hpp>
#include <core/PS4/GPU/gpu_memory.h>
#include <core/virtual_memory.h>
#include "common/log.h"
#include "common/debug.h"
#include <bit>
#include <magic_enum.hpp>
#include "common/singleton.h"
#include "../ErrorCodes.h"
#include "../Libs.h"
#include "Objects/physical_memory.h"
#include "core/hle/kernel/memory_management.h"
#include "core/hle/libraries/libs.h"
#include "core/hle/kernel/Objects/physical_memory.h"
#include "core/hle/error_codes.h"
namespace HLE::Libs::LibKernel::MemoryManagement {
namespace Core::Kernel {
constexpr bool log_file_memory = true; // disable it to disable logging
bool isPowerOfTwo(u64 n) { return std::popcount(n) == 1; }
bool is16KBAligned(u64 n) { return ((n % (16ull * 1024) == 0)); }
bool is16KBAligned(u64 n) {
return ((n % (16ull * 1024) == 0));
}
u64 PS4_SYSV_ABI sceKernelGetDirectMemorySize() {
PRINT_FUNCTION_NAME();
@ -38,7 +35,7 @@ int PS4_SYSV_ABI sceKernelAllocateDirectMemory(s64 searchStart, s64 searchEnd, u
LOG_TRACE_IF(log_file_memory, "sceKernelAllocateDirectMemory returned SCE_KERNEL_ERROR_EINVAL memory range invalid\n");
return SCE_KERNEL_ERROR_EINVAL;
}
if ((alignment != 0 || is16KBAligned(alignment)) && !isPowerOfTwo(alignment)) {
if ((alignment != 0 || is16KBAligned(alignment)) && !std::has_single_bit(alignment)) {
LOG_TRACE_IF(log_file_memory, "sceKernelAllocateDirectMemory returned SCE_KERNEL_ERROR_EINVAL alignment invalid\n");
return SCE_KERNEL_ERROR_EINVAL;
}
@ -55,7 +52,7 @@ int PS4_SYSV_ABI sceKernelAllocateDirectMemory(s64 searchStart, s64 searchEnd, u
LOG_INFO_IF(log_file_memory, "memory_type = {}\n", magic_enum::enum_name(memtype.value()));
u64 physical_addr = 0;
auto* physical_memory = Common::Singleton<HLE::Kernel::Objects::PhysicalMemory>::Instance();
auto* physical_memory = Common::Singleton<PhysicalMemory>::Instance();
if (!physical_memory->Alloc(searchStart, searchEnd, len, alignment, &physical_addr, memoryType)) {
LOG_TRACE_IF(log_file_memory, "sceKernelAllocateDirectMemory returned SCE_KERNEL_ERROR_EAGAIN can't allocate physical memory\n");
return SCE_KERNEL_ERROR_EAGAIN;
@ -76,7 +73,7 @@ int PS4_SYSV_ABI sceKernelMapDirectMemory(void** addr, u64 len, int prot, int fl
return SCE_KERNEL_ERROR_EINVAL;
}
if (alignment != 0) {
if ((!isPowerOfTwo(alignment) && !is16KBAligned(alignment))) {
if ((!std::has_single_bit(alignment) && !is16KBAligned(alignment))) {
LOG_TRACE_IF(log_file_memory, "sceKernelMapDirectMemory returned SCE_KERNEL_ERROR_EINVAL alignment invalid\n");
return SCE_KERNEL_ERROR_EINVAL;
}
@ -115,7 +112,7 @@ int PS4_SYSV_ABI sceKernelMapDirectMemory(void** addr, u64 len, int prot, int fl
return SCE_KERNEL_ERROR_ENOMEM;
}
auto* physical_memory = Common::Singleton<HLE::Kernel::Objects::PhysicalMemory>::Instance();
auto* physical_memory = Common::Singleton<PhysicalMemory>::Instance();
if (!physical_memory->Map(out_addr, directMemoryStart, len, prot, cpu_mode, gpu_mode)) {
BREAKPOINT();
}
@ -126,4 +123,4 @@ int PS4_SYSV_ABI sceKernelMapDirectMemory(void** addr, u64 len, int prot, int fl
return SCE_OK;
}
} // namespace HLE::Libs::LibKernel::MemoryManagement
} // namespace Core::Kernel

10
src/core/PS4/HLE/Kernel/memory_management.h → src/core/hle/kernel/memory_management.h
View File

@ -2,13 +2,9 @@
#include "common/types.h"
// constants
constexpr u64 SCE_KERNEL_MAIN_DMEM_SIZE = 5376_MB; // ~ 6GB
namespace HLE::Libs::LibKernel::MemoryManagement {
// memory types
namespace Core::Kernel {
enum MemoryTypes : u32 {
SCE_KERNEL_WB_ONION = 0, // write - back mode (Onion bus)
@ -21,6 +17,7 @@ enum MemoryFlags : u32 {
SCE_KERNEL_MAP_NO_OVERWRITE = 0x0080,
SCE_KERNEL_MAP_NO_COALESCE = 0x400000
};
enum MemoryProtection : u32 {
SCE_KERNEL_PROT_CPU_READ = 0x01, // Permit reads from the CPU
SCE_KERNEL_PROT_CPU_RW = 0x02, // Permit reads/writes from the CPU
@ -33,4 +30,5 @@ enum MemoryProtection : u32 {
u64 PS4_SYSV_ABI sceKernelGetDirectMemorySize();
int PS4_SYSV_ABI sceKernelAllocateDirectMemory(s64 searchStart, s64 searchEnd, u64 len, u64 alignment, int memoryType, s64* physAddrOut);
int PS4_SYSV_ABI sceKernelMapDirectMemory(void** addr, u64 len, int prot, int flags, s64 directMemoryStart, u64 alignment);
}; // namespace HLE::Libs::LibKernel::MemoryManagement
} // namespace Core::Kernel

19
src/core/PS4/HLE/Kernel/ThreadManagement.cpp → src/core/hle/kernel/thread_management.cpp
View File

@ -1,19 +1,16 @@
#include "ThreadManagement.h"
#include "common/debug.h"
#include "core/hle/kernel/thread_management.h"
#include "core/hle/error_codes.h"
#include "../ErrorCodes.h"
namespace Core::Kernel {
namespace HLE::Libs::LibKernel::ThreadManagement {
thread_local PthreadInternal* g_pthread_self = nullptr;
thread_local PthreadInternal g_pthread_self{};
PThreadCxt* g_pthread_cxt = nullptr;
void Pthread_Init_Self_MainThread() {
g_pthread_self = new PthreadInternal{};
scePthreadAttrInit(&g_pthread_self->attr);
g_pthread_self->pth = pthread_self();
g_pthread_self->name = "Main_Thread";
scePthreadAttrInit(&g_pthread_self.attr);
g_pthread_self.pth = pthread_self();
g_pthread_self.name = "Main_Thread";
}
int scePthreadAttrInit(ScePthreadAttr* attr) {
@ -122,4 +119,4 @@ int scePthreadAttrSetschedpolicy(ScePthreadAttr* attr, int policy) {
return SCE_KERNEL_ERROR_EINVAL;
}
}; // namespace HLE::Libs::LibKernel::ThreadManagement
} // namespace Core::Kernel

6
src/core/PS4/HLE/Kernel/ThreadManagement.h → src/core/hle/kernel/thread_management.h
View File

@ -6,7 +6,7 @@
#include "common/types.h"
#include <string>
namespace HLE::Libs::LibKernel::ThreadManagement {
namespace Core::Kernel {
struct PthreadAttrInternal;
@ -19,6 +19,7 @@ struct PthreadInternal {
pthread_t pth;
ScePthreadAttr attr;
};
struct PthreadAttrInternal {
u08 reserved[64];
u64 affinity;
@ -32,11 +33,10 @@ class PThreadCxt {};
void Pthread_Init_Self_MainThread();
//HLE FUNCTIONS
int scePthreadAttrInit(ScePthreadAttr* attr);
int scePthreadAttrSetdetachstate(ScePthreadAttr* attr, int detachstate);
int scePthreadAttrSetinheritsched(ScePthreadAttr* attr, int inheritSched);
int scePthreadAttrSetschedparam(ScePthreadAttr* attr, const SceKernelSchedParam* param);
int scePthreadAttrSetschedpolicy(ScePthreadAttr* attr, int policy);
} // namespace HLE::Libs::LibKernel::ThreadManagement
} // namespace Core::Kernel

33
src/core/hle/libraries/libc/libc.cpp
View File

@ -1,19 +1,17 @@
#include "libc.h"
#include <cstdlib>
#include "common/debug.h"
#include <stdlib.h>
#include "common/singleton.h"
#include "common/log.h"
#include "core/PS4/HLE/Libs.h"
#include "core/hle/libraries/libc/libc.h"
#include "core/hle/libraries/libc/libc_cxa.h"
#include "core/hle/libraries/libc/libc_math.h"
#include "core/hle/libraries/libc/libc_stdio.h"
#include "core/hle/libraries/libc/libc_stdlib.h"
#include "core/hle/libraries/libc/libc_string.h"
#include "core/hle/libraries/libs.h"
namespace Core::Libraries::LibC {
constexpr bool log_file_libc = true; // disable it to disable logging
static u32 g_need_sceLibc = 1;
@ -39,28 +37,41 @@ static PS4_SYSV_ABI int __cxa_atexit(void (*func)(void*), void* arg, void* dso_h
return 0;
}
void PS4_SYSV_ABI __cxa_finalize(void* d) { __debugbreak(); }
void PS4_SYSV_ABI __cxa_finalize(void* d) {
BREAKPOINT();
}
void PS4_SYSV_ABI __cxa_pure_virtual() { __debugbreak(); }
void PS4_SYSV_ABI __cxa_pure_virtual() {
BREAKPOINT();
}
static PS4_SYSV_ABI void init_env() { PRINT_DUMMY_FUNCTION_NAME(); }
static PS4_SYSV_ABI void init_env() {
PRINT_DUMMY_FUNCTION_NAME();
}
static PS4_SYSV_ABI void catchReturnFromMain(int status) { LOG_INFO_IF(log_file_libc, "catchReturnFromMain returned ={}\n", status); }
static PS4_SYSV_ABI void catchReturnFromMain(int status) {
LOG_INFO_IF(log_file_libc, "catchReturnFromMain returned ={}\n", status);
}
static PS4_SYSV_ABI void _Assert() {
PRINT_DUMMY_FUNCTION_NAME();
BREAKPOINT();
}
PS4_SYSV_ABI void _ZdlPv(void* ptr) { std::free(ptr); }
PS4_SYSV_ABI void _ZdlPv(void* ptr) {
std::free(ptr);
}
PS4_SYSV_ABI void _ZSt11_Xbad_allocv() {
PRINT_DUMMY_FUNCTION_NAME();
BREAKPOINT();
}
PS4_SYSV_ABI void _ZSt14_Xlength_errorPKc() {
PRINT_DUMMY_FUNCTION_NAME();
BREAKPOINT();
}
PS4_SYSV_ABI void* _Znwm(u64 count) {
if (count == 0) {
LOG_ERROR_IF(log_file_libc, "_Znwm count ={}\n", count);
@ -70,7 +81,7 @@ PS4_SYSV_ABI void* _Znwm(u64 count) {
return ptr;
}
void libcSymbolsRegister(SymbolsResolver* sym) {
void libcSymbolsRegister(Loader::SymbolsResolver* sym) {
// cxa functions
LIB_FUNCTION("3GPpjQdAMTw", "libc", 1, "libc", 1, 1, __cxa_guard_acquire);
LIB_FUNCTION("9rAeANT2tyE", "libc", 1, "libc", 1, 1, __cxa_guard_release);

7
src/core/hle/libraries/libc/libc.h
View File

@ -1,10 +1,11 @@
#pragma once
#include "common/types.h"
#include "core/PS4/Loader/SymbolsResolver.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace Core::Libraries::LibC {
void libcSymbolsRegister(SymbolsResolver* sym);
void libcSymbolsRegister(Loader::SymbolsResolver* sym);
} // namespace Core::Libraries::LibC

1
src/core/hle/libraries/libc/libc_cxa.cpp
View File

@ -6,6 +6,7 @@
// adapted from https://opensource.apple.com/source/libcppabi/libcppabi-14/src/cxa_guard.cxx.auto.html
namespace Core::Libraries::LibC {
constexpr bool log_file_cxa = true; // disable it to disable logging
// This file implements the __cxa_guard_* functions as defined at:

2
src/core/hle/libraries/libc/libc_cxa.h
View File

@ -5,7 +5,9 @@
#include "common/types.h"
namespace Core::Libraries::LibC {
int PS4_SYSV_ABI __cxa_guard_acquire(u64* guard_object);
void PS4_SYSV_ABI __cxa_guard_release(u64* guard_object);
void PS4_SYSV_ABI __cxa_guard_abort(u64* guard_object);
} // namespace Core::Libraries::LibC

35
src/core/hle/libraries/libc/libc_math.cpp
View File

@ -1,23 +1,38 @@
#include "libc_math.h"
#include <cmath>
#include "core/hle/libraries/libc/libc_math.h"
namespace Core::Libraries::LibC {
float PS4_SYSV_ABI atan2f(float y, float x) { return std::atan2f(y, x); }
float PS4_SYSV_ABI atan2f(float y, float x) {
return std::atan2f(y, x);
}
float PS4_SYSV_ABI acosf(float num) { return std::acosf(num); }
float PS4_SYSV_ABI acosf(float num) {
return std::acosf(num);
}
float PS4_SYSV_ABI tanf(float num) { return std::tanf(num); }
float PS4_SYSV_ABI tanf(float num) {
return std::tanf(num);
}
float PS4_SYSV_ABI asinf(float num) { return std::asinf(num); }
float PS4_SYSV_ABI asinf(float num) {
return std::asinf(num);
}
double PS4_SYSV_ABI pow(double base, double exponent) { return std::pow(base, exponent); }
double PS4_SYSV_ABI pow(double base, double exponent) {
return std::pow(base, exponent);
}
double PS4_SYSV_ABI _Sin(double x) { return std::sin(x); }
double PS4_SYSV_ABI _Sin(double x) {
return std::sin(x);
}
float PS4_SYSV_ABI _Fsin(float arg) { return std::sinf(arg); }
float PS4_SYSV_ABI _Fsin(float arg) {
return std::sinf(arg);
}
double PS4_SYSV_ABI exp2(double arg) { return std::exp2(arg); }
double PS4_SYSV_ABI exp2(double arg) {
return std::exp2(arg);
}
} // namespace Core::Libraries::LibC

2
src/core/hle/libraries/libc/libc_math.h
View File

@ -3,6 +3,7 @@
#include "common/types.h"
namespace Core::Libraries::LibC {
float PS4_SYSV_ABI atan2f(float y, float x);
float PS4_SYSV_ABI acosf(float num);
float PS4_SYSV_ABI tanf(float num);
@ -11,4 +12,5 @@ double PS4_SYSV_ABI pow(double base, double exponent);
double PS4_SYSV_ABI _Sin(double x);
float PS4_SYSV_ABI _Fsin(float arg);
double PS4_SYSV_ABI exp2(double arg);
} // namespace Core::Libraries::LibC

13
src/core/hle/libraries/libc/libc_stdio.cpp
View File

@ -1,15 +1,16 @@
#include "libc_stdio.h"
#include "common/debug.h"
#include "common/log.h"
#include "core/hle/libraries/libc/libc_stdio.h"
namespace Core::Libraries::LibC {
constexpr bool log_file_libc = true; // disable it to disable logging
int PS4_SYSV_ABI printf(VA_ARGS) {
VA_CTX(ctx);
return printf_ctx(&ctx);
}
int PS4_SYSV_ABI fprintf(FILE* file, VA_ARGS) {
int fd = _fileno(file);
if (fd == 1 || fd == 2) { // output stdout and stderr to console
@ -21,8 +22,12 @@ int PS4_SYSV_ABI fprintf(FILE* file, VA_ARGS) {
return 0;
}
int PS4_SYSV_ABI vsnprintf(char* s, size_t n, const char* format, VaList* arg) { return vsnprintf_ctx(s, n, format, arg); }
int PS4_SYSV_ABI vsnprintf(char* s, size_t n, const char* format, VaList* arg) {
return vsnprintf_ctx(s, n, format, arg);
}
int PS4_SYSV_ABI puts(const char* s) { return std::puts(s); }
int PS4_SYSV_ABI puts(const char* s) {
return std::puts(s);
}
} // namespace Core::Libraries::LibC

5
src/core/hle/libraries/libc/libc_stdio.h
View File

@ -1,12 +1,13 @@
#pragma once
#include "common/types.h"
#include "printf.h"
#include "core/hle/libraries/libc/printf.h"
namespace Core::Libraries::LibC {
int PS4_SYSV_ABI printf(VA_ARGS);
int PS4_SYSV_ABI vsnprintf(char* s, size_t n, const char* format, VaList* arg);
int PS4_SYSV_ABI puts(const char* s);
int PS4_SYSV_ABI fprintf(FILE* file, VA_ARGS);
} // namespace Core::Libraries::LibC

28
src/core/hle/libraries/libc/libc_stdlib.cpp
View File

@ -1,14 +1,15 @@
#include "libc_stdlib.h"
#include <cstdlib>
#include "common/log.h"
#include "common/debug.h"
#include <cstdlib>
#include "core/hle/libraries/libc/libc_stdlib.h"
namespace Core::Libraries::LibC {
constexpr bool log_file_libc = true; // disable it to disable logging
void PS4_SYSV_ABI exit(int code) { std::exit(code); }
void PS4_SYSV_ABI exit(int code) {
std::exit(code);
}
int PS4_SYSV_ABI atexit(void (*func)()) {
int rt = std::atexit(func);
@ -19,19 +20,28 @@ int PS4_SYSV_ABI atexit(void (*func)()) {
return rt;
}
void* PS4_SYSV_ABI malloc(size_t size) { return std::malloc(size); }
void* PS4_SYSV_ABI malloc(size_t size) {
return std::malloc(size);
}
void PS4_SYSV_ABI free(void* ptr) { std::free(ptr); }
void PS4_SYSV_ABI free(void* ptr) {
std::free(ptr);
}
typedef int(PS4_SYSV_ABI* pfunc_QsortCmp)(const void*, const void*);
thread_local static pfunc_QsortCmp compair_ps4;
int qsort_compair(const void* arg1, const void* arg2) { return compair_ps4(arg1, arg2); }
int qsort_compair(const void* arg1, const void* arg2) {
return compair_ps4(arg1, arg2);
}
void PS4_SYSV_ABI qsort(void* ptr, size_t count, size_t size, int(PS4_SYSV_ABI* comp)(const void*, const void*)) {
compair_ps4 = comp;
std::qsort(ptr, count, size, qsort_compair);
}
int PS4_SYSV_ABI rand() { return std::rand(); }
int PS4_SYSV_ABI rand() {
return std::rand();
}
} // namespace Core::Libraries::LibC

5
src/core/hle/libraries/libc/libc_stdlib.h
View File

@ -1,14 +1,15 @@
#pragma once
#include <cstddef>
#include "common/types.h"
#include <cstddef>
namespace Core::Libraries::LibC {
void PS4_SYSV_ABI exit(int code);
int PS4_SYSV_ABI atexit(void (*func)());
void* PS4_SYSV_ABI malloc(size_t size);
void PS4_SYSV_ABI free(void* ptr);
void PS4_SYSV_ABI qsort(void* ptr, size_t count, size_t size, int(PS4_SYSV_ABI* comp)(const void*, const void*));
int PS4_SYSV_ABI rand();
} // namespace Core::Libraries::LibC

39
src/core/hle/libraries/libc/libc_string.cpp
View File

@ -1,25 +1,42 @@
#include "libc_string.h"
#include <cstring>
#include "core/hle/libraries/libc/libc_string.h"
namespace Core::Libraries::LibC {
int PS4_SYSV_ABI memcmp(const void* s1, const void* s2, size_t n) { return std::memcmp(s1, s2, n); }
int PS4_SYSV_ABI memcmp(const void* s1, const void* s2, size_t n) {
return std::memcmp(s1, s2, n);
}
void* PS4_SYSV_ABI memcpy(void* dest, const void* src, size_t n) { return std::memcpy(dest, src, n); }
void* PS4_SYSV_ABI memcpy(void* dest, const void* src, size_t n) {
return std::memcpy(dest, src, n);
}
void* PS4_SYSV_ABI memset(void* s, int c, size_t n) { return std::memset(s, c, n); }
void* PS4_SYSV_ABI memset(void* s, int c, size_t n) {
return std::memset(s, c, n);
}
int PS4_SYSV_ABI strcmp(const char* str1, const char* str2) { return std::strcmp(str1, str2); }
int PS4_SYSV_ABI strcmp(const char* str1, const char* str2) {
return std::strcmp(str1, str2);
}
char* PS4_SYSV_ABI strncpy(char* dest, const char* src, size_t count) { return std::strncpy(dest, src, count); }
char* PS4_SYSV_ABI strncpy(char* dest, const char* src, size_t count) {
return std::strncpy(dest, src, count);
}
void* PS4_SYSV_ABI memmove(void* dest, const void* src, std::size_t count) { return std::memmove(dest, src, count); }
void* PS4_SYSV_ABI memmove(void* dest, const void* src, std::size_t count) {
return std::memmove(dest, src, count);
}
char* PS4_SYSV_ABI strcpy(char* dest, const char* src) { return std::strcpy(dest, src); }
char* PS4_SYSV_ABI strcpy(char* dest, const char* src) {
return std::strcpy(dest, src);
}
char* PS4_SYSV_ABI strcat(char* dest, const char* src) { return std::strcat(dest, src); }
char* PS4_SYSV_ABI strcat(char* dest, const char* src) {
return std::strcat(dest, src);
}
size_t PS4_SYSV_ABI strlen(const char* str) { return std::strlen(str); }
size_t PS4_SYSV_ABI strlen(const char* str) {
return std::strlen(str);
}
} // namespace Core::Libraries::LibC

5
src/core/hle/libraries/libc/libc_string.h
View File

@ -1,10 +1,10 @@
#pragma once
#include <cstddef>
#include "common/types.h"
#include <cstddef>
namespace Core::Libraries::LibC {
int PS4_SYSV_ABI memcmp(const void* s1, const void* s2, size_t n);
void* PS4_SYSV_ABI memcpy(void* dest, const void* src, size_t n);
void* PS4_SYSV_ABI memset(void* s, int c, size_t n);
@ -14,4 +14,5 @@ void* PS4_SYSV_ABI memmove(void* dest, const void* src, std::size_t count);
char* PS4_SYSV_ABI strcpy(char* destination, const char* source);
char* PS4_SYSV_ABI strcat(char* dest, const char* src);
size_t PS4_SYSV_ABI strlen(const char* str);
} // namespace Core::Libraries::LibC

8
src/core/hle/libraries/libkernel/file_system.cpp
View File

@ -1,10 +1,10 @@
#include "file_system.h"
#include <core/PS4/HLE/Libs.h>
#include "common/log.h"
#include "common/debug.h"
#include "core/hle/libraries/libkernel/file_system.h"
#include "core/hle/libraries/libs.h"
namespace Core::Libraries::LibKernel {
constexpr bool log_file_fs = true; // disable it to disable logging
int PS4_SYSV_ABI sceKernelOpen(const char* path, int flags, u16 mode) {
@ -21,7 +21,7 @@ int PS4_SYSV_ABI open(const char* path, int flags, /* SceKernelMode*/ u16 mode)
return result;
}
void fileSystemSymbolsRegister(SymbolsResolver* sym) {
void fileSystemSymbolsRegister(Loader::SymbolsResolver* sym) {
LIB_FUNCTION("1G3lF1Gg1k8", "libkernel", 1, "libkernel", 1, 1, sceKernelOpen);
LIB_FUNCTION("wuCroIGjt2g", "libScePosix", 1, "libkernel", 1, 1, open);
}

10
src/core/hle/libraries/libkernel/file_system.h
View File

@ -1,13 +1,17 @@
#pragma once
#include "common/types.h"
#include "core/PS4/Loader/SymbolsResolver.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace Core::Libraries::LibKernel {
int PS4_SYSV_ABI sceKernelOpen(const char *path, int flags, /* SceKernelMode*/ u16 mode);
// posix file system
int PS4_SYSV_ABI open(const char *path, int flags, /* SceKernelMode*/ u16 mode);
void fileSystemSymbolsRegister(Loader::SymbolsResolver *sym);
void fileSystemSymbolsRegister(SymbolsResolver *sym);
} // namespace Core::Libraries::LibKernel

50
src/core/PS4/HLE/LibKernel.cpp → src/core/hle/libraries/libkernel/libkernel.cpp
View File

@ -1,20 +1,21 @@
#include "LibKernel.h"
#include "common/log.h"
#include "common/debug.h"
#include <windows.h>
#include "common/singleton.h"
#include "../Loader/Elf.h"
#include "Kernel/Objects/physical_memory.h"
#include "Kernel/cpu_management.h"
#include "Kernel/event_queues.h"
#include "Kernel/memory_management.h"
#include "Libs.h"
#include "core/loader/elf.h"
#include "core/hle/kernel/Objects/physical_memory.h"
#include "core/hle/kernel/cpu_management.h"
#include "core/hle/kernel/event_queues.h"
#include "core/hle/kernel/memory_management.h"
#include "core/hle/libraries/libkernel/libkernel.h"
#include "core/hle/libraries/libkernel/file_system.h"
#include "core/hle/libraries/libkernel/time_management.h"
#include "core/hle/libraries/libs.h"
namespace HLE::Libs::LibKernel {
#ifdef _WIN64
#include <windows.h>
#endif
namespace Core::Libraries::LibKernel {
static u64 g_stack_chk_guard = 0xDEADBEEF54321ABC; // dummy return
@ -23,27 +24,32 @@ int32_t PS4_SYSV_ABI sceKernelReleaseDirectMemory(off_t start, size_t len) {
return 0;
}
static PS4_SYSV_ABI void stack_chk_fail() { BREAKPOINT(); }
static PS4_SYSV_ABI void stack_chk_fail() {
BREAKPOINT();
}
int PS4_SYSV_ABI sceKernelMunmap(void* addr, size_t len) { BREAKPOINT(); }
void LibKernel_Register(SymbolsResolver* sym) {
int PS4_SYSV_ABI sceKernelMunmap(void* addr, size_t len) {
BREAKPOINT();
}
void LibKernel_Register(Loader::SymbolsResolver* sym) {
// obj
LIB_OBJ("f7uOxY9mM1U", "libkernel", 1, "libkernel", 1, 1, &HLE::Libs::LibKernel::g_stack_chk_guard);
LIB_OBJ("f7uOxY9mM1U", "libkernel", 1, "libkernel", 1, 1, &g_stack_chk_guard);
// memory
LIB_FUNCTION("rTXw65xmLIA", "libkernel", 1, "libkernel", 1, 1, MemoryManagement::sceKernelAllocateDirectMemory);
LIB_FUNCTION("pO96TwzOm5E", "libkernel", 1, "libkernel", 1, 1, MemoryManagement::sceKernelGetDirectMemorySize);
LIB_FUNCTION("L-Q3LEjIbgA", "libkernel", 1, "libkernel", 1, 1, MemoryManagement::sceKernelMapDirectMemory);
LIB_FUNCTION("rTXw65xmLIA", "libkernel", 1, "libkernel", 1, 1, Kernel::sceKernelAllocateDirectMemory);
LIB_FUNCTION("pO96TwzOm5E", "libkernel", 1, "libkernel", 1, 1, Kernel::sceKernelGetDirectMemorySize);
LIB_FUNCTION("L-Q3LEjIbgA", "libkernel", 1, "libkernel", 1, 1, Kernel::sceKernelMapDirectMemory);
LIB_FUNCTION("MBuItvba6z8", "libkernel", 1, "libkernel", 1, 1, sceKernelReleaseDirectMemory);
LIB_FUNCTION("cQke9UuBQOk", "libkernel", 1, "libkernel", 1, 1, sceKernelMunmap);
// equeue
LIB_FUNCTION("D0OdFMjp46I", "libkernel", 1, "libkernel", 1, 1, EventQueues::sceKernelCreateEqueue);
LIB_FUNCTION("fzyMKs9kim0", "libkernel", 1, "libkernel", 1, 1, EventQueues::sceKernelWaitEqueue);
LIB_FUNCTION("D0OdFMjp46I", "libkernel", 1, "libkernel", 1, 1, Kernel::sceKernelCreateEqueue);
LIB_FUNCTION("fzyMKs9kim0", "libkernel", 1, "libkernel", 1, 1, Kernel::sceKernelWaitEqueue);
// misc
LIB_FUNCTION("WslcK1FQcGI", "libkernel", 1, "libkernel", 1, 1, CPUManagement::sceKernelIsNeoMode);
LIB_FUNCTION("WslcK1FQcGI", "libkernel", 1, "libkernel", 1, 1, Kernel::sceKernelIsNeoMode);
LIB_FUNCTION("Ou3iL1abvng", "libkernel", 1, "libkernel", 1, 1, stack_chk_fail);
Core::Libraries::LibKernel::fileSystemSymbolsRegister(sym);
Core::Libraries::LibKernel::timeSymbolsRegister(sym);
}
}; // namespace HLE::Libs::LibKernel
} // namespace Core::Libraries::LibKernel

16
src/core/hle/libraries/libkernel/libkernel.h Normal file
View File

@ -0,0 +1,16 @@
#pragma once
#include <sys/types.h>
#include "common/types.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace Core::Libraries::LibKernel {
int32_t PS4_SYSV_ABI sceKernelReleaseDirectMemory(off_t start, size_t len);
void LibKernel_Register(Loader::SymbolsResolver* sym);
} // namespace Core::Libraries::LibKernel

23
src/core/hle/libraries/libkernel/time_management.cpp
View File

@ -1,20 +1,27 @@
#include "time_management.h"
#include <core/PS4/HLE/Libs.h>
#include "Lib/Timer.h"
#include "common/timer.h"
#include "core/hle/libraries/libkernel/time_management.h"
#include "core/hle/libraries/libs.h"
#include "emuTimer.h"
namespace Core::Libraries::LibKernel {
u64 PS4_SYSV_ABI sceKernelGetProcessTime() {
return static_cast<u64>(Emulator::emuTimer::getTimeMsec() * 1000.0); // return time in microseconds
}
u64 PS4_SYSV_ABI sceKernelGetProcessTimeCounter() { return Emulator::emuTimer::getTimeCounter(); }
u64 PS4_SYSV_ABI sceKernelGetProcessTimeCounterFrequency() { return Emulator::emuTimer::getTimeFrequency(); }
u64 PS4_SYSV_ABI sceKernelGetProcessTimeCounter() {
return Emulator::emuTimer::getTimeCounter();
}
u64 PS4_SYSV_ABI sceKernelReadTsc() { return Lib::Timer::getQueryPerformanceCounter(); }
u64 PS4_SYSV_ABI sceKernelGetProcessTimeCounterFrequency() {
return Emulator::emuTimer::getTimeFrequency();
}
void timeSymbolsRegister(SymbolsResolver* sym) {
u64 PS4_SYSV_ABI sceKernelReadTsc() {
return Common::Timer::getQueryPerformanceCounter();
}
void timeSymbolsRegister(Loader::SymbolsResolver* sym) {
LIB_FUNCTION("4J2sUJmuHZQ", "libkernel", 1, "libkernel", 1, 1, sceKernelGetProcessTime);
LIB_FUNCTION("fgxnMeTNUtY", "libkernel", 1, "libkernel", 1, 1, sceKernelGetProcessTimeCounter);
LIB_FUNCTION("BNowx2l588E", "libkernel", 1, "libkernel", 1, 1, sceKernelGetProcessTimeCounterFrequency);

11
src/core/hle/libraries/libkernel/time_management.h
View File

@ -1,13 +1,18 @@
#pragma once
#include "common/types.h"
#include "core/PS4/Loader/SymbolsResolver.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace Core::Libraries::LibKernel {
u64 PS4_SYSV_ABI sceKernelGetProcessTime();
u64 PS4_SYSV_ABI sceKernelGetProcessTimeCounter();
u64 PS4_SYSV_ABI sceKernelGetProcessTimeCounterFrequency();
u64 PS4_SYSV_ABI sceKernelReadTsc();
void timeSymbolsRegister(SymbolsResolver* sym);
}
void timeSymbolsRegister(Loader::SymbolsResolver* sym);
} // namespace Core::Libraries::LibKernel

19
src/core/hle/libraries/libpad/pad.cpp
View File

@ -1,18 +1,17 @@
#include "pad.h"
#include <core/PS4/HLE/ErrorCodes.h>
#include <core/PS4/HLE/Libs.h>
#include "common/singleton.h"
#include "Emulator/Host/controller.h"
#include "common/debug.h"
#include "common/log.h"
#include "common/singleton.h"
#include "core/hle/libraries/libpad/pad.h"
#include "core/hle/error_codes.h"
#include "core/hle/libraries/libs.h"
#include "Emulator/Host/controller.h"
namespace Core::Libraries::LibPad {
constexpr bool log_file_pad = true; // disable it to disable logging
int PS4_SYSV_ABI scePadInit() { return SCE_OK; }
int PS4_SYSV_ABI scePadInit() {
return SCE_OK;
}
int PS4_SYSV_ABI scePadOpen(Core::Libraries::LibUserService::SceUserServiceUserId userId, s32 type, s32 index,
const ScePadOpenParam* pParam) {
@ -47,7 +46,7 @@ int PS4_SYSV_ABI scePadReadState(int32_t handle, ScePadData* pData) {
return SCE_OK;
}
void padSymbolsRegister(SymbolsResolver* sym) {
void padSymbolsRegister(Loader::SymbolsResolver* sym) {
LIB_FUNCTION("hv1luiJrqQM", "libScePad", 1, "libScePad", 1, 1, scePadInit);
LIB_FUNCTION("xk0AcarP3V4", "libScePad", 1, "libScePad", 1, 1, scePadOpen);
LIB_FUNCTION("YndgXqQVV7c", "libScePad", 1, "libScePad", 1, 1, scePadReadState);

50
src/core/hle/libraries/libpad/pad.h
View File

@ -1,30 +1,29 @@
#pragma once
#include "common/types.h"
#include "core/PS4/Loader/SymbolsResolver.h"
#include "core/hle/libraries/libuserservice/user_service.h"
#include "common/types.h"
#include "core/hle/libraries/libuserservice/libuserservice.h"
namespace Core::Libraries::LibPad {
typedef enum : u32 {
SCE_PAD_BUTTON_L3 = 0x00000002,
SCE_PAD_BUTTON_R3 = 0x00000004,
SCE_PAD_BUTTON_OPTIONS = 0x00000008,
SCE_PAD_BUTTON_UP = 0x00000010,
SCE_PAD_BUTTON_RIGHT = 0x00000020,
SCE_PAD_BUTTON_DOWN = 0x00000040,
SCE_PAD_BUTTON_LEFT = 0x00000080,
SCE_PAD_BUTTON_L2 = 0x00000100,
SCE_PAD_BUTTON_R2 = 0x00000200,
SCE_PAD_BUTTON_L1 = 0x00000400,
SCE_PAD_BUTTON_R1 = 0x00000800,
SCE_PAD_BUTTON_TRIANGLE = 0x00001000,
SCE_PAD_BUTTON_CIRCLE = 0x00002000,
SCE_PAD_BUTTON_CROSS = 0x00004000,
SCE_PAD_BUTTON_SQUARE = 0x00008000,
SCE_PAD_BUTTON_TOUCH_PAD = 0x00100000,
SCE_PAD_BUTTON_INTERCEPTED = 0x80000000,
} ScePadButton;
enum ScePadButton : u32 {
L3 = 0x00000002,
R3 = 0x00000004,
OPTIONS = 0x00000008,
UP = 0x00000010,
RIGHT = 0x00000020,
DOWN = 0x00000040,
LEFT = 0x00000080,
L2 = 0x00000100,
R2 = 0x00000200,
L1 = 0x00000400,
R1 = 0x00000800,
TRIANGLE = 0x00001000,
CIRCLE = 0x00002000,
CROSS = 0x00004000,
SQUARE = 0x00008000,
TOUCH_PAD = 0x00100000,
INTERCEPTED = 0x80000000,
};
struct ScePadOpenParam {
u08 reserve[8];
@ -88,11 +87,12 @@ struct ScePadData {
uint8_t deviceUniqueDataLen;
uint8_t deviceUniqueData[12];
};
// hle functions
int PS4_SYSV_ABI scePadInit();
int PS4_SYSV_ABI scePadOpen(Core::Libraries::LibUserService::SceUserServiceUserId userId, s32 type, s32 index,
int PS4_SYSV_ABI scePadOpen(LibUserService::SceUserServiceUserId userId, s32 type, s32 index,
const ScePadOpenParam* pParam);
int PS4_SYSV_ABI scePadReadState(int32_t handle, ScePadData* pData);
void padSymbolsRegister(SymbolsResolver* sym);
void padSymbolsRegister(Loader::SymbolsResolver* sym);
}; // namespace Core::Libraries::LibPad

22
src/core/hle/libraries/libs.cpp Normal file
View File

@ -0,0 +1,22 @@
#include "core/hle/libraries/libs.h"
#include "core/PS4/HLE/Graphics/video_out.h"
#include "core/hle/libraries/libkernel/libkernel.h"
#include "core/hle/libraries/libscegnmdriver/libscegnmdriver.h"
#include "core/hle/libraries/libuserservice/libuserservice.h"
#include "core/hle/libraries/libpad/pad.h"
#include "core/hle/libraries/libsystemservice/system_service.h"
#include "core/hle/libraries/libc/libc.h"
namespace Core::Libraries {
void InitHLELibs(Loader::SymbolsResolver* sym) {
LibKernel::LibKernel_Register(sym);
HLE::Libs::Graphics::VideoOut::videoOutRegisterLib(sym);
LibSceGnmDriver::LibSceGnmDriver_Register(sym);
LibUserService::userServiceSymbolsRegister(sym);
LibPad::padSymbolsRegister(sym);
LibSystemService::systemServiceSymbolsRegister(sym);
LibC::libcSymbolsRegister(sym);
}
} // namespace Core::Libraries

17
src/core/PS4/HLE/Libs.h → src/core/hle/libraries/libs.h
View File

@ -1,10 +1,11 @@
#pragma once
#include "../Loader/SymbolsResolver.h"
#include <core/PS4/Loader/Elf.h>
#include "core/loader/elf.h"
#include "core/loader/symbols_resolver.h"
#define LIB_FUNCTION(nid, lib, libversion, mod, moduleVersionMajor, moduleVersionMinor, function) \
{\
SymbolRes sr{}; \
Loader::SymbolRes sr{}; \
sr.name = nid; \
sr.library = lib; \
sr.library_version = libversion;\
@ -18,7 +19,7 @@
#define LIB_OBJ(nid, lib, libversion, mod, moduleVersionMajor, moduleVersionMinor, function) \
{ \
SymbolRes sr{}; \
Loader::SymbolRes sr{}; \
sr.name = nid; \
sr.library = lib; \
sr.library_version = libversion; \
@ -38,6 +39,8 @@
#define PRINT_DUMMY_FUNCTION_NAME() \
{ LOG_WARN_IF(true, "dummy {}()\n", __func__); }
namespace HLE::Libs {
void Init_HLE_Libs(SymbolsResolver* sym);
}
namespace Core::Libraries {
void InitHLELibs(Loader::SymbolsResolver* sym);
} // namespace Core::Libraries

24
src/core/hle/libraries/libscegnmdriver/libscegnmdriver.cpp Normal file
View File

@ -0,0 +1,24 @@
#include "common/log.h"
#include "core/PS4/GPU/gpu_memory.h"
#include "core/hle/libraries/libscegnmdriver/libscegnmdriver.h"
#include "core/hle/libraries/libs.h"
#include "emulator.h"
namespace Core::Libraries::LibSceGnmDriver {
int32_t sceGnmSubmitDone() {
PRINT_DUMMY_FUNCTION_NAME();
return 0;
}
void sceGnmFlushGarlic() {
PRINT_FUNCTION_NAME();
GPU::flushGarlic(Emu::getGraphicCtx());
}
void LibSceGnmDriver_Register(Loader::SymbolsResolver* sym) {
LIB_FUNCTION("yvZ73uQUqrk", "libSceGnmDriver", 1, "libSceGnmDriver", 1, 1, sceGnmSubmitDone);
LIB_FUNCTION("iBt3Oe00Kvc", "libSceGnmDriver", 1, "libSceGnmDriver", 1, 1, sceGnmFlushGarlic);
}
};

16
src/core/hle/libraries/libscegnmdriver/libscegnmdriver.h Normal file
View File

@ -0,0 +1,16 @@
#pragma once
#include "common/types.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace Core::Libraries::LibSceGnmDriver {
int32_t sceGnmSubmitDone();
void sceGnmFlushGarlic();
void LibSceGnmDriver_Register(Loader::SymbolsResolver* sym);
}; // namespace Core::Libraries::LibSceGnmDriver

14
src/core/hle/libraries/libsystemservice/system_service.cpp
View File

@ -1,7 +1,7 @@
#include <core/PS4/HLE/ErrorCodes.h>
#include <core/PS4/HLE/Libs.h>
#include "common/log.h"
#include "system_service.h"
#include "core/hle/error_codes.h"
#include "core/hle/libraries/libs.h"
#include "core/hle/libraries/libsystemservice/system_service.h"
namespace Core::Libraries::LibSystemService {
@ -10,7 +10,9 @@ s32 PS4_SYSV_ABI sceSystemServiceHideSplashScreen() {
return SCE_OK;
}
void systemServiceSymbolsRegister(SymbolsResolver* sym) {
LIB_FUNCTION("Vo5V8KAwCmk", "libSceSystemService", 1, "libSceSystemService", 1, 1, sceSystemServiceHideSplashScreen);
void systemServiceSymbolsRegister(Loader::SymbolsResolver* sym) {
LIB_FUNCTION("Vo5V8KAwCmk", "libSceSystemService", 1, "libSceSystemService", 1, 1,
sceSystemServiceHideSplashScreen);
}
}; // namespace Emulator::HLE::Libraries::LibUserService
}; // namespace Core::Libraries::LibSystemService

12
src/core/hle/libraries/libsystemservice/system_service.h
View File

@ -1,11 +1,15 @@
#pragma once
#include "core/PS4/Loader/SymbolsResolver.h"
#include "common/types.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace Core::Libraries::LibSystemService {
//HLE functions
s32 PS4_SYSV_ABI sceSystemServiceHideSplashScreen();
void systemServiceSymbolsRegister(SymbolsResolver* sym);
void systemServiceSymbolsRegister(Loader::SymbolsResolver* sym);
}; // namespace Emulator::HLE::Libraries::LibUserService
}; // namespace Core::Libraries::LibSystemService

11
src/core/hle/libraries/libuserservice/user_service.cpp → src/core/hle/libraries/libuserservice/libuserservice.cpp
View File

@ -1,9 +1,7 @@
#include "user_service.h"
#include <core/PS4/HLE/ErrorCodes.h>
#include <core/PS4/HLE/Libs.h>
#include "common/log.h"
#include "core/hle/libraries/libuserservice/libuserservice.h"
#include "core/hle/error_codes.h"
#include "core/hle/libraries/libs.h"
namespace Core::Libraries::LibUserService {
@ -21,7 +19,8 @@ s32 PS4_SYSV_ABI sceUserServiceGetLoginUserIdList(SceUserServiceLoginUserIdList*
return SCE_OK;
}
void userServiceSymbolsRegister(SymbolsResolver* sym) {
void userServiceSymbolsRegister(Loader::SymbolsResolver* sym) {
LIB_FUNCTION("j3YMu1MVNNo", "libSceUserService", 1, "libSceUserService", 1, 1, sceUserServiceInitialize);
LIB_FUNCTION("fPhymKNvK-A", "libSceUserService", 1, "libSceUserService", 1, 1, sceUserServiceGetLoginUserIdList);
}

12
src/core/hle/libraries/libuserservice/user_service.h → src/core/hle/libraries/libuserservice/libuserservice.h
View File

@ -1,5 +1,10 @@
#pragma once
#include "core/PS4/Loader/SymbolsResolver.h"
#include "common/types.h"
namespace Core::Loader {
class SymbolsResolver;
}
namespace Core::Libraries::LibUserService {
@ -16,5 +21,6 @@ struct SceUserServiceLoginUserIdList {
s32 PS4_SYSV_ABI sceUserServiceInitialize(const SceUserServiceInitializeParams* initParams);
s32 PS4_SYSV_ABI sceUserServiceGetLoginUserIdList(SceUserServiceLoginUserIdList* userIdList);
void userServiceSymbolsRegister(SymbolsResolver* sym);
}; // namespace Emulator::HLE::Libraries::LibUserService
void userServiceSymbolsRegister(Loader::SymbolsResolver* sym);
}; // namespace Core::Libraries::LibUserService

0
src/core/PS4/HLE/UserManagement/UsrMngCodes.h → src/core/hle/libraries/libuserservice/usr_mng_codes.h
View File

40
src/core/PS4/Linker.cpp → src/core/linker.cpp
View File

@ -1,13 +1,14 @@
#include "Linker.h"
#include "../virtual_memory.h"
#include "common/log.h"
#include <fmt/core.h>
#include <Zydis/Zydis.h>
#include "common/log.h"
#include "common/string_util.h"
#include "Util/aerolib.h"
#include "Loader/SymbolsResolver.h"
#include "HLE/Kernel/ThreadManagement.h"
#include "Stubs.h"
#include "core/aerolib/aerolib.h"
#include "core/aerolib/stubs.h"
#include "core/hle/kernel/thread_management.h"
#include "core/linker.h"
#include "core/virtual_memory.h"
namespace Core {
constexpr bool debug_loader = true;
@ -452,7 +453,7 @@ void Linker::LoadSymbols(Module* m)
bool is_sym_export = sym->st_value != 0;
std::string nidName = "";
auto aeronid = aerolib::find_by_nid(ids.at(0).c_str());
auto aeronid = AeroLib::FindByNid(ids.at(0).c_str());
if (aeronid != nullptr)
{
@ -463,7 +464,7 @@ void Linker::LoadSymbols(Module* m)
nidName = "UNK";
}
SymbolRes sym_r{};
Loader::SymbolRes sym_r{};
sym_r.name = ids.at(0);
sym_r.nidName = nidName;
sym_r.library = library->name;
@ -519,7 +520,7 @@ static void relocate(u32 idx, elf_relocation* rel, Module* m, bool isJmpRel) {
auto sym_type = sym.GetType();
auto sym_visibility = sym.GetVisibility();
u64 symbol_vitrual_addr = 0;
SymbolRecord symrec{};
Loader::SymbolRecord symrec{};
switch (sym_type) {
case STT_FUN: rel_sym_type = 2; break;
case STT_OBJECT: rel_sym_type = 1; break;
@ -575,7 +576,7 @@ void Linker::Relocate(Module* m)
}
}
void Linker::Resolve(const std::string& name, int Symtype, Module* m, SymbolRecord* return_info) {
void Linker::Resolve(const std::string& name, int Symtype, Module* m, Loader::SymbolRecord* return_info) {
const auto ids = Common::SplitString(name, '#');
if (ids.size() == 3) // symbols are 3 parts name , library , module
{
@ -583,7 +584,7 @@ void Linker::Resolve(const std::string& name, int Symtype, Module* m, SymbolReco
const auto* module = FindModule(*m, ids.at(2));
if (library != nullptr && module != nullptr) {
SymbolRes sr{};
Loader::SymbolRes sr{};
sr.name = ids.at(0);
sr.library = library->name;
sr.library_version = library->version;
@ -592,18 +593,18 @@ void Linker::Resolve(const std::string& name, int Symtype, Module* m, SymbolReco
sr.module_version_minor = module->version_minor;
sr.type = Symtype;
const SymbolRecord* rec = nullptr;
const Loader::SymbolRecord* rec = nullptr;
rec = m_hle_symbols.FindSymbol(sr);
if (rec != nullptr) {
*return_info = *rec;
} else {
auto aeronid = aerolib::find_by_nid(sr.name.c_str());
auto aeronid = AeroLib::FindByNid(sr.name.c_str());
if (aeronid) {
return_info->name = aeronid->name;
return_info->virtual_address = GetStub(aeronid->nid);
return_info->virtual_address = AeroLib::GetStub(aeronid->nid);
} else {
return_info->virtual_address = GetStub(sr.name.c_str());
return_info->virtual_address = AeroLib::GetStub(sr.name.c_str());
return_info->name = "Unknown !!!";
}
LOG_ERROR_IF(debug_loader, "Linker: Stub resolved {} as {} (lib: {}, mod: {}) \n", sr.name, return_info->name, library->name, module->name);
@ -652,9 +653,8 @@ static void run_main_entry(u64 addr, EntryParams* params, exit_func_t exit_func)
);
}
void Linker::Execute()
{
HLE::Libs::LibKernel::ThreadManagement::Pthread_Init_Self_MainThread();
void Linker::Execute() {
Core::Kernel::Pthread_Init_Self_MainThread();
EntryParams p{};
p.argc = 1;
p.argv[0] = "eboot.bin"; //hmm should be ok?
@ -662,3 +662,5 @@ void Linker::Execute()
const auto& module = m_modules.at(0);
run_main_entry(module.elf.GetElfEntry() + module.base_virtual_addr, &p, ProgramExitFunc);
}
} // namespace Core

44
src/core/PS4/Linker.h → src/core/linker.h
View File

@ -2,8 +2,10 @@
#include <vector>
#include <mutex>
#include "Loader/Elf.h"
#include "Loader/SymbolsResolver.h"
#include "core/loader/elf.h"
#include "core/loader/symbols_resolver.h"
namespace Core {
struct DynamicModuleInfo;
class Linker;
@ -14,14 +16,11 @@ struct EntryParams {
const char* argv[3];
};
struct ModuleInfo
{
struct ModuleInfo {
std::string name;
union
{
union {
u64 value;
struct
{
struct {
u32 name_offset;
u08 version_minor;
u08 version_major;
@ -31,14 +30,11 @@ struct ModuleInfo
std::string enc_id;
};
struct LibraryInfo
{
struct LibraryInfo {
std::string name;
union
{
union {
u64 value;
struct
{
struct {
u32 name_offset;
u16 version;
u16 id;
@ -47,8 +43,7 @@ struct LibraryInfo
std::string enc_id;
};
struct DynamicModuleInfo
{
struct DynamicModuleInfo {
void* hash_table = nullptr;
u64 hash_table_size = 0;
@ -91,9 +86,8 @@ struct DynamicModuleInfo
};
// This struct keeps neccesary info about loaded modules. Main executeable is included too as well
struct Module
{
Elf elf;
struct Module {
Loader::Elf elf;
u64 aligned_base_size = 0;
u64 base_virtual_addr = 0; // Base virtual address
@ -103,8 +97,8 @@ struct Module
std::vector<u08> m_dynamic_data;
DynamicModuleInfo dynamic_info{};
SymbolsResolver export_sym;
SymbolsResolver import_sym;
Loader::SymbolsResolver export_sym;
Loader::SymbolsResolver import_sym;
};
class Linker {
@ -117,9 +111,9 @@ public:
void LoadModuleToMemory(Module* m);
void LoadDynamicInfo(Module* m);
void LoadSymbols(Module* m);
SymbolsResolver& getHLESymbols() { return m_hle_symbols; }
Loader::SymbolsResolver& getHLESymbols() { return m_hle_symbols; }
void Relocate(Module* m);
void Resolve(const std::string& name, int Symtype, Module* m, SymbolRecord* return_info);
void Resolve(const std::string& name, int Symtype, Module* m, Loader::SymbolRecord* return_info);
void Execute();
private:
@ -127,6 +121,8 @@ private:
const LibraryInfo* FindLibrary(const Module& program, const std::string& id);
std::vector<Module> m_modules;
SymbolsResolver m_hle_symbols{};
Loader::SymbolsResolver m_hle_symbols{};
std::mutex m_mutex;
};
} // namespace Core

9
src/core/PS4/Loader/Elf.cpp → src/core/loader/elf.cpp
View File

@ -1,8 +1,9 @@
#include "Elf.h"
#include <fmt/core.h>
#include "common/log.h"
#include "common/debug.h"
#include <fmt/core.h>
#include "core/loader/elf.h"
namespace Core::Loader {
constexpr bool log_file_loader = true; // disable it to disable logging
@ -432,3 +433,5 @@ void Elf::LoadSegment(u64 virtual_addr, u64 file_offset, u64 size) {
}
BREAKPOINT(); // Hmm we didn't return something...
}
} // namespace Core::Loader

4
src/core/PS4/Loader/Elf.h → src/core/loader/elf.h
View File

@ -450,6 +450,8 @@ constexpr u32 R_X86_64_64 = 1; // Direct 64 bit
constexpr u32 R_X86_64_JUMP_SLOT = 7; // Create PLT entry
constexpr u32 R_X86_64_RELATIVE = 8; // Adjust by program base
namespace Core::Loader {
class Elf {
public:
Elf() = default;
@ -502,3 +504,5 @@ class Elf {
std::vector<elf_section_header> m_elf_shdr;
elf_program_id_header m_self_id_header{};
};
} // namespace Core::Loader

11
src/core/PS4/Loader/SymbolsResolver.cpp → src/core/loader/symbols_resolver.cpp
View File

@ -1,9 +1,10 @@
#include "common/types.h"
#include "SymbolsResolver.h"
#include "common/log.h"
#include "common/types.h"
#include "core/loader/symbols_resolver.h"
void SymbolsResolver::AddSymbol(const SymbolRes& s, u64 virtual_addr)
{
namespace Core::Loader {
void SymbolsResolver::AddSymbol(const SymbolRes& s, u64 virtual_addr) {
SymbolRecord r{};
r.name = GenerateName(s);
r.virtual_address = virtual_addr;
@ -27,3 +28,5 @@ const SymbolRecord* SymbolsResolver::FindSymbol(const SymbolRes& s) const {
LOG_INFO("Unresolved! {}\n", name);
return nullptr;
}
} // namespace Core::Loader

13
src/core/PS4/Loader/SymbolsResolver.h → src/core/loader/symbols_resolver.h
View File

@ -5,14 +5,14 @@
#include <unordered_map>
#include "common/types.h"
struct SymbolRecord
{
namespace Core::Loader {
struct SymbolRecord {
std::string name;
u64 virtual_address;
};
struct SymbolRes
{
struct SymbolRes {
std::string name;
std::string nidName;
std::string library;
@ -23,8 +23,7 @@ struct SymbolRes
u32 type;
};
class SymbolsResolver
{
class SymbolsResolver {
public:
SymbolsResolver() = default;
virtual ~SymbolsResolver() = default;
@ -37,3 +36,5 @@ public:
private:
std::vector<SymbolRecord> m_symbols;
};
} // namespace Core::Loader

4
src/core/virtual_memory.cpp
View File

@ -1,7 +1,5 @@
#include "common/debug.h"
#include "common/log.h"
#include "virtual_memory.h"
#include "core/PS4/Loader/Elf.h"
#include "core/virtual_memory.h"
#ifdef _WIN64
#include <windows.h>

21
src/emuTimer.cpp
View File

@ -1,14 +1,23 @@
#include "Lib/Timer.h"
#include "common/timer.h"
namespace Emulator::emuTimer {
static Lib::Timer timer;
void start() { timer.Start(); }
static Common::Timer timer;
double getTimeMsec() { return timer.GetTimeMsec(); }
void start() {
timer.Start();
}
u64 getTimeCounter() { return timer.GetTicks(); }
double getTimeMsec() {
return timer.GetTimeMsec();
}
u64 getTimeFrequency() { return timer.GetFrequency(); }
u64 getTimeCounter() {
return timer.GetTicks();
}
u64 getTimeFrequency() {
return timer.GetFrequency();
}
} // namespace Emulator::emuTimer

34
src/emulator.cpp
View File

@ -1,15 +1,13 @@
#include "emulator.h"
#include <core/PS4/HLE/Graphics/graphics_render.h>
#include <Emulator/Host/controller.h>
#include <Lib/Timer.h>
#include <fmt/core.h>
#include <vulkan_util.h>
#include "core/PS4/HLE/Graphics/video_out.h"
#include "core/hle/libraries/libpad/pad.h"
#include "common/timer.h"
#include "common/singleton.h"
#include "common/version.h"
#include "emulator.h"
#include "core/PS4/HLE/Graphics/graphics_render.h"
#include "Emulator/Host/controller.h"
#include "core/PS4/HLE/Graphics/video_out.h"
#include "core/hle/libraries/libpad/pad.h"
namespace Emu {
@ -92,7 +90,7 @@ static void calculateFps(double game_time_s) {
}
}
void emuRun() {
Lib::Timer timer;
Common::Timer timer;
timer.Start();
auto window_ctx = Common::Singleton<Emu::WindowCtx>::Instance();
{
@ -306,15 +304,15 @@ void keyboardEvent(SDL_Event* event) {
if (event->type == SDL_EVENT_KEY_DOWN || event->type == SDL_EVENT_KEY_UP) {
u32 button = 0;
switch (event->key.keysym.sym) {
case SDLK_UP: button = ScePadButton::SCE_PAD_BUTTON_UP; break;
case SDLK_DOWN: button = ScePadButton::SCE_PAD_BUTTON_DOWN; break;
case SDLK_LEFT: button = ScePadButton::SCE_PAD_BUTTON_LEFT; break;
case SDLK_RIGHT: button = ScePadButton::SCE_PAD_BUTTON_RIGHT; break;
case SDLK_KP_8: button = ScePadButton ::SCE_PAD_BUTTON_TRIANGLE; break;
case SDLK_KP_6: button = ScePadButton ::SCE_PAD_BUTTON_CIRCLE; break;
case SDLK_KP_2: button = ScePadButton ::SCE_PAD_BUTTON_CROSS; break;
case SDLK_KP_4: button = ScePadButton ::SCE_PAD_BUTTON_SQUARE; break;
case SDLK_RETURN: button = ScePadButton ::SCE_PAD_BUTTON_OPTIONS; break;
case SDLK_UP: button = ScePadButton::UP; break;
case SDLK_DOWN: button = ScePadButton::DOWN; break;
case SDLK_LEFT: button = ScePadButton::LEFT; break;
case SDLK_RIGHT: button = ScePadButton::RIGHT; break;
case SDLK_KP_8: button = ScePadButton ::TRIANGLE; break;
case SDLK_KP_6: button = ScePadButton ::CIRCLE; break;
case SDLK_KP_2: button = ScePadButton ::CROSS; break;
case SDLK_KP_4: button = ScePadButton ::SQUARE; break;
case SDLK_RETURN: button = ScePadButton ::OPTIONS; break;
default: break;
}
if (button != 0) {

22
src/main.cpp
View File

@ -1,18 +1,18 @@
#include <SDL3/SDL.h>
#include <cstdio>
#include <cinttypes>
#include <thread>
#include <fmt/core.h>
#include <SDL3/SDL.h>
#include <Zydis/Zydis.h>
#include "common/discord.h"
#include "common/types.h"
#include "common/log.h"
#include "common/singleton.h"
#include <core/PS4/HLE/Graphics/video_out.h>
#include <Util/config.h>
#include <Zydis/Zydis.h>
#include <emulator.h>
#include <cinttypes>
#include <thread>
#include "core/PS4/HLE/Libs.h"
#include "core/PS4/Linker.h"
#include "core/PS4/HLE/Graphics/video_out.h"
#include "Util/config.h"
#include "emulator.h"
#include "core/hle/libraries/libs.h"
#include "core/linker.h"
#include "emuTimer.h"
int main(int argc, char* argv[]) {
@ -31,8 +31,8 @@ int main(int argc, char* argv[]) {
// Argument 1 is the path of self file to boot
const char* const path = argv[1];
auto linker = Common::Singleton<Linker>::Instance();
HLE::Libs::Init_HLE_Libs(&linker->getHLESymbols());
auto linker = Common::Singleton<Core::Linker>::Instance();
Core::Libraries::InitHLELibs(&linker->getHLESymbols());
linker->LoadModule(path);
std::jthread mainthread(
[linker](std::stop_token stop_token, void*) {