diff --git a/CMakeLists.txt b/CMakeLists.txt index 70b5d77a..4cd69b12 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,4 +1,6 @@ cmake_minimum_required(VERSION 3.16.3) +set(CMAKE_CXX_STANDARD 20) +set(CMAKE_CXX_STANDARD_REQUIRED True) project(shadps4) @@ -7,13 +9,18 @@ include_directories(third-party/imgui/) include_directories(third-party/imgui/backends) include_directories(third-party/sdl/) include_directories(third-party/fmt/include) - +include_directories(third-party/magic_enum/include) add_subdirectory("third-party") #=================== EXAMPLE =================== add_executable(shadps4 src/main.cpp + src/types.h + src/Core/FsFile.cpp + src/Core/FsFile.h + src/Loader/Elf.cpp + src/Loader/Elf.h ) find_package(OpenGL REQUIRED) diff --git a/src/Core/FsFile.cpp b/src/Core/FsFile.cpp new file mode 100644 index 00000000..2ea882f1 --- /dev/null +++ b/src/Core/FsFile.cpp @@ -0,0 +1,90 @@ +#include "FsFile.h" + +FsFile::FsFile() +{ + m_file = nullptr; +} +FsFile::FsFile(const std::string& path, fsOpenMode mode) +{ + Open(path, mode); +} +bool FsFile::Open(const std::string& path, fsOpenMode mode) +{ + Close(); + fopen_s(&m_file, path.c_str(), getOpenMode(mode)); + return IsOpen(); +} +bool FsFile::Close() +{ + if (!IsOpen() || std::fclose(m_file) != 0) { + m_file = nullptr; + return false; + } + + m_file = nullptr; + return true; +} +FsFile::~FsFile() +{ + Close(); +} + +bool FsFile::Write(const void* src, u64 size) +{ + if (!IsOpen() || std::fwrite(src, 1, size, m_file) != size) { + return false; + } + return true; +} + +bool FsFile::Read(void* dst, u64 size) +{ + if (!IsOpen() || std::fread(dst, 1, size, m_file) != size) { + return false; + } + return true; +} + +u32 FsFile::ReadBytes(void* dst, u64 size) +{ + return std::fread(dst, 1, size, m_file); +} + +bool FsFile::Seek(s64 offset, fsSeekMode mode) +{ + if (!IsOpen() || _fseeki64(m_file, offset, getSeekMode(mode)) != 0) { + return false; + } + return true; +} + +u64 FsFile::Tell() const +{ + if (IsOpen()) { + return _ftelli64(m_file); + } + else { + return -1; + } +} +u64 FsFile::getFileSize() +{ + u64 pos = _ftelli64(m_file); + if (_fseeki64(m_file, 0, SEEK_END) != 0) { + + return 0; + } + + u64 size = _ftelli64(m_file); + if (_fseeki64(m_file, pos, SEEK_SET) != 0) { + + return 0; + } + return size; +} + +bool FsFile::IsOpen() const +{ + return m_file != nullptr; +} + diff --git a/src/Core/FsFile.h b/src/Core/FsFile.h new file mode 100644 index 00000000..dd505df8 --- /dev/null +++ b/src/Core/FsFile.h @@ -0,0 +1,63 @@ +#pragma once +#include +#include +#include "../Types.h" + +enum fsOpenMode +{ + fsRead = 0x1, + fsWrite = 0x2, + fsReadWrite = fsRead | fsWrite +}; + +enum fsSeekMode +{ + fsSeekSet, + fsSeekCur, + fsSeekEnd, +}; + +class FsFile +{ + std::FILE* m_file; +public: + FsFile(); + FsFile(const std::string& path, fsOpenMode mode = fsRead); + bool Open(const std::string& path, fsOpenMode mode = fsRead); + bool IsOpen() const; + bool Close(); + bool Read(void* dst, u64 size); + u32 ReadBytes(void* dst, u64 size); + bool Write(const void* src, u64 size); + bool Seek(s64 offset, fsSeekMode mode); + u64 getFileSize(); + u64 Tell() const; + ~FsFile(); + + const char* getOpenMode(fsOpenMode mode) + { + switch (mode) { + case fsRead: return "rb"; + case fsWrite: return "wb"; + case fsReadWrite: return "r+b"; + } + + return "r"; + } + + const int getSeekMode(fsSeekMode mode) + { + switch (mode) { + case fsSeekSet: return SEEK_SET; + case fsSeekCur: return SEEK_CUR; + case fsSeekEnd: return SEEK_END; + } + + return SEEK_SET; + } + std::FILE* fileDescr() + { + return m_file; + } +}; + diff --git a/src/Loader/Elf.cpp b/src/Loader/Elf.cpp new file mode 100644 index 00000000..8e383508 --- /dev/null +++ b/src/Loader/Elf.cpp @@ -0,0 +1,432 @@ +#include "Elf.h" +#include "spdlog/spdlog.h" +#include "spdlog/sinks/basic_file_sink.h" +#include +#include +#include + +template <> +struct magic_enum::customize::enum_range { + static constexpr int min = 0xfe00; + static constexpr int max = 0xfe18; + // (max - min) must be less than UINT16_MAX. +}; + +Elf::~Elf() +{ + Reset(); +} + +static self_header* load_self(FsFile& f) +{ + //read self header + auto* self = new self_header; + f.Read(self, sizeof(self_header)); + return self; +} + + +static self_segment_header* load_self_segments(FsFile& f, u16 num) +{ + auto* segs = new self_segment_header[num]; + + f.Read(segs, sizeof(self_segment_header) * num); + + return segs; +} + + +static elf_header* load_elf_header(FsFile& f) +{ + auto* m_elf_header = new elf_header; + + f.Read(m_elf_header, sizeof(elf_header)); + + return m_elf_header; +} + +static elf_program_header* load_program_header(FsFile& f, u64 offset, u16 num) +{ + auto* phdr = new elf_program_header[num]; + + f.Seek(offset,fsSeekMode::fsSeekSet); + f.Read(phdr, sizeof(elf_program_header) * num); + + return phdr; +} + +static elf_section_header* load_section_header(FsFile& f, u64 offset, u16 num) +{ + if (num == 0)//just in case we don't have section headers + { + return nullptr; + } + + auto* shdr = new elf_section_header[num]; + + f.Seek(offset,fsSeekMode::fsSeekSet); + f.Read(shdr, sizeof(elf_section_header) * num); + + return shdr; +} + +void Elf::Reset()//reset all variables +{ + if (m_f != nullptr) + { + m_f->Close(); + delete m_f; + } + delete m_self; + delete m_elf_header; + delete m_self_id_header; + delete[] m_self_segments; + delete[] m_elf_phdr; + delete[] m_elf_shdr; + + m_self = nullptr; + m_self_segments = nullptr; + m_elf_header = nullptr; + m_elf_phdr = nullptr; + m_elf_shdr = nullptr; + m_self_id_header = nullptr; +} +void Elf::Open(const std::string& file_name) +{ + Reset();//reset all variables + + m_f = new FsFile; + m_f->Open(file_name, fsOpenMode::fsRead); + + m_self = load_self(*m_f); + + bool isself = isSelfFile(); + if (!isself) + { + delete m_self; + m_self = nullptr; + m_f->Seek(0,fsSeekMode::fsSeekSet); //it is not an self file move to the start of file + } + else + { + m_self_segments = load_self_segments(*m_f, m_self->segment_count); + } + + auto elfheader_pos = m_f->Tell();//get the entry pos for elf file + + m_elf_header = load_elf_header(*m_f); + + if (!isElfFile()) + { + delete m_elf_header; + m_elf_header = nullptr; + } + + if (m_elf_header != nullptr) + { + m_elf_phdr = load_program_header(*m_f, elfheader_pos + m_elf_header->e_phoff, m_elf_header->e_phnum); + m_elf_shdr = load_section_header(*m_f, elfheader_pos + m_elf_header->e_shoff, m_elf_header->e_shnum); + } + if (isself && m_elf_header != nullptr) + { + u64 header_size = 0; + header_size += sizeof(self_header); + header_size += sizeof(self_segment_header) * m_self->segment_count; + header_size += sizeof(elf_header); + header_size += m_elf_header->e_phnum * m_elf_header->e_phentsize; + header_size += m_elf_header->e_shnum * m_elf_header->e_shentsize; + header_size += 15; header_size &= ~15; // align + + if (m_elf_header->e_ehsize - header_size >= sizeof(elf_program_id_header)) + { + m_f->Seek(header_size, fsSeekMode::fsSeekSet); + + m_self_id_header = new elf_program_id_header; + m_f->Read(m_self_id_header, sizeof(elf_program_id_header)); + + } + } + + + DebugDump(); +} + +bool Elf::isSelfFile() const +{ + if (m_f == nullptr) + { + return false; + } + + if (m_self == nullptr) + { + return false;//if we can't load self header return false + } + + if (m_self->magic != self_header::signature) + { + printf("Not a SELF file. Magic file mismatched! current = 0x%08X required = 0x%08X\n", m_self->magic, self_header::signature); + return false; + } + + if (m_self->version != 0x00 || m_self->mode != 0x01 || m_self->endian != 0x01 || m_self->attributes != 0x12) + { + printf("Unknown SELF file\n"); + return false; + } + + if (m_self->category != 0x01 || m_self->program_type != 0x01) + { + printf("Unknown SELF file\n"); + return false; + } + + return true; +} + +bool Elf::isElfFile() const +{ + if (m_f == nullptr) + { + return false; + } + + if (m_elf_header == nullptr) + { + return false; + } + + if (m_elf_header->e_ident.magic[EI_MAG0] != ELFMAG0 || m_elf_header->e_ident.magic[EI_MAG1] != ELFMAG1 || m_elf_header->e_ident.magic[EI_MAG2] != ELFMAG2 || + m_elf_header->e_ident.magic[EI_MAG3] != ELFMAG3) + { + printf("ERROR:Not an ELF file magic is wrong!\n"); + return false; + } + if (m_elf_header->e_ident.ei_class != ELF_CLASS_64) + { + printf("ERROR:e_ident[EI_CLASS] expected 0x02 is (0x%x)\n", m_elf_header->e_ident.ei_class); + return false; + } + + if (m_elf_header->e_ident.ei_data != ELF_DATA_2LSB) + { + printf("ERROR:e_ident[EI_DATA] expected 0x01 is (0x%x)\n", m_elf_header->e_ident.ei_data); + return false; + } + + if (m_elf_header->e_ident.ei_version != ELF_VERSION_CURRENT) + { + printf("ERROR:e_ident[EI_VERSION] expected 0x01 is (0x%x)\n", m_elf_header->e_ident.ei_version); + return false; + } + + if (m_elf_header->e_ident.ei_osabi != ELF_OSABI_FREEBSD) + { + printf("ERROR:e_ident[EI_OSABI] expected 0x09 is (0x%x)\n", m_elf_header->e_ident.ei_osabi); + return false; + } + + if (m_elf_header->e_ident.ei_abiversion != ELF_ABI_VERSION_AMDGPU_HSA_V2) + { + printf("ERROR:e_ident[EI_ABIVERSION] expected 0x00 is (0x%x)\n", m_elf_header->e_ident.ei_abiversion); + return false; + } + + if (m_elf_header->e_type != ET_SCE_DYNEXEC && m_elf_header->e_type != ET_SCE_DYNAMIC) + { + printf("ERROR:e_type expected 0xFE10 OR 0xFE18 is (%04x)\n", m_elf_header->e_type); + return false; + } + + if (m_elf_header->e_machine != EM_X86_64) + { + printf("ERROR:e_machine expected 0x3E is (%04x)\n", m_elf_header->e_machine); + return false; + } + + if (m_elf_header->e_version != EV_CURRENT) + { + printf("ERROR:m_elf_header->e_version expected 0x01 is (0x%x)\n", m_elf_header->e_version); + return false; + } + + if (m_elf_header->e_phentsize != sizeof(elf_program_header)) + { + printf("ERROR:e_phentsize (%d) != sizeof(elf_program_header)\n", m_elf_header->e_phentsize); + return false; + } + + if (m_elf_header->e_shentsize > 0 && m_elf_header->e_shentsize != sizeof(elf_section_header)) //commercial games doesn't appear to have section headers + { + printf("ERROR:e_shentsize (%d) != sizeof(elf_section_header)\n", m_elf_header->e_shentsize); + return false; + } + + return true; +} + +void Elf::DebugDump() { + std::vector sinks; + sinks.push_back(std::make_shared()); + sinks.push_back(std::make_shared(L"output.log", true)); //this might work only in windows ;/ + spdlog::set_default_logger(std::make_shared("shadps4 logger", begin(sinks), end(sinks))); + auto f = std::make_unique("%v", spdlog::pattern_time_type::local, std::string("")); // disable eol + spdlog::set_formatter(std::move(f)); + spdlog::info("SELF header:\n"); + + spdlog::info(" magic ..............: 0x{:X}\n", m_self->magic); + spdlog::info(" version .........: {}\n", m_self->version); + spdlog::info(" mode .........: {:#04x}\n", m_self->mode); + spdlog::info(" endian .........: {}\n", m_self->endian); + spdlog::info(" attributes .........: {:#04x}\n", m_self->attributes); + spdlog::info(" category .........: {:#04x}\n", m_self->category); + spdlog::info(" program_type........: {:#04x}\n", m_self->program_type); + spdlog::info(" padding1 ...........: {:#06x}\n", m_self->padding1); + spdlog::info(" header size ........: {}\n", m_self->header_size); + spdlog::info(" meta size .....: {}\n", m_self->meta_size); + spdlog::info(" file size ..........: {}\n", m_self->file_size); + spdlog::info(" padding2 ...........: {:#010x}\n", m_self->padding2); + spdlog::info(" segment count ......: {}\n", m_self->segment_count); + spdlog::info(" unknown 1A .........: {:#06x}\n", m_self->unknown1A); + spdlog::info(" padding3 ...........: {:#010x}\n", m_self->padding3); + spdlog::info("\n"); + + spdlog::info("SELF segments:\n"); + + for (int i = 0; i < m_self->segment_count; i++) + { + auto segment_header = m_self_segments[i]; + spdlog::info(" [{}]\n", i); + spdlog::info(" flags ............: {:#018x}\n", segment_header.flags); + spdlog::info(" file offset ......: {:#018x}\n", segment_header.file_offset); + spdlog::info(" file size ........: {}\n", segment_header.file_size); + spdlog::info(" memory size ......: {}\n", segment_header.memory_size); + } + spdlog::info("\n"); + + spdlog::info("Elf header:\n"); + spdlog::info(" ident ............: 0x"); + for (auto i : m_elf_header->e_ident.magic) + { + spdlog::info("{:02X}", i); + } + spdlog::info("\n"); + + auto ident_class = magic_enum::enum_cast(m_elf_header->e_ident.ei_class); + if (ident_class.has_value()) + { + spdlog::info(" ident class.......: {}\n", magic_enum::enum_name(ident_class.value())); + } + + auto ident_data = magic_enum::enum_cast(m_elf_header->e_ident.ei_data); + if (ident_data.has_value()) + { + spdlog::info(" ident data .......: {}\n", magic_enum::enum_name(ident_data.value())); + } + + auto ident_version = magic_enum::enum_cast(m_elf_header->e_ident.ei_version); + if (ident_version.has_value()) + { + spdlog::info(" ident version.....: {}\n", magic_enum::enum_name(ident_version.value())); + } + + auto ident_osabi = magic_enum::enum_cast(m_elf_header->e_ident.ei_osabi); + if (ident_osabi.has_value()) + { + spdlog::info(" ident osabi .....: {}\n", magic_enum::enum_name(ident_osabi.value())); + } + + auto ident_abiversion = magic_enum::enum_cast(m_elf_header->e_ident.ei_abiversion); + if (ident_abiversion.has_value()) + { + spdlog::info(" ident abiversion..: {}\n", magic_enum::enum_name(ident_abiversion.value())); + } + + spdlog::info(" ident UNK ........: 0x"); + for (auto i : m_elf_header->e_ident.pad) + { + spdlog::info("{:02X}", i); + } + spdlog::info("\n"); + + auto type = magic_enum::enum_cast(m_elf_header->e_type); + if (type.has_value()) + { + spdlog::info(" type ............: {}\n", magic_enum::enum_name(type.value())); + } + + auto machine = magic_enum::enum_cast(m_elf_header->e_machine); + if (machine.has_value()) + { + spdlog::info(" machine ..........: {}\n", magic_enum::enum_name(machine.value())); + } + auto version = magic_enum::enum_cast(m_elf_header->e_version); + if (version.has_value()) + { + spdlog::info(" version ..........: {}\n", magic_enum::enum_name(version.value())); + } + spdlog::info(" entry ............: {:#018x}\n", m_elf_header->e_entry); + spdlog::info(" phoff ............: {:#018x}\n", m_elf_header->e_phoff); + spdlog::info(" shoff ............: {:#018x}\n", m_elf_header->e_shoff); + spdlog::info(" flags ............: {:#010x}\n", m_elf_header->e_flags); + spdlog::info(" ehsize ...........: {}\n", m_elf_header->e_ehsize); + spdlog::info(" phentsize ........: {}\n", m_elf_header->e_phentsize); + spdlog::info(" phnum ............: {}\n", m_elf_header->e_phnum); + spdlog::info(" shentsize ........: {}\n", m_elf_header->e_shentsize); + spdlog::info(" shnum ............: {}\n", m_elf_header->e_shnum); + spdlog::info(" shstrndx .........: {}\n", m_elf_header->e_shstrndx); + + if (m_elf_header->e_phentsize > 0) + { + spdlog::info("Program headers:\n"); + for (u16 i = 0; i < m_elf_header->e_phnum; i++) + { + spdlog::info("--- phdr [{}] ---\n", i); + spdlog::info("p_type ....: {:#010x}\n", (m_elf_phdr+i)->p_type); + spdlog::info("p_flags ...: {:#010x}\n", (m_elf_phdr + i)->p_flags); + spdlog::info("p_offset ..: {:#018x}\n", (m_elf_phdr + i)->p_offset); + spdlog::info("p_vaddr ...: {:#018x}\n", (m_elf_phdr + i)->p_vaddr); + spdlog::info("p_paddr ...: {:#018x}\n", (m_elf_phdr + i)->p_paddr); + spdlog::info("p_filesz ..: {:#018x}\n", (m_elf_phdr + i)->p_filesz); + spdlog::info("p_memsz ...: {:#018x}\n", (m_elf_phdr + i)->p_memsz); + spdlog::info("p_align ...: {:#018x}\n", (m_elf_phdr + i)->p_align); + } + } + if (m_elf_header->e_shentsize > 0) + { + spdlog::info("Section headers:\n"); + for (u16 i = 0; i < m_elf_header->e_shnum; i++) + { + spdlog::info("--- shdr {} --\n", i); + spdlog::info("sh_name ........: {}\n", (m_elf_shdr + i)->sh_name); + spdlog::info("sh_type ........: {:#010x}\n", (m_elf_shdr + i)->sh_type); + spdlog::info("sh_flags .......: {:#018x}\n", (m_elf_shdr + i)->sh_flags); + spdlog::info("sh_addr ........: {:#018x}\n", (m_elf_shdr + i)->sh_addr); + spdlog::info("sh_offset ......: {:#018x}\n", (m_elf_shdr + i)->sh_offset); + spdlog::info("sh_size ........: {:#018x}\n", (m_elf_shdr + i)->sh_size); + spdlog::info("sh_link ........: {:#010x}\n", (m_elf_shdr + i)->sh_link); + spdlog::info("sh_info ........: {:#010x}\n", (m_elf_shdr + i)->sh_info); + spdlog::info("sh_addralign ...: {:#018x}\n", (m_elf_shdr + i)->sh_addralign); + spdlog::info("sh_entsize .....: {:#018x}\n", (m_elf_shdr + i)->sh_entsize); + } + } + if (m_self_id_header != nullptr) + { + spdlog::info("SELF info:\n"); + spdlog::info("auth id ............: {:#018x}\n", m_self_id_header->authid); + auto program_type = magic_enum::enum_cast(m_self_id_header->program_type); + if (program_type.has_value()) + { + spdlog::info("program type .......: {}\n", magic_enum::enum_name(program_type.value())); + } + else + { + spdlog::info("program type UNK....: {:#018x}\n", (int)m_self_id_header->program_type); + } + spdlog::info("app version ........: {:#018x}\n", m_self_id_header->appver); + spdlog::info("fw version .........: {:#018x}\n", m_self_id_header->firmver); + spdlog::info("digest..............: 0x"); + for (int i = 0; i < 32; i++) spdlog::info("{:02x}", m_self_id_header->digest[i]); + spdlog::info("\n"); + } +} \ No newline at end of file diff --git a/src/Loader/Elf.h b/src/Loader/Elf.h new file mode 100644 index 00000000..dfc8636f --- /dev/null +++ b/src/Loader/Elf.h @@ -0,0 +1,308 @@ +#pragma once +#include +#include +#include "../types.h" +#include "../Core/FsFile.h" + +struct self_header +{ + static const u32 signature = 0x1D3D154Fu; + + u32 magic; + u08 version; + u08 mode; + u08 endian;// 1 is little endian + u08 attributes; + u08 category; + u08 program_type; + u16 padding1; + u16 header_size; + u16 meta_size; + u32 file_size; + u32 padding2; + u16 segment_count; + u16 unknown1A; //always 0x22 + u32 padding3; +}; + +struct self_segment_header +{ + u64 flags; + u64 file_offset; + u64 file_size; + u64 memory_size; +}; + + +constexpr u08 EI_MAG0 = 0;/* e_ident[] indexes */ +constexpr u08 EI_MAG1 = 1; +constexpr u08 EI_MAG2 = 2; +constexpr u08 EI_MAG3 = 3; +constexpr u08 EI_CLASS = 4; +constexpr u08 EI_DATA = 5; +constexpr u08 EI_VERSION = 6; +constexpr u08 EI_OSABI = 7; +constexpr u08 EI_ABIVERSION = 8; + +// Magic number +constexpr u08 ELFMAG0 = 0x7F; +constexpr u08 ELFMAG1 = 'E'; +constexpr u08 ELFMAG2 = 'L'; +constexpr u08 ELFMAG3 = 'F'; + +typedef enum : u16 { + ET_NONE = 0x0, + ET_REL = 0x1, + ET_EXEC = 0x2, + ET_DYN = 0x3, + ET_CORE = 0x4, + ET_SCE_EXEC = 0xfe00, + ET_SCE_STUBLIB = 0xfe0c, + ET_SCE_DYNEXEC = 0xfe10, + ET_SCE_DYNAMIC = 0xfe18 +} e_type_s; + +typedef enum : u16 { + EM_NONE = 0, /* No machine */ + EM_M32 = 1, /* AT&T WE 32100 */ + EM_SPARC = 2, /* SPARC */ + EM_386 = 3, /* Intel 80386 */ + EM_68K = 4, /* Motorola 68000 */ + EM_88K = 5, /* Motorola 88000 */ + EM_860 = 7, /* Intel 80860 */ + EM_MIPS = 8, /* MIPS I Architecture */ + EM_S370 = 9, /* IBM System/370 Processor */ + EM_MIPS_RS3_LE = 10, /* MIPS RS3000 Little-endian */ + EM_PARISC = 15, /* Hewlett-Packard PA-RISC */ + EM_VPP500 = 17, /* Fujitsu VPP500 */ + EM_SPARC32PLUS = 18, /* Enhanced instruction set SPARC */ + EM_960 = 19, /* Intel 80960 */ + EM_PPC = 20, /* PowerPC */ + EM_PPC64 = 21, /* 64-bit PowerPC */ + EM_S390 = 22, /* IBM System/390 Processor */ + EM_V800 = 36, /* NEC V800 */ + EM_FR20 = 37, /* Fujitsu FR20 */ + EM_RH32 = 38, /* TRW RH-32 */ + EM_RCE = 39, /* Motorola RCE */ + EM_ARM = 40, /* Advanced RISC Machines ARM */ + EM_ALPHA = 41, /* Digital Alpha */ + EM_SH = 42, /* Hitachi SH */ + EM_SPARCV9 = 43, /* SPARC Version 9 */ + EM_TRICORE = 44, /* Siemens TriCore embedded processor */ + EM_ARC = 45, /* Argonaut RISC Core, Argonaut Technologies Inc. */ + EM_H8_300 = 46, /* Hitachi H8/300 */ + EM_H8_300H = 47, /* Hitachi H8/300H */ + EM_H8S = 48, /* Hitachi H8S */ + EM_H8_500 = 49, /* Hitachi H8/500 */ + EM_IA_64 = 50, /* Intel IA-64 processor architecture */ + EM_MIPS_X = 51, /* Stanford MIPS-X */ + EM_COLDFIRE = 52, /* Motorola ColdFire */ + EM_68HC12 = 53, /* Motorola M68HC12 */ + EM_MMA = 54, /* Fujitsu MMA Multimedia Accelerator */ + EM_PCP = 55, /* Siemens PCP */ + EM_NCPU = 56, /* Sony nCPU embedded RISC processor */ + EM_NDR1 = 57, /* Denso NDR1 microprocessor */ + EM_STARCORE = 58, /* Motorola Star*Core processor */ + EM_ME16 = 59, /* Toyota ME16 processor */ + EM_ST100 = 60, /* STMicroelectronics ST100 processor */ + EM_TINYJ = 61, /* Advanced Logic Corp. TinyJ embedded processor family */ + EM_X86_64 = 62, /* AMD x86-64 architecture (PS4) */ + EM_PDSP = 63, /* Sony DSP Processor */ + EM_PDP10 = 64, /* Digital Equipment Corp. PDP-10 */ + EM_PDP11 = 65, /* Digital Equipment Corp. PDP-11 */ + EM_FX66 = 66, /* Siemens FX66 microcontroller */ + EM_ST9PLUS = 67, /* STMicroelectronics ST9+ 8/16 bit microcontroller */ + EM_ST7 = 68, /* STMicroelectronics ST7 8-bit microcontroller */ + EM_68HC16 = 69, /* Motorola MC68HC16 Microcontroller */ + EM_68HC11 = 70, /* Motorola MC68HC11 Microcontroller */ + EM_68HC08 = 71, /* Motorola MC68HC08 Microcontroller */ + EM_68HC05 = 72, /* Motorola MC68HC05 Microcontroller */ + EM_SVX = 73, /* Silicon Graphics SVx */ + EM_ST19 = 75, /* Digital VAX */ + EM_CRIS = 76, /* Axis Communications 32-bit embedded processor */ + EM_JAVELIN = 77, /* Infineon Technologies 32-bit embedded processor */ + EM_FIREPATH = 78, /* Element 14 64-bit DSP Processor */ + EM_ZSP = 79, /* LSI Logic 16-bit DSP Processor */ + EM_MMIX = 80, /* Donald Knuth's educational 64-bit processor */ + EM_HUANY = 81, /* Harvard University machine-independent object files */ + EM_PRISM = 82, /* SiTera Prism */ + EM_AVR = 83, /* Atmel AVR 8-bit microcontroller */ + EM_FR30 = 84, /* Fujitsu FR30 */ + EM_D10V = 85, /* Mitsubishi D10V */ + EM_D30V = 86, /* Mitsubishi D30V */ + EM_V850 = 87, /* NEC v850 */ + EM_M32R = 88, /* Mitsubishi M32R */ + EM_MN10300 = 89, /* Matsushita MN10300 */ + EM_MN10200 = 90, /* Matsushita MN10200 */ + EM_PJ = 91, /* PicoJava */ + EM_OPENRISC = 92, /* OpenRISC 32-bit embedded processor */ + EM_ARC_A5 = 93, /* ARC Cores Tangent-A5 */ + EM_XTENSA = 94, /* Tensilica Xtensa Architecture */ + EM_VIDEOCORE = 95, /* Alphamosaic VideoCore processor */ + EM_TMM_GPP = 96, /* Thompson Multimedia General Purpose Processor */ + EM_NS32K = 97, /* National Semiconductor 32000 series */ + EM_TPC = 98, /* Tenor Network TPC processor */ + EM_SNP1K = 99, /* Trebia SNP 1000 processor */ + EM_ST200 = 100, /* STMicroelectronics (www.st.com) ST200 microcontroller */ + EM_IP2K = 101, /* Ubicom IP2xxx microcontroller family */ + EM_MAX = 102, /* MAX Processor */ + EM_CR = 103, /* National Semiconductor CompactRISC microprocessor */ + EM_F2MC16 = 104, /* Fujitsu F2MC16 */ + EM_MSP430 = 105, /* Texas Instruments embedded microcontroller msp430 */ + EM_BLACKFIN = 106, /* Analog Devices Blackfin (DSP) processor */ + EM_SE_C33 = 107, /* S1C33 Family of Seiko Epson processors */ + EM_SEP = 108, /* Sharp embedded microprocessor */ + EM_ARCA = 109, /* Arca RISC Microprocessor */ + EM_UNICORE = 110 /* Microprocessor series from PKU-Unity Ltd. and MPRC */ +} e_machine_es; + +typedef enum :u32 { + EV_NONE = 0x0, + EV_CURRENT = 0x1 +} e_version_es; + +typedef enum : u08 { + ELF_CLASS_NONE =0x0, + ELF_CLASS_32 =0x1, + ELF_CLASS_64 =0x2, + ELF_CLASS_NUM =0x3 +} ident_class_es; + +typedef enum : u08 { + ELF_DATA_NONE = 0x0, + ELF_DATA_2LSB = 0x1, + ELF_DATA_2MSB = 0x2, + ELF_DATA_NUM = 0x3 +} ident_endian_es; + +typedef enum :u08 { + 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 */ + ELF_OSABI_HPUX = 0x1, /* Hewlett-Packard HP-UX */ + ELF_OSABI_NETBSD = 0x2, /* NetBSD */ + ELF_OSABI_LINUX = 0x3, /* Linux */ + ELF_OSABI_SOLARIS = 0x6, /* Sun Solaris */ + ELF_OSABI_AIX = 0x7, /* AIX */ + ELF_OSABI_IRIX = 0x8, /* IRIX */ + ELF_OSABI_FREEBSD = 0x9, /* FreeBSD (PS4) */ + ELF_OSABI_TRU64 = 0xA, /* Compaq TRU64 UNIX */ + ELF_OSABI_MODESTO = 0xB, /* Novell Modesto */ + ELF_OSABI_OPENBSD = 0xC, /* Open BSD */ + ELF_OSABI_OPENVMS = 0xD, /* Open VMS */ + ELF_OSABI_NSK = 0xE, /* Hewlett-Packard Non-Stop Kernel */ + ELF_OSABI_AROS = 0xF, /* Amiga Research OS */ + ELF_OSABI_ARM_AEABI = 0x40, /* ARM EABI */ + ELF_OSABI_ARM = 0x61, /* ARM */ + ELF_OSABI_STANDALONE = 0xFF /* Standalone (embedded applications) */ +} ident_osabi_es; + +typedef enum :u08 { + ELF_ABI_VERSION_AMDGPU_HSA_V2=0x0, + ELF_ABI_VERSION_AMDGPU_HSA_V3=0x1, + ELF_ABI_VERSION_AMDGPU_HSA_V4=0x2, + ELF_ABI_VERSION_AMDGPU_HSA_V5=0x3 +} ident_abiversion_es; + +struct elf_ident { + u08 magic[4]; + ident_class_es ei_class; + ident_endian_es ei_data; + ident_version_es ei_version; + ident_osabi_es ei_osabi; + ident_abiversion_es ei_abiversion; + u08 pad[6]; +}; + +struct elf_header +{ + static const u32 signature = 0x7F454C46u; + + elf_ident e_ident; /* ELF identification */ + e_type_s e_type; /* Object file type */ + e_machine_es e_machine; /* Machine type */ + e_version_es e_version; /* Object file version */ + u64 e_entry; /* Entry point address */ + u64 e_phoff; /* Program header offset */ + u64 e_shoff; /* Section header offset */ + u32 e_flags; /* Processor-specific flags */ + u16 e_ehsize; /* ELF header size */ + u16 e_phentsize; /* Size of program header entry */ + u16 e_phnum; /* Number of program header entries */ + u16 e_shentsize; /* Size of section header entry */ + u16 e_shnum; /* Number of section header entries */ + u16 e_shstrndx; /* Section name string table index */ +}; + +struct elf_program_header +{ + u32 p_type; /* Type of segment */ + u32 p_flags; /* Segment attributes */ + u64 p_offset; /* Offset in file */ + u64 p_vaddr; /* Virtual address in memory */ + u64 p_paddr; /* Reserved */ + u64 p_filesz; /* Size of segment in file */ + u64 p_memsz; /* Size of segment in memory */ + u64 p_align; /* Alignment of segment */ +}; + +struct elf_section_header +{ + u32 sh_name; /* Section name */ + u32 sh_type; /* Section type */ + u64 sh_flags; /* Section attributes */ + u64 sh_addr; /* Virtual address in memory */ + u64 sh_offset; /* Offset in file */ + u64 sh_size; /* Size of section */ + u32 sh_link; /* Link to other section */ + u32 sh_info; /* Miscellaneous information */ + u64 sh_addralign; /* Address alignment boundary */ + u64 sh_entsize; /* Size of entries, if section has table */ +}; + +typedef enum :u64 { + PT_FAKE = 0x1, + PT_NPDRM_EXEC = 0x4, + PT_NPDRM_DYNLIB = 0x5, + PT_SYSTEM_EXEC = 0x8, + PT_SYSTEM_DYNLIB = 0x9, + PT_HOST_KERNEL = 0xC, + PT_SECURE_MODULE = 0xE, + PT_SECURE_KERNEL = 0xF +} program_type_es; + +struct elf_program_id_header +{ + u64 authid; + program_type_es program_type; + u64 appver; + u64 firmver; + u08 digest[32]; +}; +class Elf +{ +public: + Elf() = default; + virtual ~Elf(); + + void Open(const std::string & file_name); + bool isSelfFile() const; + bool isElfFile() const; + void DebugDump(); +private: + + void Reset(); + + FsFile* m_f = nullptr; + self_header* m_self = nullptr; + self_segment_header* m_self_segments = nullptr; + elf_header* m_elf_header = nullptr; + elf_program_header* m_elf_phdr = nullptr; + elf_section_header* m_elf_shdr = nullptr; + elf_program_id_header* m_self_id_header = nullptr; +}; + diff --git a/src/main.cpp b/src/main.cpp index b10a4921..5ee6568c 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -15,6 +15,8 @@ #endif #include "spdlog/spdlog.h" +#include "types.h" +#include "Loader/Elf.h" // This example can also compile and run with Emscripten! See 'Makefile.emscripten' for details. #ifdef __EMSCRIPTEN__ @@ -22,9 +24,12 @@ #endif // Main code -int main(int, char**) +int main(int argc, char* argv[]) { - spdlog::info("Welcome to spdlog!"); + const char* const path = argv[1]; //argument 1 is the path of self file to boot + Elf* elf = new Elf; + elf->Open(path); + // Setup SDL if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER | SDL_INIT_GAMEPAD) != 0) { diff --git a/src/types.h b/src/types.h new file mode 100644 index 00000000..64a05f85 --- /dev/null +++ b/src/types.h @@ -0,0 +1,14 @@ +#pragma once + +using s08 = char; +using s16 = short; +using s32 = int; +using s64 = long long; + +using u08 = unsigned char; +using u16 = unsigned short; +using u32 = unsigned int; +using u64 = unsigned long long; + +using f32 = float; +using f64 = double; \ No newline at end of file diff --git a/third-party/CMakeLists.txt b/third-party/CMakeLists.txt index 1d50afaf..f0d5d668 100644 --- a/third-party/CMakeLists.txt +++ b/third-party/CMakeLists.txt @@ -1,3 +1,7 @@ +set(CMAKE_CXX_STANDARD 20) +set(CMAKE_CXX_STANDARD_REQUIRED True) + + #====================FMT ==================== set(fmt_DIR ${CMAKE_CURRENT_SOURCE_DIR}/fmt) add_subdirectory(${fmt_DIR})