we can now load elf and imgui.

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)

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;
+}
+

src/Core/FsFile.h

@@ -0,0 +1,63 @@
+#pragma once
+#include <cstdio>
+#include <string>
+#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;
+	}
+};
+

src/Loader/Elf.cpp

@@ -0,0 +1,432 @@
+#include "Elf.h"
+#include "spdlog/spdlog.h"
+#include "spdlog/sinks/basic_file_sink.h"
+#include <spdlog/sinks/stdout_color_sinks.h>
+#include <spdlog/pattern_formatter.h>
+#include <magic_enum.hpp>
+
+template <>
+struct magic_enum::customize::enum_range<e_type_s> {
+    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<spdlog::sink_ptr> sinks;
+    sinks.push_back(std::make_shared<spdlog::sinks::stdout_color_sink_mt>());
+    sinks.push_back(std::make_shared<spdlog::sinks::basic_file_sink_mt>(L"output.log", true)); //this might work only in windows ;/
+    spdlog::set_default_logger(std::make_shared<spdlog::logger>("shadps4 logger", begin(sinks), end(sinks)));   
+    auto f = std::make_unique<spdlog::pattern_formatter>("%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<ident_class_es>(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<ident_endian_es>(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<ident_version_es>(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<ident_osabi_es>(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<ident_abiversion_es>(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<e_type_s>(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<e_machine_es>(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<e_version_es>(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<program_type_es>(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");
+    }
+}

src/Loader/Elf.h

@@ -0,0 +1,308 @@
+#pragma once
+#include <string>
+#include <inttypes.h>
+#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;
+};
+

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)
     {

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;

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})