mirror of
https://github.com/shadps4-emu/shadPS4.git
synced 2025-05-23 11:55:00 +00:00
core: Rework elf loader
This commit is contained in:
GPUCode
parent
fed14ad4ed
commit
ca564b928c
7 changed files with 514 additions and 503 deletions
|
|
@ -1,139 +1,188 @@
|
|||
#include "Elf.h"
|
||||
|
||||
#include <Util/log.h>
|
||||
#include <debug.h>
|
||||
#include <bit>
|
||||
#include <fmt/core.h>
|
||||
#include <spdlog/pattern_formatter.h>
|
||||
#include <spdlog/sinks/stdout_color_sinks.h>
|
||||
#include <spdlog/sinks/basic_file_sink.h>
|
||||
#include <spdlog/spdlog.h>
|
||||
|
||||
#include <magic_enum.hpp>
|
||||
#include <debug.h>
|
||||
#include "Elf.h"
|
||||
|
||||
#include "spdlog/sinks/basic_file_sink.h"
|
||||
#include "spdlog/spdlog.h"
|
||||
|
||||
constexpr bool debug_elf = true;
|
||||
|
||||
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;
|
||||
static std::string_view getProgramTypeName(program_type_es type) {
|
||||
switch (type) {
|
||||
case PT_FAKE:
|
||||
return "PT_FAKE";
|
||||
case PT_NPDRM_EXEC:
|
||||
return "PT_NPDRM_EXEC";
|
||||
case PT_NPDRM_DYNLIB:
|
||||
return "PT_NPDRM_DYNLIB";
|
||||
case PT_SYSTEM_EXEC:
|
||||
return "PT_SYSTEM_EXEC";
|
||||
case PT_SYSTEM_DYNLIB:
|
||||
return "PT_SYSTEM_DYNLIB";
|
||||
case PT_HOST_KERNEL:
|
||||
return "PT_HOST_KERNEL";
|
||||
case PT_SECURE_MODULE:
|
||||
return "PT_SECURE_MODULE";
|
||||
case PT_SECURE_KERNEL:
|
||||
return "PT_SECURE_KERNEL";
|
||||
default:
|
||||
return "INVALID";
|
||||
}
|
||||
|
||||
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;
|
||||
static std::string_view getIdentClassName(ident_class_es elf_class) {
|
||||
switch (elf_class) {
|
||||
case ELF_CLASS_NONE:
|
||||
return "ELF_CLASS_NONE";
|
||||
case ELF_CLASS_32:
|
||||
return "ELF_CLASS_32";
|
||||
case ELF_CLASS_64:
|
||||
return "ELF_CLASS_64";
|
||||
case ELF_CLASS_NUM:
|
||||
return "ELF_CLASS_NUM";
|
||||
default:
|
||||
return "INVALID";
|
||||
}
|
||||
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;
|
||||
static std::string_view getIdentEndianName(ident_endian_es endian) {
|
||||
switch (endian) {
|
||||
case ELF_DATA_NONE:
|
||||
return "ELF_DATA_NONE";
|
||||
case ELF_DATA_2LSB:
|
||||
return "ELF_DATA_2LSB";
|
||||
case ELF_DATA_2MSB:
|
||||
return "ELF_DATA_2MSB";
|
||||
case ELF_DATA_NUM:
|
||||
return "ELF_DATA_NUM";
|
||||
default:
|
||||
return "INVALID";
|
||||
}
|
||||
}
|
||||
|
||||
static std::string_view getIdentVersionName(ident_version_es version) {
|
||||
switch (version) {
|
||||
case ELF_VERSION_NONE:
|
||||
return "ELF_VERSION_NONE";
|
||||
case ELF_VERSION_CURRENT:
|
||||
return "ELF_VERSION_CURRENT";
|
||||
case ELF_VERSION_NUM:
|
||||
return "ELF_VERSION_NUM";
|
||||
default:
|
||||
return "INVALID";
|
||||
}
|
||||
}
|
||||
|
||||
static std::string_view getIdentOsabiName(ident_osabi_es osabi) {
|
||||
switch (osabi) {
|
||||
case ELF_OSABI_NONE:
|
||||
return "ELF_OSABI_NONE";
|
||||
case ELF_OSABI_HPUX:
|
||||
return "ELF_OSABI_HPUX";
|
||||
case ELF_OSABI_NETBSD:
|
||||
return "ELF_OSABI_NETBSD";
|
||||
case ELF_OSABI_LINUX:
|
||||
return "ELF_OSABI_LINUX";
|
||||
case ELF_OSABI_SOLARIS:
|
||||
return "ELF_OSABI_SOLARIS";
|
||||
case ELF_OSABI_AIX:
|
||||
return "ELF_OSABI_AIX";
|
||||
case ELF_OSABI_IRIX:
|
||||
return "ELF_OSABI_IRIX";
|
||||
case ELF_OSABI_FREEBSD:
|
||||
return "ELF_OSABI_FREEBSD";
|
||||
case ELF_OSABI_TRU64:
|
||||
return "ELF_OSABI_TRU64";
|
||||
case ELF_OSABI_MODESTO:
|
||||
return "ELF_OSABI_MODESTO";
|
||||
case ELF_OSABI_OPENBSD:
|
||||
return "ELF_OSABI_OPENBSD";
|
||||
case ELF_OSABI_OPENVMS:
|
||||
return "ELF_OSABI_OPENVMS";
|
||||
case ELF_OSABI_NSK:
|
||||
return "ELF_OSABI_NSK";
|
||||
case ELF_OSABI_AROS:
|
||||
return "ELF_OSABI_AROS";
|
||||
case ELF_OSABI_ARM_AEABI:
|
||||
return "ELF_OSABI_ARM_AEABI";
|
||||
case ELF_OSABI_ARM:
|
||||
return "ELF_OSABI_ARM";
|
||||
case ELF_OSABI_STANDALONE:
|
||||
return "ELF_OSABI_STANDALONE";
|
||||
default:
|
||||
return "INVALID";
|
||||
}
|
||||
}
|
||||
|
||||
static std::string_view getIdentAbiversionName(ident_abiversion_es version) {
|
||||
switch (version) {
|
||||
case ELF_ABI_VERSION_AMDGPU_HSA_V2:
|
||||
return "ELF_ABI_VERSION_AMDGPU_HSA_V2";
|
||||
case ELF_ABI_VERSION_AMDGPU_HSA_V3:
|
||||
return "ELF_ABI_VERSION_AMDGPU_HSA_V3";
|
||||
case ELF_ABI_VERSION_AMDGPU_HSA_V4:
|
||||
return "ELF_ABI_VERSION_AMDGPU_HSA_V4";
|
||||
case ELF_ABI_VERSION_AMDGPU_HSA_V5:
|
||||
return "ELF_ABI_VERSION_AMDGPU_HSA_V5";
|
||||
default:
|
||||
return "INVALID";
|
||||
}
|
||||
}
|
||||
|
||||
Elf::~Elf() {
|
||||
Reset();
|
||||
}
|
||||
|
||||
void Elf::Reset() {
|
||||
m_f.close();
|
||||
}
|
||||
|
||||
void Elf::Open(const std::string& file_name) {
|
||||
Reset(); // reset all variables
|
||||
Reset();
|
||||
|
||||
m_f = new FsFile;
|
||||
m_f->Open(file_name, fsOpenMode::fsRead);
|
||||
m_f.open(file_name, Common::FS::OpenMode::Read);
|
||||
m_f.read(m_self);
|
||||
|
||||
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
|
||||
if (is_self = isSelfFile(); !is_self) {
|
||||
m_f.seek(0, Common::FS::SeekMode::Set);
|
||||
} else {
|
||||
m_self_segments = load_self_segments(*m_f, m_self->segment_count);
|
||||
m_self_segments.resize(m_self.segment_count);
|
||||
m_f.read(m_self_segments);
|
||||
}
|
||||
|
||||
auto elfheader_pos = m_f->Tell(); // get the entry pos for elf file
|
||||
|
||||
m_elf_header = load_elf_header(*m_f);
|
||||
|
||||
const u64 elf_header_pos = m_f.tell();
|
||||
m_f.read(m_elf_header);
|
||||
if (!isElfFile()) {
|
||||
delete m_elf_header;
|
||||
m_elf_header = nullptr;
|
||||
return;
|
||||
}
|
||||
|
||||
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) {
|
||||
const auto load_headers = [this]<typename T>(std::vector<T>& out, u64 offset, u16 num) {
|
||||
if (!num) {
|
||||
return;
|
||||
}
|
||||
|
||||
out.resize(num);
|
||||
m_f.seek(offset, Common::FS::SeekMode::Set);
|
||||
m_f.read(out);
|
||||
};
|
||||
|
||||
load_headers(m_elf_phdr, elf_header_pos + m_elf_header.e_phoff, m_elf_header.e_phnum);
|
||||
load_headers(m_elf_shdr, elf_header_pos + m_elf_header.e_shoff, m_elf_header.e_shnum);
|
||||
|
||||
if (is_self) {
|
||||
u64 header_size = 0;
|
||||
header_size += sizeof(self_header);
|
||||
header_size += sizeof(self_segment_header) * m_self->segment_count;
|
||||
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 += 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
|
||||
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));
|
||||
if (m_elf_header.e_ehsize - header_size >= sizeof(elf_program_id_header)) {
|
||||
m_f.seek(header_size, Common::FS::SeekMode::Set);
|
||||
m_f.read(m_self_id_header);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -141,26 +190,19 @@ void Elf::Open(const std::string& file_name) {
|
|||
}
|
||||
|
||||
bool Elf::isSelfFile() const {
|
||||
if (m_f == nullptr) {
|
||||
if (m_self.magic != self_header::signature) [[unlikely]] {
|
||||
fmt::print("Not a SELF file. Magic file mismatched! current = {:#x} required = {:#x}\n",
|
||||
m_self.magic, self_header::signature);
|
||||
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);
|
||||
if (m_self.version != 0x00 || m_self.mode != 0x01 || m_self.endian != 0x01 || m_self.attributes != 0x12) [[unlikely]] {
|
||||
fmt::print("Unknown SELF file\n");
|
||||
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");
|
||||
if (m_self.category != 0x01 || m_self.program_type != 0x01) [[unlikely]] {
|
||||
fmt::print("Unknown SELF file\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -168,68 +210,60 @@ bool Elf::isSelfFile() const {
|
|||
}
|
||||
|
||||
bool Elf::isElfFile() const {
|
||||
if (m_f == nullptr) {
|
||||
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) {
|
||||
fmt::print("ERROR:Not an ELF file magic is wrong!\n");
|
||||
return false;
|
||||
}
|
||||
if (m_elf_header.e_ident.ei_class != ELF_CLASS_64) {
|
||||
fmt::print("ERROR:e_ident[EI_CLASS] expected 0x02 is ({:#x})\n", static_cast<u32>(m_elf_header.e_ident.ei_class));
|
||||
return false;
|
||||
}
|
||||
|
||||
if (m_elf_header == nullptr) {
|
||||
if (m_elf_header.e_ident.ei_data != ELF_DATA_2LSB) {
|
||||
fmt::print("ERROR:e_ident[EI_DATA] expected 0x01 is ({:#x})\n", static_cast<u32>(m_elf_header.e_ident.ei_data));
|
||||
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);
|
||||
if (m_elf_header.e_ident.ei_version != ELF_VERSION_CURRENT) {
|
||||
fmt::print("ERROR:e_ident[EI_VERSION] expected 0x01 is ({:#x})\n", static_cast<u32>(m_elf_header.e_ident.ei_version));
|
||||
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);
|
||||
if (m_elf_header.e_ident.ei_osabi != ELF_OSABI_FREEBSD) {
|
||||
fmt::print("ERROR:e_ident[EI_OSABI] expected 0x09 is ({:#x})\n", static_cast<u32>(m_elf_header.e_ident.ei_osabi));
|
||||
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);
|
||||
if (m_elf_header.e_ident.ei_abiversion != ELF_ABI_VERSION_AMDGPU_HSA_V2) {
|
||||
fmt::print("ERROR:e_ident[EI_ABIVERSION] expected 0x00 is ({:#x})\n", static_cast<u32>(m_elf_header.e_ident.ei_abiversion));
|
||||
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);
|
||||
if (m_elf_header.e_type != ET_SCE_DYNEXEC&& m_elf_header.e_type != ET_SCE_DYNAMIC && m_elf_header.e_type != ET_SCE_EXEC) {
|
||||
fmt::print("ERROR:e_type expected 0xFE10 OR 0xFE18 OR 0xfe00 is ({:#x})\n", static_cast<u32>(m_elf_header.e_type));
|
||||
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);
|
||||
if (m_elf_header.e_machine != EM_X86_64) {
|
||||
fmt::print("ERROR:e_machine expected 0x3E is ({:#x})\n", static_cast<u32>(m_elf_header.e_machine));
|
||||
return false;
|
||||
}
|
||||
|
||||
if (m_elf_header->e_type != ET_SCE_DYNEXEC&& m_elf_header->e_type != ET_SCE_DYNAMIC&& m_elf_header->e_type != ET_SCE_EXEC) {
|
||||
printf("ERROR:e_type expected 0xFE10 OR 0xFE18 OR 0xfe00 is (%04x)\n", m_elf_header->e_type);
|
||||
if (m_elf_header.e_version != EV_CURRENT) {
|
||||
fmt::print("ERROR:m_elf_header.e_version expected 0x01 is ({:#x})\n", static_cast<u32>(m_elf_header.e_version));
|
||||
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);
|
||||
if (m_elf_header.e_phentsize != sizeof(elf_program_header)) {
|
||||
fmt::print("ERROR:e_phentsize ({}) != sizeof(elf_program_header)\n", static_cast<u32>(m_elf_header.e_phentsize));
|
||||
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
|
||||
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);
|
||||
fmt::print("ERROR:e_shentsize ({}) != sizeof(elf_section_header)\n", m_elf_header.e_shentsize);
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -237,10 +271,10 @@ bool Elf::isElfFile() const {
|
|||
}
|
||||
|
||||
void Elf::DebugDump() {
|
||||
if (m_self != nullptr) { // if we load elf instead
|
||||
if (is_self) { // If we load elf instead
|
||||
spdlog::info(SElfHeaderStr());
|
||||
spdlog::info("\n");
|
||||
for (u16 i = 0; i < m_self->segment_count; i++) {
|
||||
for (u16 i = 0; i < m_self.segment_count; i++) {
|
||||
spdlog::info(SELFSegHeader(i));
|
||||
}
|
||||
spdlog::info("\n");
|
||||
|
|
@ -248,67 +282,65 @@ void Elf::DebugDump() {
|
|||
|
||||
spdlog::info(ElfHeaderStr());
|
||||
|
||||
if (m_elf_header->e_phentsize > 0) {
|
||||
if (m_elf_header.e_phentsize > 0) {
|
||||
spdlog::info("Program headers:\n");
|
||||
for (u16 i = 0; i < m_elf_header->e_phnum; i++) {
|
||||
for (u16 i = 0; i < m_elf_header.e_phnum; i++) {
|
||||
spdlog::info(ElfPHeaderStr(i));
|
||||
}
|
||||
}
|
||||
if (m_elf_header->e_shentsize > 0) {
|
||||
if (m_elf_header.e_shentsize > 0) {
|
||||
spdlog::info("Section headers:\n");
|
||||
for (u16 i = 0; i < m_elf_header->e_shnum; i++) {
|
||||
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);
|
||||
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) {
|
||||
|
||||
if (is_self) {
|
||||
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("auth id ............: {:#018x}\n", m_self_id_header.authid);
|
||||
spdlog::info("program type .......: {}\n", getProgramTypeName(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);
|
||||
std::string digest;
|
||||
for (int i = 0; i < 32; i++) digest += fmt::format("{:02X}", m_self_id_header->digest[i]);
|
||||
for (int i = 0; i < 32; i++) {
|
||||
digest += fmt::format("{:02X}", m_self_id_header.digest[i]);
|
||||
}
|
||||
spdlog::info("digest..............: 0x{}\n",digest);
|
||||
}
|
||||
}
|
||||
|
||||
std::string Elf::SElfHeaderStr() {
|
||||
std::string header = fmt::format("======= SELF HEADER =========\n", m_self->magic);
|
||||
header += fmt::format("magic ..............: 0x{:X}\n", m_self->magic);
|
||||
header += fmt::format("version ............: {}\n", m_self->version);
|
||||
header += fmt::format("mode ...............: {:#04x}\n", m_self->mode);
|
||||
header += fmt::format("endian .............: {}\n", m_self->endian);
|
||||
header += fmt::format("attributes .........: {:#04x}\n", m_self->attributes);
|
||||
header += fmt::format("category ...........: {:#04x}\n", m_self->category);
|
||||
header += fmt::format("program_type........: {:#04x}\n", m_self->program_type);
|
||||
header += fmt::format("padding1 ...........: {:#06x}\n", m_self->padding1);
|
||||
header += fmt::format("header size ........: {}\n", m_self->header_size);
|
||||
header += fmt::format("meta size ..........: {}\n", m_self->meta_size);
|
||||
header += fmt::format("file size ..........: {}\n", m_self->file_size);
|
||||
header += fmt::format("padding2 ...........: {:#010x}\n", m_self->padding2);
|
||||
header += fmt::format("segment count ......: {}\n", m_self->segment_count);
|
||||
header += fmt::format("unknown 1A .........: {:#06x}\n", m_self->unknown1A);
|
||||
header += fmt::format("padding3 ...........: {:#010x}\n", m_self->padding3);
|
||||
std::string header = fmt::format("======= SELF HEADER =========\n", m_self.magic);
|
||||
header += fmt::format("magic ..............: 0x{:X}\n", m_self.magic);
|
||||
header += fmt::format("version ............: {}\n", m_self.version);
|
||||
header += fmt::format("mode ...............: {:#04x}\n", m_self.mode);
|
||||
header += fmt::format("endian .............: {}\n", m_self.endian);
|
||||
header += fmt::format("attributes .........: {:#04x}\n", m_self.attributes);
|
||||
header += fmt::format("category ...........: {:#04x}\n", m_self.category);
|
||||
header += fmt::format("program_type........: {:#04x}\n", m_self.program_type);
|
||||
header += fmt::format("padding1 ...........: {:#06x}\n", m_self.padding1);
|
||||
header += fmt::format("header size ........: {}\n", m_self.header_size);
|
||||
header += fmt::format("meta size ..........: {}\n", m_self.meta_size);
|
||||
header += fmt::format("file size ..........: {}\n", m_self.file_size);
|
||||
header += fmt::format("padding2 ...........: {:#010x}\n", m_self.padding2);
|
||||
header += fmt::format("segment count ......: {}\n", m_self.segment_count);
|
||||
header += fmt::format("unknown 1A .........: {:#06x}\n", m_self.unknown1A);
|
||||
header += fmt::format("padding3 ...........: {:#010x}\n", m_self.padding3);
|
||||
return header;
|
||||
}
|
||||
|
||||
std::string Elf::SELFSegHeader(u16 no) {
|
||||
auto segment_header = m_self_segments[no];
|
||||
const auto segment_header = m_self_segments[no];
|
||||
std::string header = fmt::format("====== SEGMENT HEADER {} ========\n", no);
|
||||
header += fmt::format("flags ............: {:#018x}\n", segment_header.flags);
|
||||
header += fmt::format("file offset ......: {:#018x}\n", segment_header.file_offset);
|
||||
|
|
@ -320,65 +352,36 @@ std::string Elf::SELFSegHeader(u16 no) {
|
|||
std::string Elf::ElfHeaderStr() {
|
||||
std::string header = fmt::format("======= Elf header ===========\n");
|
||||
header += fmt::format("ident ............: 0x");
|
||||
for (auto i : m_elf_header->e_ident.magic) {
|
||||
for (auto i : m_elf_header.e_ident.magic) {
|
||||
header += fmt::format("{:02X}", i);
|
||||
}
|
||||
header += fmt::format("\n");
|
||||
|
||||
auto ident_class = magic_enum::enum_cast<ident_class_es>(m_elf_header->e_ident.ei_class);
|
||||
if (ident_class.has_value()) {
|
||||
header += fmt::format("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()) {
|
||||
header += fmt::format("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()) {
|
||||
header += fmt::format("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()) {
|
||||
header += fmt::format("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()) {
|
||||
header += fmt::format("ident abiversion..: {}\n", magic_enum::enum_name(ident_abiversion.value()));
|
||||
}
|
||||
header += fmt::format("ident class.......: {}\n", getIdentClassName(m_elf_header.e_ident.ei_class));
|
||||
header += fmt::format("ident data .......: {}\n", getIdentEndianName(m_elf_header.e_ident.ei_data));
|
||||
header += fmt::format("ident version.....: {}\n", getIdentVersionName(m_elf_header.e_ident.ei_version));
|
||||
header += fmt::format("ident osabi .....: {}\n", getIdentOsabiName(m_elf_header.e_ident.ei_osabi));
|
||||
header += fmt::format("ident abiversion..: {}\n", getIdentAbiversionName(m_elf_header.e_ident.ei_abiversion));
|
||||
|
||||
header += fmt::format("ident UNK ........: 0x");
|
||||
for (auto i : m_elf_header->e_ident.pad) {
|
||||
for (auto i : m_elf_header.e_ident.pad) {
|
||||
header += fmt::format("{:02X}", i);
|
||||
}
|
||||
header += fmt::format("\n");
|
||||
|
||||
auto type = magic_enum::enum_cast<e_type_s>(m_elf_header->e_type);
|
||||
if (type.has_value()) {
|
||||
header += fmt::format("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()) {
|
||||
header += fmt::format("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()) {
|
||||
header += fmt::format("version ..........: {}\n", magic_enum::enum_name(version.value()));
|
||||
}
|
||||
header += fmt::format("entry ............: {:#018x}\n", m_elf_header->e_entry);
|
||||
header += fmt::format("phoff ............: {:#018x}\n", m_elf_header->e_phoff);
|
||||
header += fmt::format("shoff ............: {:#018x}\n", m_elf_header->e_shoff);
|
||||
header += fmt::format("flags ............: {:#010x}\n", m_elf_header->e_flags);
|
||||
header += fmt::format("ehsize ...........: {}\n", m_elf_header->e_ehsize);
|
||||
header += fmt::format("phentsize ........: {}\n", m_elf_header->e_phentsize);
|
||||
header += fmt::format("phnum ............: {}\n", m_elf_header->e_phnum);
|
||||
header += fmt::format("shentsize ........: {}\n", m_elf_header->e_shentsize);
|
||||
header += fmt::format("shnum ............: {}\n", m_elf_header->e_shnum);
|
||||
header += fmt::format("shstrndx .........: {}\n", m_elf_header->e_shstrndx);
|
||||
header += fmt::format("type ............: {}\n", static_cast<u32>(m_elf_header.e_type));
|
||||
header += fmt::format("machine ..........: {}\n", static_cast<u32>(m_elf_header.e_machine));
|
||||
header += fmt::format("version ..........: {}\n", static_cast<u32>(m_elf_header.e_version));
|
||||
header += fmt::format("entry ............: {:#018x}\n", m_elf_header.e_entry);
|
||||
header += fmt::format("phoff ............: {:#018x}\n", m_elf_header.e_phoff);
|
||||
header += fmt::format("shoff ............: {:#018x}\n", m_elf_header.e_shoff);
|
||||
header += fmt::format("flags ............: {:#010x}\n", m_elf_header.e_flags);
|
||||
header += fmt::format("ehsize ...........: {}\n", m_elf_header.e_ehsize);
|
||||
header += fmt::format("phentsize ........: {}\n", m_elf_header.e_phentsize);
|
||||
header += fmt::format("phnum ............: {}\n", m_elf_header.e_phnum);
|
||||
header += fmt::format("shentsize ........: {}\n", m_elf_header.e_shentsize);
|
||||
header += fmt::format("shnum ............: {}\n", m_elf_header.e_shnum);
|
||||
header += fmt::format("shstrndx .........: {}\n", m_elf_header.e_shstrndx);
|
||||
return header;
|
||||
}
|
||||
|
||||
|
|
@ -418,45 +421,39 @@ std::string Elf::ElfPheaderFlagsStr(u32 flags) {
|
|||
|
||||
std::string Elf::ElfPHeaderStr(u16 no) {
|
||||
std::string header = fmt::format("====== PROGRAM HEADER {} ========\n", no);
|
||||
header += fmt::format("p_type ....: {}\n", ElfPheaderTypeStr((m_elf_phdr + no)->p_type));
|
||||
|
||||
auto flags = magic_enum::enum_cast<elf_program_flags>((m_elf_phdr + no)->p_flags);
|
||||
if (flags.has_value()) {
|
||||
header += fmt::format("p_flags ...: {}\n", magic_enum::enum_name(flags.value()));
|
||||
}
|
||||
// header += fmt::format("p_flags ...: {:#010x}\n", (m_elf_phdr + no)->p_flags);
|
||||
header += fmt::format("p_offset ..: {:#018x}\n", (m_elf_phdr + no)->p_offset);
|
||||
header += fmt::format("p_vaddr ...: {:#018x}\n", (m_elf_phdr + no)->p_vaddr);
|
||||
header += fmt::format("p_paddr ...: {:#018x}\n", (m_elf_phdr + no)->p_paddr);
|
||||
header += fmt::format("p_filesz ..: {:#018x}\n", (m_elf_phdr + no)->p_filesz);
|
||||
header += fmt::format("p_memsz ...: {:#018x}\n", (m_elf_phdr + no)->p_memsz);
|
||||
header += fmt::format("p_align ...: {:#018x}\n", (m_elf_phdr + no)->p_align);
|
||||
header += fmt::format("p_type ....: {}\n", ElfPheaderTypeStr(m_elf_phdr[no].p_type));
|
||||
header += fmt::format("p_flags ...: {:#010x}\n", static_cast<u32>(m_elf_phdr[no].p_flags));
|
||||
header += fmt::format("p_offset ..: {:#018x}\n", m_elf_phdr[no].p_offset);
|
||||
header += fmt::format("p_vaddr ...: {:#018x}\n", m_elf_phdr[no].p_vaddr);
|
||||
header += fmt::format("p_paddr ...: {:#018x}\n", m_elf_phdr[no].p_paddr);
|
||||
header += fmt::format("p_filesz ..: {:#018x}\n", m_elf_phdr[no].p_filesz);
|
||||
header += fmt::format("p_memsz ...: {:#018x}\n", m_elf_phdr[no].p_memsz);
|
||||
header += fmt::format("p_align ...: {:#018x}\n", m_elf_phdr[no].p_align);
|
||||
return header;
|
||||
}
|
||||
|
||||
void Elf::LoadSegment(u64 virtual_addr, u64 file_offset, u64 size) {
|
||||
if (m_self != nullptr) {
|
||||
for (uint16_t i = 0; i < m_self->segment_count; i++) {
|
||||
const auto& seg = m_self_segments[i];
|
||||
if (!is_self) {
|
||||
// It's elf file
|
||||
m_f.seek(file_offset, Common::FS::SeekMode::Set);
|
||||
m_f.read(reinterpret_cast<void*>(static_cast<uintptr_t>(virtual_addr)), size);
|
||||
return;
|
||||
}
|
||||
|
||||
if (seg.IsBlocked()) {
|
||||
auto phdr_id = seg.GetId();
|
||||
const auto& phdr = m_elf_phdr[phdr_id];
|
||||
for (uint16_t i = 0; i < m_self.segment_count; i++) {
|
||||
const auto& seg = m_self_segments[i];
|
||||
|
||||
if (file_offset >= phdr.p_offset && file_offset < phdr.p_offset + phdr.p_filesz) {
|
||||
auto offset = file_offset - phdr.p_offset;
|
||||
m_f->Seek(offset + seg.file_offset, fsSeekMode::fsSeekSet);
|
||||
m_f->Read(reinterpret_cast<void*>(static_cast<uintptr_t>(virtual_addr)), size);
|
||||
return;
|
||||
}
|
||||
if (seg.IsBlocked()) {
|
||||
auto phdr_id = seg.GetId();
|
||||
const auto& phdr = m_elf_phdr[phdr_id];
|
||||
|
||||
if (file_offset >= phdr.p_offset && file_offset < phdr.p_offset + phdr.p_filesz) {
|
||||
auto offset = file_offset - phdr.p_offset;
|
||||
m_f.seek(offset + seg.file_offset, Common::FS::SeekMode::Set);
|
||||
m_f.read(reinterpret_cast<void*>(static_cast<uintptr_t>(virtual_addr)), size);
|
||||
return;
|
||||
}
|
||||
}
|
||||
BREAKPOINT(); // hmm we didn't return something...
|
||||
} else {
|
||||
// it's elf file
|
||||
m_f->Seek(file_offset, fsSeekMode::fsSeekSet);
|
||||
m_f->Read(reinterpret_cast<void*>(static_cast<uintptr_t>(virtual_addr)), size);
|
||||
}
|
||||
BREAKPOINT(); // Hmm we didn't return something...
|
||||
}
|
||||
|
||||
u64 Elf::GetElfEntry() { return m_elf_header->e_entry; }
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue