diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt index f8bc1fdd0e..33ce8dc81c 100644 --- a/src/core/CMakeLists.txt +++ b/src/core/CMakeLists.txt @@ -174,8 +174,10 @@ set(SRCS hw/y2r.cpp loader/3dsx.cpp loader/elf.cpp + loader/linker.cpp loader/loader.cpp loader/ncch.cpp + loader/nro.cpp loader/nso.cpp loader/smdh.cpp tracer/recorder.cpp @@ -374,8 +376,10 @@ set(HEADERS hw/y2r.h loader/3dsx.h loader/elf.h + loader/linker.h loader/loader.h loader/ncch.h + loader/nro.h loader/nso.h loader/smdh.h tracer/recorder.h diff --git a/src/core/loader/linker.cpp b/src/core/loader/linker.cpp new file mode 100644 index 0000000000..a265b93154 --- /dev/null +++ b/src/core/loader/linker.cpp @@ -0,0 +1,151 @@ +// Copyright 2017 Citra Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#include + +#include "common/common_funcs.h" +#include "common/logging/log.h" +#include "common/swap.h" +#include "core/loader/linker.h" +#include "core/memory.h" + +namespace Loader { + +enum class RelocationType : u32 { ABS64 = 257, GLOB_DAT = 1025, JUMP_SLOT = 1026, RELATIVE = 1027 }; + +enum DynamicType : u32 { + DT_NULL = 0, + DT_PLTRELSZ = 2, + DT_STRTAB = 5, + DT_SYMTAB = 6, + DT_RELA = 7, + DT_RELASZ = 8, + DT_STRSZ = 10, + DT_JMPREL = 23, +}; + +struct Elf64_Rela { + u64_le offset; + RelocationType type; + u32_le symbol; + s64_le addend; +}; +static_assert(sizeof(Elf64_Rela) == 0x18, "Elf64_Rela has incorrect size."); + +struct Elf64_Dyn { + u64_le tag; + u64_le value; +}; +static_assert(sizeof(Elf64_Dyn) == 0x10, "Elf64_Dyn has incorrect size."); + +struct Elf64_Sym { + u32_le name; + INSERT_PADDING_BYTES(0x2); + u16_le shndx; + u64_le value; + u64_le size; +}; +static_assert(sizeof(Elf64_Sym) == 0x18, "Elf64_Sym has incorrect size."); + +void Linker::WriteRelocations(std::vector& program_image, + const std::vector& symbols, u64 relocation_offset, + u64 size, bool is_jump_relocation, VAddr load_base) { + for (u64 i = 0; i < size; i += sizeof(Elf64_Rela)) { + Elf64_Rela rela; + std::memcpy(&rela, &program_image[relocation_offset + i], sizeof(Elf64_Rela)); + + const Symbol& symbol = symbols[rela.symbol]; + switch (rela.type) { + case RelocationType::RELATIVE: { + const u64 value = load_base + rela.addend; + if (!symbol.name.empty()) { + exports[symbol.name] = value; + } + std::memcpy(&program_image[rela.offset], &value, sizeof(u64)); + break; + } + case RelocationType::JUMP_SLOT: + case RelocationType::GLOB_DAT: + if (!symbol.value) { + imports[symbol.name] = {rela.offset + load_base, 0}; + } else { + exports[symbol.name] = symbol.value; + std::memcpy(&program_image[rela.offset], &symbol.value, sizeof(u64)); + } + break; + case RelocationType::ABS64: + if (!symbol.value) { + imports[symbol.name] = {rela.offset + load_base, rela.addend}; + } else { + const u64 value = symbol.value + rela.addend; + exports[symbol.name] = value; + std::memcpy(&program_image[rela.offset], &value, sizeof(u64)); + } + break; + default: + LOG_CRITICAL(Loader, "Unknown relocation type: %d", rela.type); + break; + } + } +} + +void Linker::Relocate(std::vector& program_image, u32 dynamic_section_offset, + VAddr load_base) { + std::map dynamic; + while (dynamic_section_offset < program_image.size()) { + Elf64_Dyn dyn; + std::memcpy(&dyn, &program_image[dynamic_section_offset], sizeof(Elf64_Dyn)); + dynamic_section_offset += sizeof(Elf64_Dyn); + + if (dyn.tag == DT_NULL) { + break; + } + dynamic[dyn.tag] = dyn.value; + } + + u64 offset = dynamic[DT_SYMTAB]; + std::vector symbols; + while (offset < program_image.size()) { + Elf64_Sym sym; + std::memcpy(&sym, &program_image[offset], sizeof(Elf64_Sym)); + offset += sizeof(Elf64_Sym); + + if (sym.name >= dynamic[DT_STRSZ]) { + break; + } + + std::string name = reinterpret_cast(&program_image[dynamic[DT_STRTAB] + sym.name]); + if (sym.value) { + exports[name] = load_base + sym.value; + symbols.emplace_back(std::move(name), load_base + sym.value); + } else { + symbols.emplace_back(std::move(name), 0); + } + } + + if (dynamic.find(DT_RELA) != dynamic.end()) { + WriteRelocations(program_image, symbols, dynamic[DT_RELA], dynamic[DT_RELASZ], false, + load_base); + } + + if (dynamic.find(DT_JMPREL) != dynamic.end()) { + WriteRelocations(program_image, symbols, dynamic[DT_JMPREL], dynamic[DT_PLTRELSZ], true, + load_base); + } +} + +void Linker::ResolveImports() { + // Resolve imports + for (const auto& import : imports) { + const auto& search = exports.find(import.first); + if (search != exports.end()) { + Memory::Write64(import.second.ea, search->second + import.second.addend); + } + else { + LOG_ERROR(Loader, "Unresolved import: %s", import.first.c_str()); + } + } +} + +} // namespace Loader diff --git a/src/core/loader/linker.h b/src/core/loader/linker.h new file mode 100644 index 0000000000..d18155f0d9 --- /dev/null +++ b/src/core/loader/linker.h @@ -0,0 +1,37 @@ +// Copyright 2017 Citra Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#pragma once + +#include +#include +#include "common/common_types.h" + +namespace Loader { + +class Linker { +protected: + struct Symbol { + Symbol(std::string&& name, u64 value) : name(std::move(name)), value(value) {} + std::string name; + u64 value; + }; + + struct Import { + VAddr ea; + s64 addend; + }; + + void WriteRelocations(std::vector& program_image, const std::vector& symbols, + u64 relocation_offset, u64 size, bool is_jump_relocation, + VAddr load_base); + void Relocate(std::vector& program_image, u32 dynamic_section_offset, VAddr load_base); + + void ResolveImports(); + + std::map imports; + std::map exports; +}; + +} // namespace Loader diff --git a/src/core/loader/loader.cpp b/src/core/loader/loader.cpp index d309e7c9ef..d96b9f1f06 100644 --- a/src/core/loader/loader.cpp +++ b/src/core/loader/loader.cpp @@ -10,6 +10,7 @@ #include "core/loader/3dsx.h" #include "core/loader/elf.h" #include "core/loader/ncch.h" +#include "core/loader/nro.h" #include "core/loader/nso.h" //////////////////////////////////////////////////////////////////////////////////////////////////// @@ -34,6 +35,7 @@ FileType IdentifyFile(FileUtil::IOFile& file) { CHECK_TYPE(ELF) CHECK_TYPE(NCCH) CHECK_TYPE(NSO) + CHECK_TYPE(NRO) #undef CHECK_TYPE @@ -121,6 +123,10 @@ static std::unique_ptr GetFileLoader(FileUtil::IOFile&& file, FileTyp case FileType::NSO: return std::make_unique(std::move(file), filename, filepath); + // NX NRO file format. + case FileType::NRO: + return std::make_unique(std::move(file), filename, filepath); + default: return nullptr; } diff --git a/src/core/loader/loader.h b/src/core/loader/loader.h index 79a3bd498d..ac26f31fa9 100644 --- a/src/core/loader/loader.h +++ b/src/core/loader/loader.h @@ -33,6 +33,7 @@ enum class FileType { ELF, THREEDSX, // 3DSX NSO, + NRO, }; /** diff --git a/src/core/loader/nro.cpp b/src/core/loader/nro.cpp new file mode 100644 index 0000000000..ed638e1fac --- /dev/null +++ b/src/core/loader/nro.cpp @@ -0,0 +1,173 @@ +// Copyright 2017 Citra Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#include + +#include "common/logging/log.h" +#include "common/swap.h" +#include "core/hle/kernel/process.h" +#include "core/hle/kernel/resource_limit.h" +#include "core/loader/nro.h" +#include "core/memory.h" + +namespace Loader { + +struct NroSegmentHeader { + u32_le offset; + u32_le size; +}; +static_assert(sizeof(NroSegmentHeader) == 0x8, "NroSegmentHeader has incorrect size."); + +struct NroHeader { + INSERT_PADDING_BYTES(0x4); + u32_le module_header_offset; + INSERT_PADDING_BYTES(0x8); + u32_le magic; + INSERT_PADDING_BYTES(0x4); + u32_le file_size; + INSERT_PADDING_BYTES(0x4); + std::array segments; // Text, RoData, Data (in that order) + u32_le bss_size; + INSERT_PADDING_BYTES(0x44); +}; +static_assert(sizeof(NroHeader) == 0x80, "NroHeader has incorrect size."); + +struct ModHeader { + u32_le magic; + u32_le dynamic_offset; + u32_le bss_start_offset; + u32_le bss_end_offset; + u32_le unwind_start_offset; + u32_le unwind_end_offset; + u32_le module_offset; // Offset to runtime-generated module object. typically equal to .bss base +}; +static_assert(sizeof(ModHeader) == 0x1c, "ModHeader has incorrect size."); + +FileType AppLoader_NRO::IdentifyType(FileUtil::IOFile& file) { + // Read NSO header + NroHeader nro_header{}; + file.Seek(0, SEEK_SET); + if (sizeof(NroHeader) != file.ReadBytes(&nro_header, sizeof(NroHeader))) { + return FileType::Error; + } + if (nro_header.magic == MakeMagic('N', 'R', 'O', '0')) { + return FileType::NRO; + } + return FileType::Error; +} + +static constexpr u32 PageAlignSize(u32 size) { + return (size + Memory::PAGE_MASK) & ~Memory::PAGE_MASK; +} + +static std::vector ReadSegment(FileUtil::IOFile& file, const NroSegmentHeader& header) { + std::vector data; + data.resize(header.size); + + file.Seek(header.offset + sizeof(NroHeader), SEEK_SET); + size_t bytes_read{file.ReadBytes(data.data(), header.size)}; + if (header.size != PageAlignSize(static_cast(bytes_read))) { + LOG_CRITICAL(Loader, "Failed to read NRO segment bytes", header.size); + return {}; + } + + return data; +} + +VAddr AppLoader_NRO::GetEntryPoint(VAddr load_base) const { + // Find nnMain function, set entrypoint to that address + const auto& search = exports.find("nnMain"); + if (search != exports.end()) { + return load_base + search->second; + } + const VAddr entry_point{load_base + sizeof(NroHeader)}; + LOG_ERROR(Loader, "Unable to find entrypoint, defaulting to: 0x%llx", entry_point); + return entry_point; +} + +bool AppLoader_NRO::LoadNro(const std::string& path, VAddr load_base) { + FileUtil::IOFile file(path, "rb"); + if (!file.IsOpen()) { + return {}; + } + + // Read NSO header + NroHeader nro_header{}; + file.Seek(0, SEEK_SET); + if (sizeof(NroHeader) != file.ReadBytes(&nro_header, sizeof(NroHeader))) { + return {}; + } + if (nro_header.magic != MakeMagic('N', 'R', 'O', '0')) { + return {}; + } + + // Build program image + Kernel::SharedPtr codeset = Kernel::CodeSet::Create("", 0); + std::vector program_image; + program_image.resize(PageAlignSize(nro_header.file_size + nro_header.bss_size)); + file.Seek(0, SEEK_SET); + file.ReadBytes(program_image.data(), nro_header.file_size); + + for (int i = 0; i < nro_header.segments.size(); ++i) { + codeset->segments[i].addr = nro_header.segments[i].offset; + codeset->segments[i].offset = nro_header.segments[i].offset; + codeset->segments[i].size = PageAlignSize(nro_header.segments[i].size); + } + + // Read MOD header + ModHeader mod_header{}; + u32 bss_size{Memory::PAGE_SIZE}; // Default .bss to page size if MOD0 section doesn't exist + std::memcpy(&mod_header, program_image.data() + nro_header.module_header_offset, + sizeof(ModHeader)); + const bool has_mod_header{mod_header.magic == MakeMagic('M', 'O', 'D', '0')}; + if (has_mod_header) { + // Resize program image to include .bss section and page align each section + bss_size = PageAlignSize(mod_header.bss_end_offset - mod_header.bss_start_offset); + codeset->data.size += bss_size; + } + program_image.resize(PageAlignSize(static_cast(program_image.size()) + bss_size)); + + // Relocate symbols if there was a proper MOD header - This must happen after the image has been + // loaded into memory + if (has_mod_header) { + Relocate(program_image, nro_header.module_header_offset + mod_header.dynamic_offset, + load_base); + } + + // Load codeset for current process + codeset->name = path; + codeset->memory = std::make_shared>(std::move(program_image)); + Kernel::g_current_process->LoadModule(codeset, load_base); + + return true; +} + +ResultStatus AppLoader_NRO::Load() { + if (is_loaded) { + return ResultStatus::ErrorAlreadyLoaded; + } + if (!file.IsOpen()) { + return ResultStatus::Error; + } + + // Load and relocate "main" and "sdk" NSO + static constexpr VAddr main_base{0x10000000}; + Kernel::g_current_process = Kernel::Process::Create("main"); + if (!LoadNro(filepath, main_base)) { + return ResultStatus::ErrorInvalidFormat; + } + + Kernel::g_current_process->svc_access_mask.set(); + Kernel::g_current_process->address_mappings = default_address_mappings; + Kernel::g_current_process->resource_limit = + Kernel::ResourceLimit::GetForCategory(Kernel::ResourceLimitCategory::APPLICATION); + Kernel::g_current_process->Run(GetEntryPoint(main_base), 48, Kernel::DEFAULT_STACK_SIZE); + + ResolveImports(); + + is_loaded = true; + return ResultStatus::Success; +} + +} // namespace Loader diff --git a/src/core/loader/nro.h b/src/core/loader/nro.h new file mode 100644 index 0000000000..d145b68d57 --- /dev/null +++ b/src/core/loader/nro.h @@ -0,0 +1,45 @@ +// Copyright 2017 Citra Emulator Project +// Licensed under GPLv2 or any later version +// Refer to the license.txt file included. + +#pragma once + +#include +#include +#include "common/common_types.h" +#include "common/file_util.h" +#include "core/hle/kernel/kernel.h" +#include "core/loader/linker.h" +#include "core/loader/loader.h" + +namespace Loader { + +/// Loads an NRO file +class AppLoader_NRO final : public AppLoader, Linker { +public: + AppLoader_NRO(FileUtil::IOFile&& file, std::string filename, std::string filepath) + : AppLoader(std::move(file)), filename(std::move(filename)), filepath(std::move(filepath)) { + } + + /** + * Returns the type of the file + * @param file FileUtil::IOFile open file + * @return FileType found, or FileType::Error if this loader doesn't know it + */ + static FileType IdentifyType(FileUtil::IOFile& file); + + FileType GetFileType() override { + return IdentifyType(file); + } + + ResultStatus Load() override; + +private: + VAddr GetEntryPoint(VAddr load_base) const; + bool LoadNro(const std::string& path, VAddr load_base); + + std::string filename; + std::string filepath; +}; + +} // namespace Loader diff --git a/src/core/loader/nso.cpp b/src/core/loader/nso.cpp index 0155dec824..4d885fef72 100644 --- a/src/core/loader/nso.cpp +++ b/src/core/loader/nso.cpp @@ -14,19 +14,6 @@ namespace Loader { -enum class RelocationType : u32 { ABS64 = 257, GLOB_DAT = 1025, JUMP_SLOT = 1026, RELATIVE = 1027 }; - -enum DynamicType : u32 { - DT_NULL = 0, - DT_PLTRELSZ = 2, - DT_STRTAB = 5, - DT_SYMTAB = 6, - DT_RELA = 7, - DT_RELASZ = 8, - DT_STRSZ = 10, - DT_JMPREL = 23, -}; - struct NsoSegmentHeader { u32_le offset; u32_le location; @@ -46,8 +33,6 @@ struct NsoHeader { static_assert(sizeof(NsoHeader) == 0x6c, "NsoHeader has incorrect size."); struct ModHeader { - INSERT_PADDING_BYTES(0x4); - u32_le offset_to_start; // Always 8 u32_le magic; u32_le dynamic_offset; u32_le bss_start_offset; @@ -56,7 +41,7 @@ struct ModHeader { u32_le eh_frame_hdr_end_offset; u32_le module_offset; // Offset to runtime-generated module object. typically equal to .bss base }; -static_assert(sizeof(ModHeader) == 0x24, "ModHeader has incorrect size."); +static_assert(sizeof(ModHeader) == 0x1c, "ModHeader has incorrect size."); FileType AppLoader_NSO::IdentifyType(FileUtil::IOFile& file) { u32 magic = 0; @@ -95,101 +80,6 @@ static std::vector ReadSegment(FileUtil::IOFile& file, const NsoSegmentHeade return uncompressed_data; } -void AppLoader_NSO::WriteRelocations(const std::vector& symbols, VAddr load_base, - u64 relocation_offset, u64 size, bool is_jump_relocation) { - for (u64 i = 0; i < size; i += 0x18) { - VAddr addr = load_base + relocation_offset + i; - u64 offset = Memory::Read64(addr); - u64 info = Memory::Read64(addr + 8); - u64 addend_unsigned = Memory::Read64(addr + 16); - s64 addend{}; - std::memcpy(&addend, &addend_unsigned, sizeof(u64)); - - RelocationType rtype = static_cast(info & 0xFFFFFFFF); - u32 rsym = static_cast(info >> 32); - VAddr ea = load_base + offset; - - const Symbol& symbol = symbols[rsym]; - - switch (rtype) { - case RelocationType::RELATIVE: - if (!symbol.name.empty()) { - exports[symbol.name] = load_base + addend; - } - Memory::Write64(ea, load_base + addend); - break; - case RelocationType::JUMP_SLOT: - case RelocationType::GLOB_DAT: - if (!symbol.value) { - imports[symbol.name] = {ea, 0}; - } else { - exports[symbol.name] = symbol.value; - Memory::Write64(ea, symbol.value); - } - break; - case RelocationType::ABS64: - if (!symbol.value) { - imports[symbol.name] = {ea, addend}; - } else { - exports[symbol.name] = symbol.value + addend; - Memory::Write64(ea, symbol.value + addend); - } - break; - default: - LOG_CRITICAL(Loader, "Unknown relocation type: %d", rtype); - break; - } - } -} - -void AppLoader_NSO::Relocate(VAddr load_base, VAddr dynamic_section_addr) { - std::map dynamic; - while (1) { - u64 tag = Memory::Read64(dynamic_section_addr); - u64 value = Memory::Read64(dynamic_section_addr + 8); - dynamic_section_addr += 16; - - if (tag == DT_NULL) { - break; - } - dynamic[tag] = value; - } - - u64 strtabsize = dynamic[DT_STRSZ]; - std::vector strtab; - strtab.resize(strtabsize); - Memory::ReadBlock(load_base + dynamic[DT_STRTAB], strtab.data(), strtabsize); - - VAddr addr = load_base + dynamic[DT_SYMTAB]; - std::vector symbols; - while (1) { - const u32 stname = Memory::Read32(addr); - const u16 stshndx = Memory::Read16(addr + 6); - const u64 stvalue = Memory::Read64(addr + 8); - addr += 24; - - if (stname >= strtabsize) { - break; - } - - std::string name = reinterpret_cast(&strtab[stname]); - if (stvalue) { - exports[name] = load_base + stvalue; - symbols.emplace_back(std::move(name), load_base + stvalue); - } else { - symbols.emplace_back(std::move(name), 0); - } - } - - if (dynamic.find(DT_RELA) != dynamic.end()) { - WriteRelocations(symbols, load_base, dynamic[DT_RELA], dynamic[DT_RELASZ], false); - } - - if (dynamic.find(DT_JMPREL) != dynamic.end()) { - WriteRelocations(symbols, load_base, dynamic[DT_JMPREL], dynamic[DT_PLTRELSZ], true); - } -} - VAddr AppLoader_NSO::GetEntryPoint(VAddr load_base) const { // Find nnMain function, set entrypoint to that address const auto& search = exports.find("nnMain"); @@ -233,10 +123,14 @@ bool AppLoader_NSO::LoadNso(const std::string& path, VAddr load_base) { codeset->segments[i].size = PageAlignSize(static_cast(data.size())); } + // MOD header pointer is at .text offset + 4 + u32 module_offset; + std::memcpy(&module_offset, program_image.data() + 4, sizeof(u32)); + // Read MOD header ModHeader mod_header{}; u32 bss_size{Memory::PAGE_SIZE}; // Default .bss to page size if MOD0 section doesn't exist - std::memcpy(&mod_header, program_image.data(), sizeof(ModHeader)); + std::memcpy(&mod_header, program_image.data() + module_offset, sizeof(ModHeader)); const bool has_mod_header{mod_header.magic == MakeMagic('M', 'O', 'D', '0')}; if (has_mod_header) { // Resize program image to include .bss section and page align each section @@ -245,16 +139,17 @@ bool AppLoader_NSO::LoadNso(const std::string& path, VAddr load_base) { } program_image.resize(PageAlignSize(static_cast(program_image.size()) + bss_size)); + // Relocate symbols if there was a proper MOD header - This must happen after the image has been + // loaded into memory + if (has_mod_header) { + Relocate(program_image, module_offset + mod_header.dynamic_offset, load_base); + } + // Load codeset for current process codeset->name = path; codeset->memory = std::make_shared>(std::move(program_image)); Kernel::g_current_process->LoadModule(codeset, load_base); - // Relocate symbols if there was a proper MOD header - This must happen after the image has been - // loaded into memory - if (has_mod_header) { - Relocate(load_base, load_base + mod_header.offset_to_start + mod_header.dynamic_offset); - } return true; } @@ -267,13 +162,13 @@ ResultStatus AppLoader_NSO::Load() { } // Load and relocate "main" and "sdk" NSO - static constexpr VAddr main_base{0x10000000}; + static constexpr VAddr main_base{0x710000000}; Kernel::g_current_process = Kernel::Process::Create("main"); if (!LoadNso(filepath, main_base)) { return ResultStatus::ErrorInvalidFormat; } const std::string sdkpath = filepath.substr(0, filepath.find_last_of("/\\")) + "/sdk"; - if (!LoadNso(sdkpath, 0x20000000)) { + if (!LoadNso(sdkpath, 0x720000000)) { LOG_WARNING(Loader, "failed to find SDK NSO"); } @@ -283,15 +178,7 @@ ResultStatus AppLoader_NSO::Load() { Kernel::ResourceLimit::GetForCategory(Kernel::ResourceLimitCategory::APPLICATION); Kernel::g_current_process->Run(GetEntryPoint(main_base), 48, Kernel::DEFAULT_STACK_SIZE); - // Resolve imports - for (const auto& import : imports) { - const auto& search = exports.find(import.first); - if (search != exports.end()) { - Memory::Write64(import.second.ea, search->second + import.second.addend); - } else { - LOG_ERROR(Loader, "Unresolved import: %s", import.first.c_str()); - } - } + ResolveImports(); is_loaded = true; return ResultStatus::Success; diff --git a/src/core/loader/nso.h b/src/core/loader/nso.h index 16b41b6dc6..431b960b1a 100644 --- a/src/core/loader/nso.h +++ b/src/core/loader/nso.h @@ -9,12 +9,13 @@ #include "common/common_types.h" #include "common/file_util.h" #include "core/hle/kernel/kernel.h" +#include "core/loader/linker.h" #include "core/loader/loader.h" namespace Loader { /// Loads an NSO file -class AppLoader_NSO final : public AppLoader { +class AppLoader_NSO final : public AppLoader, Linker { public: AppLoader_NSO(FileUtil::IOFile&& file, std::string filename, std::string filepath) : AppLoader(std::move(file)), filename(std::move(filename)), filepath(std::move(filepath)) { @@ -34,25 +35,8 @@ public: ResultStatus Load() override; private: - struct Symbol { - Symbol(std::string&& name, u64 value) : name(std::move(name)), value(value) {} - std::string name; - u64 value; - }; - - struct Import { - VAddr ea; - s64 addend; - }; - - void WriteRelocations(const std::vector& symbols, VAddr load_base, - u64 relocation_offset, u64 size, bool is_jump_relocation); VAddr GetEntryPoint(VAddr load_base) const; bool LoadNso(const std::string& path, VAddr load_base); - void Relocate(VAddr load_base, VAddr dynamic_section_addr); - - std::map imports; - std::map exports; std::string filename; std::string filepath;