Merge pull request #77 from georgemoralis/TLS_works

TLS branch WIP

CMakeLists.txt

@@ -147,7 +147,7 @@ add_executable(shadps4
     src/emuTimer.h
     src/core/hle/libraries/libkernel/time_management.cpp
     src/core/hle/libraries/libkernel/time_management.h
-)
+ "src/common/io_file.cpp" "src/common/io_file.h")
 
 create_target_directory_groups(shadps4)
 

src/common/io_file.cpp

@@ -0,0 +1,138 @@
+#include "io_file.h"
+
+//#include "helpers.hpp"
+
+#ifdef _MSC_VER
+// 64 bit offsets for MSVC
+#define fseeko _fseeki64
+#define ftello _ftelli64
+#define fileno _fileno
+
+#pragma warning(disable : 4996)
+#endif
+
+#ifndef _CRT_SECURE_NO_WARNINGS
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#ifdef WIN32
+#include <io.h> // For _chsize_s
+#else
+#include <unistd.h> // For ftruncate
+#endif
+
+IOFile::IOFile(const std::filesystem::path& path, const char* permissions) : handle(nullptr) {
+    open(path, permissions);
+}
+
+bool IOFile::open(const std::filesystem::path& path, const char* permissions) {
+    const auto str =
+        path.string(); // For some reason converting paths directly with c_str() doesn't work
+    return open(str.c_str(), permissions);
+}
+
+bool IOFile::open(const char* filename, const char* permissions) {
+    // If this IOFile is already bound to an open file descriptor, release the file descriptor
+    // To avoid leaking it and/or erroneously locking the file
+    if (isOpen()) {
+        close();
+    }
+
+    handle = std::fopen(filename, permissions);
+    return isOpen();
+}
+
+void IOFile::close() {
+    if (isOpen()) {
+        fclose(handle);
+        handle = nullptr;
+    }
+}
+
+std::pair<bool, std::size_t> IOFile::read(void* data, std::size_t length, std::size_t dataSize) {
+    if (!isOpen()) {
+        return {false, std::numeric_limits<std::size_t>::max()};
+    }
+
+    if (length == 0)
+        return {true, 0};
+    return {true, std::fread(data, dataSize, length, handle)};
+}
+
+std::pair<bool, std::size_t> IOFile::write(const void* data, std::size_t length,
+                                           std::size_t dataSize) {
+    if (!isOpen()) {
+        return {false, std::numeric_limits<std::size_t>::max()};
+    }
+
+    if (length == 0) {
+        return {true, 0};
+    } else {
+        return {true, std::fwrite(data, dataSize, length, handle)};
+    }
+}
+
+std::pair<bool, std::size_t> IOFile::readBytes(void* data, std::size_t count) {
+    return read(data, count, sizeof(std::uint8_t));
+}
+std::pair<bool, std::size_t> IOFile::writeBytes(const void* data, std::size_t count) {
+    return write(data, count, sizeof(std::uint8_t));
+}
+
+std::optional<std::uint64_t> IOFile::size() {
+    if (!isOpen())
+        return {};
+
+    std::uint64_t pos = ftello(handle);
+    if (fseeko(handle, 0, SEEK_END) != 0) {
+        return {};
+    }
+
+    std::uint64_t size = ftello(handle);
+    if ((size != pos) && (fseeko(handle, pos, SEEK_SET) != 0)) {
+        return {};
+    }
+
+    return size;
+}
+
+bool IOFile::seek(std::int64_t offset, int origin) {
+    if (!isOpen() || fseeko(handle, offset, origin) != 0)
+        return false;
+
+    return true;
+}
+
+bool IOFile::flush() {
+    if (!isOpen() || fflush(handle))
+        return false;
+
+    return true;
+}
+
+bool IOFile::rewind() {
+    return seek(0, SEEK_SET);
+}
+FILE* IOFile::getHandle() {
+    return handle;
+}
+
+void IOFile::setAppDataDir(const std::filesystem::path& dir) {
+    //if (dir == "")
+    //    Helpers::panic("Failed to set app data directory");
+    appData = dir;
+}
+
+bool IOFile::setSize(std::uint64_t size) {
+    if (!isOpen())
+        return false;
+    bool success;
+
+#ifdef WIN32
+    success = _chsize_s(_fileno(handle), size) == 0;
+#else
+    success = ftruncate(fileno(handle), size) == 0;
+#endif
+    fflush(handle);
+    return success;
+}

src/common/io_file.h

@@ -0,0 +1,41 @@
+#pragma once
+#include <cstdint>
+#include <filesystem>
+#include <optional>
+
+class IOFile {
+    FILE* handle = nullptr;
+    static inline std::filesystem::path appData =""; // Directory for holding app data. AppData on Windows
+
+public:
+    IOFile() : handle(nullptr) {}
+    IOFile(FILE* handle) : handle(handle) {}
+    IOFile(const std::filesystem::path& path, const char* permissions = "rb");
+
+    bool isOpen() {
+        return handle != nullptr;
+    }
+    bool open(const std::filesystem::path& path, const char* permissions = "rb");
+    bool open(const char* filename, const char* permissions = "rb");
+    void close();
+
+    std::pair<bool, std::size_t> read(void* data, std::size_t length, std::size_t dataSize);
+    std::pair<bool, std::size_t> readBytes(void* data, std::size_t count);
+
+    std::pair<bool, std::size_t> write(const void* data, std::size_t length, std::size_t dataSize);
+    std::pair<bool, std::size_t> writeBytes(const void* data, std::size_t count);
+
+    std::optional<std::uint64_t> size();
+
+    bool seek(std::int64_t offset, int origin = SEEK_SET);
+    bool rewind();
+    bool flush();
+    FILE* getHandle();
+    static void setAppDataDir(const std::filesystem::path& dir);
+    static std::filesystem::path getAppData() {
+        return appData;
+    }
+
+    // Sets the size of the file to "size" and returns whether it succeeded or not
+    bool setSize(std::uint64_t size);
+};

src/common/log.cpp

@@ -19,8 +19,38 @@ void Flush() {
     spdlog::details::registry::instance().flush_all();
 }
 
+thread_local uint8_t TLS[1024];
+
+uint64_t tls_access(int64_t tls_offset) {
+    if (tls_offset == 0) {
+        return (uint64_t)TLS;
+    }
+}
+
 #ifdef _WIN64
 static LONG WINAPI ExceptionHandler(PEXCEPTION_POINTERS pExp) noexcept {
+    auto orig_rip = pExp->ContextRecord->Rip;
+    while (*(uint8_t *)pExp->ContextRecord->Rip == 0x66) pExp->ContextRecord->Rip++;
+
+    if (*(uint8_t *)pExp->ContextRecord->Rip == 0xcd) {
+        int reg = *(uint8_t *)(pExp->ContextRecord->Rip + 1) - 0x80;
+        int sizes = *(uint8_t *)(pExp->ContextRecord->Rip + 2);
+        int pattern_size = sizes & 0xF;
+        int imm_size = sizes >> 4;
+
+        int64_t tls_offset;
+        if (imm_size == 4)
+            tls_offset = *(int32_t *)(pExp->ContextRecord->Rip + pattern_size);
+        else
+            tls_offset = *(int64_t *)(pExp->ContextRecord->Rip + pattern_size);
+
+        (&pExp->ContextRecord->Rax)[reg] = tls_access(tls_offset); /* TLS_ACCESS */
+        pExp->ContextRecord->Rip += pattern_size + imm_size;
+
+        return EXCEPTION_CONTINUE_EXECUTION;
+    }
+
+    pExp->ContextRecord->Rip = orig_rip;
     const u32 ec = pExp->ExceptionRecord->ExceptionCode;
     switch (ec) {
         case EXCEPTION_ACCESS_VIOLATION: {

src/core/PS4/HLE/Graphics/video_out.cpp

@@ -330,5 +330,14 @@ void videoOutRegisterLib(Core::Loader::SymbolsResolver* sym) {
     LIB_FUNCTION("zgXifHT9ErY", "libSceVideoOut", 1, "libSceVideoOut", 0, 0, sceVideoOutIsFlipPending);
     LIB_FUNCTION("N5KDtkIjjJ4", "libSceVideoOut", 1, "libSceVideoOut", 0, 0, sceVideoOutUnregisterBuffers);
     LIB_FUNCTION("uquVH4-Du78", "libSceVideoOut", 1, "libSceVideoOut", 0, 0, sceVideoOutClose);
+
+    // openOrbis appears to have libSceVideoOut_v1 module libSceVideoOut_v1.1
+    LIB_FUNCTION("Up36PTk687E", "libSceVideoOut", 1, "libSceVideoOut", 1, 1, sceVideoOutOpen);
+    LIB_FUNCTION("CBiu4mCE1DA", "libSceVideoOut", 1, "libSceVideoOut", 1, 1, sceVideoOutSetFlipRate);
+    LIB_FUNCTION("HXzjK9yI30k", "libSceVideoOut", 1, "libSceVideoOut", 1, 1, sceVideoOutAddFlipEvent);
+    LIB_FUNCTION("i6-sR91Wt-4", "libSceVideoOut", 1, "libSceVideoOut", 1, 1, sceVideoOutSetBufferAttribute);
+    LIB_FUNCTION("w3BY+tAEiQY", "libSceVideoOut", 1, "libSceVideoOut", 1, 1, sceVideoOutRegisterBuffers);
+    LIB_FUNCTION("U46NwOiJpys", "libSceVideoOut", 1, "libSceVideoOut", 1, 1, sceVideoOutSubmitFlip);
+    LIB_FUNCTION("SbU3dwp80lQ", "libSceVideoOut", 1, "libSceVideoOut", 1, 1, sceVideoOutGetFlipStatus);
 }
 }  // namespace HLE::Libs::Graphics::VideoOut

src/core/file_sys/fs.h

@@ -4,6 +4,7 @@
 #include <vector>
 
 #include "common/fs_file.h"
+#include <common/io_file.h>
 
 namespace Core::FileSys {
 
@@ -32,7 +33,7 @@ struct File {
     std::atomic_bool isDirectory;
     std::string m_host_name;
     std::string m_guest_name;
-    Common::FS::File f;
+    IOFile f;
     //std::vector<Common::FS::DirEntry> dirents;
     u32 dirents_index;
     std::mutex m_mutex;

src/core/hle/libraries/libkernel/file_system.cpp

@@ -2,6 +2,9 @@
 #include "common/debug.h"
 #include "core/hle/libraries/libkernel/file_system.h"
 #include "core/hle/libraries/libs.h"
+#include <core/file_sys/fs.h>
+#include <common/singleton.h>
+#include <core/hle/error_codes.h>
 
 namespace Core::Libraries::LibKernel {
 
@@ -9,10 +12,25 @@ constexpr bool log_file_fs = true;  // disable it to disable logging
 
 int PS4_SYSV_ABI sceKernelOpen(const char* path, int flags, u16 mode) {
     LOG_INFO_IF(log_file_fs, "sceKernelOpen path = {} flags = {:#x} mode = {:#x}\n", path, flags, mode);
-    return 0;
+    auto* h = Common::Singleton<Core::FileSys::HandleTable>::Instance();
+    auto* mnt = Common::Singleton<Core::FileSys::MntPoints>::Instance();
+
+    // only open files support!
+    u32 handle = h->createHandle();
+    auto* file = h->getFile(handle);
+    file->m_guest_name = path;
+    file->m_host_name = mnt->getHostFile(file->m_guest_name);
+
+    bool result = file->f.open(file->m_host_name);
+    if (!result) {
+        h->deleteHandle(handle);
+        return SCE_KERNEL_ERROR_EACCES;
+    }
+    file->isOpened = true;
+    return handle;
 }
 
-int PS4_SYSV_ABI open(const char* path, int flags, /* SceKernelMode*/ u16 mode) {
+int PS4_SYSV_ABI posix_open(const char* path, int flags, /* SceKernelMode*/ u16 mode) {
     LOG_INFO_IF(log_file_fs, "posix open redirect to sceKernelOpen\n");
     int result = sceKernelOpen(path, flags, mode);
     if (result < 0) {
@@ -21,9 +39,25 @@ int PS4_SYSV_ABI open(const char* path, int flags, /* SceKernelMode*/ u16 mode)
     return result;
 }
 
+size_t PS4_SYSV_ABI _readv(int d, const SceKernelIovec* iov, int iovcnt) {
+    auto* h = Common::Singleton<Core::FileSys::HandleTable>::Instance();
+    auto* file = h->getFile(d);
+    size_t total_read = 0;
+    file->m_mutex.lock();
+    for (int i = 0; i < iovcnt; i++) {
+        total_read += file->f.readBytes(iov[i].iov_base,iov[i].iov_len).second;
+    }
+    file->m_mutex.unlock();
+    return total_read;
+}
+
 void fileSystemSymbolsRegister(Loader::SymbolsResolver* sym) {
     LIB_FUNCTION("1G3lF1Gg1k8", "libkernel", 1, "libkernel", 1, 1, sceKernelOpen);
-    LIB_FUNCTION("wuCroIGjt2g", "libScePosix", 1, "libkernel", 1, 1, open);
+    LIB_FUNCTION("wuCroIGjt2g", "libScePosix", 1, "libkernel", 1, 1, posix_open);
+    LIB_FUNCTION("+WRlkKjZvag", "libkernel", 1, "libkernel", 1, 1, _readv);
+
+    // openOrbis (to check if it is valid out of OpenOrbis
+    LIB_FUNCTION("6c3rCVE-fTU", "libkernel", 1, "libkernel", 1, 1, posix_open);  // _open shoudld be equal to open function
 }
 
 } // namespace Core::Libraries::LibKernel

src/core/hle/libraries/libkernel/file_system.h

@@ -8,9 +8,14 @@ class SymbolsResolver;
 
 namespace Core::Libraries::LibKernel {
 
+struct SceKernelIovec {
+    void *iov_base;
+    size_t iov_len;
+};
+
 int PS4_SYSV_ABI sceKernelOpen(const char *path, int flags, /* SceKernelMode*/ u16 mode);
 
-int PS4_SYSV_ABI open(const char *path, int flags, /* SceKernelMode*/ u16 mode);
+int PS4_SYSV_ABI posix_open(const char *path, int flags, /* SceKernelMode*/ u16 mode);
 
 void fileSystemSymbolsRegister(Loader::SymbolsResolver *sym);
 

src/core/hle/libraries/libkernel/libkernel.cpp

@@ -14,11 +14,14 @@
 
 #ifdef _WIN64
 #include <windows.h>
+#include <io.h>
 #endif
 #include "thread_management.h"
 
 namespace Core::Libraries::LibKernel {
 
+constexpr bool log_libkernel_file = true;  // disable it to disable logging
+
 static u64 g_stack_chk_guard = 0xDEADBEEF54321ABC;  // dummy return
 
 int32_t PS4_SYSV_ABI sceKernelReleaseDirectMemory(off_t start, size_t len) {
@@ -30,9 +33,72 @@ static PS4_SYSV_ABI void stack_chk_fail() { BREAKPOINT(); }
 
 int PS4_SYSV_ABI sceKernelMunmap(void* addr, size_t len) { BREAKPOINT(); }
 
+void PS4_SYSV_ABI sceKernelUsleep(unsigned int microseconds) { std::this_thread::sleep_for(std::chrono::microseconds(microseconds)); }
+
+struct iovec {
+    void* iov_base; /* Base	address. */
+    size_t iov_len; /* Length. */
+};
+
+size_t PS4_SYSV_ABI _writev(int fd, const struct iovec* iov, int iovcn) {
+    // weird it gives fd ==0 and writes to stdout , i am not sure if it that is valid (found in openorbis)
+    size_t total_written = 0;
+    for (int i = 0; i < iovcn; i++) {
+        total_written += ::fwrite(iov[i].iov_base, 1, iov[i].iov_len, stdout);
+    }
+    return total_written;
+}
+
 static thread_local int libc_error;
 int* PS4_SYSV_ABI __Error() { return &libc_error; }
 
+#define PROT_READ 0x1
+#define PROT_WRITE 0x2
+
+int PS4_SYSV_ABI sceKernelMmap(void* addr, u64 len, int prot, int flags, int fd, off_t offset, void** res) {
+    PRINT_FUNCTION_NAME();
+    if (prot > 3)  // READ,WRITE or bitwise READ | WRITE supported
+    {
+        LOG_ERROR_IF(log_libkernel_file, "sceKernelMmap prot ={} not supported\n", prot);
+    }
+    DWORD flProtect;
+    if (prot & PROT_WRITE) {
+        flProtect = PAGE_READWRITE;
+    }
+    off_t end = len + offset;
+    HANDLE mmap_fd, h;
+    if (fd == -1)
+        mmap_fd = INVALID_HANDLE_VALUE;
+    else
+        mmap_fd = (HANDLE)_get_osfhandle(fd);
+    h = CreateFileMapping(mmap_fd, NULL, flProtect, 0, end, NULL);
+    int k = GetLastError();
+    if (NULL == h) return -1;
+    DWORD dwDesiredAccess;
+    if (prot & PROT_WRITE)
+        dwDesiredAccess = FILE_MAP_WRITE;
+    else
+        dwDesiredAccess = FILE_MAP_READ;
+    void* ret = MapViewOfFile(h, dwDesiredAccess, 0, offset, len);
+    if (ret == NULL) {
+        CloseHandle(h);
+        ret = nullptr;
+    }
+    *res = ret;
+    return 0;
+}
+
+PS4_SYSV_ABI void* posix_mmap(void* addr, u64 len, int prot, int flags, int fd, u64 offset) {
+    void* ptr;
+    LOG_INFO_IF(log_libkernel_file, "posix mmap redirect to sceKernelMmap\n");
+    // posix call the difference is that there is a different behaviour when it doesn't return 0 or SCE_OK
+    int result = sceKernelMmap(addr, len, prot, flags, fd, offset, &ptr);
+    if (result != 0) {
+        BREAKPOINT();
+    }
+    return ptr;
+}
+
 void LibKernel_Register(Loader::SymbolsResolver* sym) {
     // obj
     LIB_OBJ("f7uOxY9mM1U", "libkernel", 1, "libkernel", 1, 1, &g_stack_chk_guard);
@@ -49,6 +115,9 @@ void LibKernel_Register(Loader::SymbolsResolver* sym) {
     LIB_FUNCTION("WslcK1FQcGI", "libkernel", 1, "libkernel", 1, 1, Kernel::sceKernelIsNeoMode);
     LIB_FUNCTION("Ou3iL1abvng", "libkernel", 1, "libkernel", 1, 1, stack_chk_fail);
     LIB_FUNCTION("9BcDykPmo1I", "libkernel", 1, "libkernel", 1, 1, __Error);
+    LIB_FUNCTION("BPE9s9vQQXo", "libkernel", 1, "libkernel", 1, 1, posix_mmap);
+    LIB_FUNCTION("1jfXLRVzisc", "libkernel", 1, "libkernel", 1, 1, sceKernelUsleep);
+    LIB_FUNCTION("YSHRBRLn2pI", "libkernel", 1, "libkernel", 1, 1, _writev);
 
     Core::Libraries::LibKernel::fileSystemSymbolsRegister(sym);
     Core::Libraries::LibKernel::timeSymbolsRegister(sym);

src/core/linker.cpp

@@ -95,8 +95,62 @@ Module* Linker::FindModule(/*u32 id*/)
     return &m_modules[0];
 }
 
-void Linker::LoadModuleToMemory(Module* m)
+struct TLSPattern{
-{
+    uint8_t pattern[5];
+    uint8_t pattern_size;
+    uint8_t imm_size;
+    uint8_t target_reg;
+};
+
+constexpr TLSPattern tls_patterns[] = {
+    {{0x64, 0x48, 0xA1}, 3, 8, 0},			   // 64 48 A1 | 00 00 00 00 00 00 00 00 # mov rax, qword ptr fs:[64b imm]
+
+    {{0x64, 0x48, 0x8B, 0x4, 0x25}, 5, 4, 0},  // 64 48 8B 04 25 | 00 00 00 00 # mov rax,qword ptr fs:[0]
+    {{0x64, 0x48, 0x8B, 0xC, 0x25}, 5, 4, 1},  // rcx
+    {{0x64, 0x48, 0x8B, 0x14, 0x25}, 5, 4, 2}, // rdx
+    {{0x64, 0x48, 0x8B, 0x1C, 0x25}, 5, 4, 3}, // rbx
+    {{0x64, 0x48, 0x8B, 0x24, 0x25}, 5, 4, 4}, // rsp
+    {{0x64, 0x48, 0x8B, 0x2C, 0x25}, 5, 4, 5}, // rbp
+    {{0x64, 0x48, 0x8B, 0x34, 0x25}, 5, 4, 6}, // rsi
+    {{0x64, 0x48, 0x8B, 0x3C, 0x25}, 5, 4, 7}, // rdi
+    {{0x64, 0x4C, 0x8B, 0x4, 0x25}, 5, 4, 8},  // r8
+    {{0x64, 0x4C, 0x8B, 0xC, 0x25}, 5, 4, 9},  // r9
+    {{0x64, 0x4C, 0x8B, 0x14, 0x25}, 5, 4, 10},// r10
+    {{0x64, 0x4C, 0x8B, 0x1C, 0x25}, 5, 4, 11},// r11
+    {{0x64, 0x4C, 0x8B, 0x24, 0x25}, 5, 4, 12},// r12
+    {{0x64, 0x4C, 0x8B, 0x2C, 0x25}, 5, 4, 13},// r13
+    {{0x64, 0x4C, 0x8B, 0x34, 0x25}, 5, 4, 14},// r14
+    {{0x64, 0x4C, 0x8B, 0x3C, 0x25}, 5, 4, 15},// r15
+};
+
+void PatchTLS(u64 segment_addr, u64 segment_size) {
+    uint8_t* code = (uint8_t*)segment_addr;
+    auto remaining_size = segment_size;
+
+    while (remaining_size) {
+        for (auto& tls_pattern : tls_patterns) {
+            auto total_size = tls_pattern.pattern_size + tls_pattern.imm_size;
+            if (remaining_size >= total_size) {
+                if (memcmp(code, tls_pattern.pattern, tls_pattern.pattern_size) == 0) {
+                    if (tls_pattern.imm_size == 4)
+						printf("PATTERN32 FOUND @ %p, reg: %d offset: %X\n", code, tls_pattern.target_reg, *(uint32_t*)(code + tls_pattern.pattern_size));
+                    else
+						printf("PATTERN64 FOUND @ %p, reg: %d offset: %lX\n", code, tls_pattern.target_reg, *(uint64_t*)(code + tls_pattern.pattern_size));
+                    code[0] = 0xcd;
+                    code[1] = 0x80 + tls_pattern.target_reg;
+                    code[2] = tls_pattern.pattern_size | (tls_pattern.imm_size << 4);
+                    code += total_size - 1;
+                    remaining_size -= total_size - 1;
+                    break;
+                }
+            }
+        }
+        code++;
+        remaining_size--;
+    }
+}
+
+void Linker::LoadModuleToMemory(Module* m) {
 	//get elf header, program header
     const auto elf_header = m->elf.GetElfHeader();
     const auto elf_pheader = m->elf.GetProgramHeader();
@@ -130,6 +184,10 @@ void Linker::LoadModuleToMemory(Module* m)
 					LOG_INFO_IF(debug_loader, "segment_mode ..........: {}\n", segment_mode);
 					
                     m->elf.LoadSegment(segment_addr, elf_pheader[i].p_offset, segment_file_size);
+
+					if (elf_pheader[i].p_flags & PF_EXEC) {
+                        PatchTLS(segment_addr, segment_file_size);
+					}
 				}
 				else
 				{
@@ -158,29 +216,17 @@ void Linker::LoadModuleToMemory(Module* m)
                     LOG_ERROR_IF(debug_loader, "p_filesz==0 in type {}\n", m->elf.ElfPheaderTypeStr(elf_pheader[i].p_type));
 				}
 				break;
+            case PT_TLS:
+                m->tls.image_virtual_addr = elf_pheader[i].p_vaddr + m->base_virtual_addr;
+                m->tls.image_size = get_aligned_size(elf_pheader[i]);
+                LOG_INFO_IF(debug_loader, "tls virtual address ={:#x}\n", m->tls.image_virtual_addr);
+                LOG_INFO_IF(debug_loader, "tls image size      ={}\n", m->tls.image_size);
+                break;
 			default:
                 LOG_ERROR_IF(debug_loader, "Unimplemented type {}\n", m->elf.ElfPheaderTypeStr(elf_pheader[i].p_type));
 		}
 	}
     LOG_INFO_IF(debug_loader, "program entry addr ..........: {:#018x}\n", m->elf.GetElfEntry() + m->base_virtual_addr);
-
-    auto* rt1 = reinterpret_cast<uint8_t*>(m->elf.GetElfEntry() + m->base_virtual_addr);
-    ZyanU64 runtime_address = m->elf.GetElfEntry() + m->base_virtual_addr;
-
-	// Loop over the instructions in our buffer.
-	ZyanUSize offset = 0;
-	ZydisDisassembledInstruction instruction;
-	while (ZYAN_SUCCESS(ZydisDisassembleIntel(
-		/* machine_mode:    */ ZYDIS_MACHINE_MODE_LONG_64,
-		/* runtime_address: */ runtime_address,
-		/* buffer:          */ rt1 + offset,
-		/* length:          */ sizeof(rt1) - offset,
-		/* instruction:     */ &instruction
-	))) {
-		fmt::print("{:#x}" PRIX64 "  {}\n", runtime_address, instruction.text);
-		offset += instruction.info.length;
-		runtime_address += instruction.info.length;
-	}
 }
 
 void Linker::LoadDynamicInfo(Module* m)
@@ -316,7 +362,7 @@ void Linker::LoadDynamicInfo(Module* m)
 			break;
 		case DT_SCE_IMPORT_LIB_ATTR:
 			//The upper 32-bits should contain the module index multiplied by 0x10000. The lower 32-bits should be a constant 0x9.
-			LOG_INFO_IF(debug_loader, "unsupported DT_SCE_IMPORT_LIB_ATTR value = ..........: {:#018x}\n", dyn->d_un.d_val);
+			LOG_INFO_IF(debug_loader, "unsupported DT_SCE_IMPORT_LIB_ATTR value = ......: {:#018x}\n", dyn->d_un.d_val);
 			break;
 		case DT_SCE_ORIGINAL_FILENAME:
             m->dynamic_info.filename = m->dynamic_info.str_table + dyn->d_un.d_val;
@@ -507,7 +553,7 @@ static void relocate(u32 idx, elf_relocation* rel, Module* m, bool isJmpRel) {
         case R_X86_64_RELATIVE:
             if (symbol != 0)  // should be always zero
             {
-                LOG_INFO_IF(debug_loader, "R_X86_64_RELATIVE symbol not zero = {:#010x}\n", type, symbol);
+                //LOG_INFO_IF(debug_loader, "R_X86_64_RELATIVE symbol not zero = {:#010x}\n", type, symbol);//found it openorbis but i am not sure it worth logging
             }
             rel_value = rel_base_virtual_addr + addend;
             rel_isResolved = true;

src/core/linker.h

@@ -43,6 +43,11 @@ struct LibraryInfo {
 	std::string enc_id;
 };
 
+struct PS4ThreadLocal {
+    u64 image_virtual_addr = 0;
+    u64 image_size = 0;
+    u64 handler_virtual_addr = 0;
+};
 struct DynamicModuleInfo {
     void* hash_table = nullptr;
     u64 hash_table_size = 0;
@@ -99,6 +104,8 @@ struct Module {
 
     Loader::SymbolsResolver export_sym;
     Loader::SymbolsResolver import_sym;
+
+    PS4ThreadLocal tls;
 };
 
 class Linker {

src/core/loader/elf.h

@@ -1,15 +1,14 @@
 #pragma once
 
-#include <string>
 #include <cinttypes>
 #include <span>
+#include <string>
 #include <vector>
 
-#include "common/types.h"
 #include "common/fs_file.h"
+#include "common/types.h"
 
-struct self_header
+struct self_header {
-{
     static const u32 signature = 0x1D3D154Fu;
 
     u32 magic;
@@ -29,15 +28,12 @@ struct self_header
     u32 padding3;
 };
 
-struct self_segment_header
+struct self_segment_header {
-{
     bool IsBlocked() const {
         return (flags & 0x800) != 0;  // 0 or 0x800
     }
 
-    u32 GetId() const {
+    u32 GetId() const { return (flags >> 20u) & 0xFFFu; }
-        return (flags >> 20u) & 0xFFFu;
-    }
 
     bool IsOrdered() const {
         return (flags & 1) != 0;  // 0 or 1
@@ -61,7 +57,6 @@ struct self_segment_header
     u64 memory_size;
 };
 
-
 constexpr u08 EI_MAG0 = 0; /* e_ident[] indexes */
 constexpr u08 EI_MAG1 = 1;
 constexpr u08 EI_MAG2 = 2;
@@ -184,30 +179,13 @@ typedef enum : u16 {
     EM_UNICORE = 110     /* Microprocessor series from PKU-Unity Ltd. and MPRC */
 } e_machine_es;
 
-typedef enum :u32 {
+typedef enum : u32 { EV_NONE = 0x0, EV_CURRENT = 0x1 } e_version_es;
-    EV_NONE = 0x0,
-    EV_CURRENT = 0x1
-} e_version_es;
 
-typedef enum : u08 {
+typedef enum : u08 { ELF_CLASS_NONE = 0x0, ELF_CLASS_32 = 0x1, ELF_CLASS_64 = 0x2, ELF_CLASS_NUM = 0x3 } ident_class_es;
-    ELF_CLASS_NONE  =0x0,
-    ELF_CLASS_32	=0x1,
-    ELF_CLASS_64	=0x2,
-    ELF_CLASS_NUM	=0x3
-} ident_class_es;
 
-typedef enum : u08 {
+typedef enum : u08 { ELF_DATA_NONE = 0x0, ELF_DATA_2LSB = 0x1, ELF_DATA_2MSB = 0x2, ELF_DATA_NUM = 0x3 } ident_endian_es;
-    ELF_DATA_NONE = 0x0,
-    ELF_DATA_2LSB = 0x1,
-    ELF_DATA_2MSB = 0x2,
-    ELF_DATA_NUM = 0x3
-} ident_endian_es;
 
-typedef enum :u08 {
+typedef enum : u08 { ELF_VERSION_NONE = 0x0, ELF_VERSION_CURRENT = 0x1, ELF_VERSION_NUM = 0x2 } ident_version_es;
-    ELF_VERSION_NONE = 0x0,
-    ELF_VERSION_CURRENT = 0x1,
-    ELF_VERSION_NUM = 0x2
-} ident_version_es;
 
 typedef enum : u08 {
     ELF_OSABI_NONE = 0x0,       /* No extensions or unspecified */
@@ -246,8 +224,7 @@ struct elf_ident {
     u08 pad[6];
 };
 
-struct elf_header
+struct elf_header {
-{
     static const u32 signature = 0x7F454C46u;
 
     elf_ident e_ident;      /* ELF identification */
@@ -306,8 +283,7 @@ typedef enum : u32 {
     PF_READ_WRITE_EXEC = 0x7
 } elf_program_flags;
 
-struct elf_program_header
+struct elf_program_header {
-{
     elf_program_type p_type;   /* Type of segment */
     elf_program_flags p_flags; /* Segment attributes */
     u64 p_offset;              /* Offset in file */
@@ -318,8 +294,7 @@ struct elf_program_header
     u64 p_align;               /* Alignment of segment */
 };
 
-struct elf_section_header
+struct elf_section_header {
-{
     u32 sh_name;      /* Section name */
     u32 sh_type;      /* Section type */
     u64 sh_flags;     /* Section attributes */
@@ -343,8 +318,7 @@ typedef enum :u64 {
     PT_SECURE_KERNEL = 0xF
 } program_type_es;
 
-struct elf_program_id_header
+struct elf_program_id_header {
-{
     u64 authid;
     program_type_es program_type;
     u64 appver;
@@ -389,12 +363,9 @@ constexpr s64 DT_SCE_STRSZ             = 0x61000037;
 constexpr s64 DT_SCE_SYMTAB = 0x61000039;
 constexpr s64 DT_SCE_SYMTABSZ = 0x6100003f;
 
-
+struct elf_dynamic {
-struct elf_dynamic
-{
     s64 d_tag;
-    union
+    union {
-    {
         u64 d_val;
         u64 d_ptr;
     } d_un;
@@ -423,8 +394,7 @@ constexpr u08 STV_INTERNAL = 1;
 constexpr u08 STV_HIDDEN = 2;
 constexpr u08 STV_PROTECTED = 3;
 
-struct elf_symbol
+struct elf_symbol {
-{
     u08 GetBind() const { return st_info >> 4u; }
     u08 GetType() const { return st_info & 0xfu; }
     u08 GetVisibility() const { return st_other & 3u; }
@@ -437,8 +407,7 @@ struct elf_symbol
     u64 st_size;
 };
 
-struct elf_relocation
+struct elf_relocation {
-{
     u32 GetSymbol() const { return static_cast<u32>(rel_info >> 32u); }
     u32 GetType() const { return static_cast<u32>(rel_info & 0xffffffff); }
 
@@ -447,8 +416,10 @@ struct elf_relocation
     s64 rel_addend;
 };
 constexpr u32 R_X86_64_64 = 1;  // Direct 64 bit
+constexpr u32 R_X86_64_GLOB_DAT = 6;
 constexpr u32 R_X86_64_JUMP_SLOT = 7;  // Create PLT entry
 constexpr u32 R_X86_64_RELATIVE = 8;   // Adjust by program base
+constexpr u32 R_X86_64_DTPMOD64 = 16;
 
 namespace Core::Loader {
 
@@ -462,25 +433,15 @@ class Elf {
     bool isElfFile() const;
     void DebugDump();
 
-    [[nodiscard]] self_header GetSElfHeader() const {
+    [[nodiscard]] self_header GetSElfHeader() const { return m_self; }
-        return m_self;
-    }
 
-    [[nodiscard]] elf_header GetElfHeader() const {
+    [[nodiscard]] elf_header GetElfHeader() const { return m_elf_header; }
-        return m_elf_header;
-    }
 
-    [[nodiscard]] std::span<const elf_program_header> GetProgramHeader() const {
+    [[nodiscard]] std::span<const elf_program_header> GetProgramHeader() const { return m_elf_phdr; }
-        return m_elf_phdr;
-    }
 
-    [[nodiscard]] std::span<const self_segment_header> GetSegmentHeader() const {
+    [[nodiscard]] std::span<const self_segment_header> GetSegmentHeader() const { return m_self_segments; }
-        return m_self_segments;
-    }
 
-    [[nodiscard]] u64 GetElfEntry() const {
+    [[nodiscard]] u64 GetElfEntry() const { return m_elf_header.e_entry; }
-        return m_elf_header.e_entry;
-    }
 
     std::string SElfHeaderStr();
     std::string SELFSegHeader(u16 no);

src/core/virtual_memory.cpp

@@ -1,6 +1,7 @@
-#include "common/log.h"
 #include "core/virtual_memory.h"
 
+#include "common/log.h"
+
 #ifdef _WIN64
 #include <windows.h>
 #else
@@ -107,8 +108,7 @@ bool memory_patch(u64 vaddr, u64 value) {
     memory_protect(vaddr, 8, old_mode, nullptr);
 
     // if mode is executable flush it so insure that cpu finds it
-    if ((old_mode == MemoryMode::Execute || old_mode == MemoryMode::ExecuteRead || old_mode == MemoryMode::ExecuteWrite ||
+    if (containsExecuteMode(old_mode)) {
-         old_mode == MemoryMode::ExecuteReadWrite)) {
         memory_flush(vaddr, 8);
     }
 

src/core/virtual_memory.h

@@ -25,4 +25,14 @@ bool memory_protect(u64 address, u64 size, MemoryMode mode, MemoryMode* old_mode
 bool memory_flush(u64 address, u64 size);
 bool memory_patch(u64 vaddr, u64 value);
 
+inline bool containsExecuteMode(MemoryMode mode) {
+    switch (mode) {
+        case MemoryMode::Execute: return true;
+        case MemoryMode::ExecuteRead: return true;
+        case MemoryMode::ExecuteWrite: return true;
+        case MemoryMode::ExecuteReadWrite: return true;
+        default: return false;
+    }
+}
+
 }  // namespace VirtualMemory