diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
index f8bc1fdd0..33ce8dc81 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 000000000..a265b9315
--- /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 <vector>
+
+#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<u8>& program_image,
+ const std::vector<Symbol>& 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<u8>& program_image, u32 dynamic_section_offset,
+ VAddr load_base) {
+ std::map<u64, u64> 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<Symbol> 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<char*>(&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 000000000..d18155f0d
--- /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 <map>
+#include <string>
+#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<u8>& program_image, const std::vector<Symbol>& symbols,
+ u64 relocation_offset, u64 size, bool is_jump_relocation,
+ VAddr load_base);
+ void Relocate(std::vector<u8>& program_image, u32 dynamic_section_offset, VAddr load_base);
+
+ void ResolveImports();
+
+ std::map<std::string, Import> imports;
+ std::map<std::string, VAddr> exports;
+};
+
+} // namespace Loader
diff --git a/src/core/loader/loader.cpp b/src/core/loader/loader.cpp
index d309e7c9e..d96b9f1f0 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<AppLoader> GetFileLoader(FileUtil::IOFile&& file, FileTyp
case FileType::NSO:
return std::make_unique<AppLoader_NSO>(std::move(file), filename, filepath);
+ // NX NRO file format.
+ case FileType::NRO:
+ return std::make_unique<AppLoader_NRO>(std::move(file), filename, filepath);
+
default:
return nullptr;
}
diff --git a/src/core/loader/loader.h b/src/core/loader/loader.h
index 79a3bd498..ac26f31fa 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 000000000..ed638e1fa
--- /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 <vector>
+
+#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<NroSegmentHeader, 3> 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<u8> ReadSegment(FileUtil::IOFile& file, const NroSegmentHeader& header) {
+ std::vector<u8> 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<u32>(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<Kernel::CodeSet> codeset = Kernel::CodeSet::Create("", 0);
+ std::vector<u8> 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<u32>(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::vector<u8>>(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 000000000..d145b68d5
--- /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 <map>
+#include <string>
+#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 0155dec82..4d885fef7 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<u8> ReadSegment(FileUtil::IOFile& file, const NsoSegmentHeade
return uncompressed_data;
}
-void AppLoader_NSO::WriteRelocations(const std::vector<Symbol>& 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<RelocationType>(info & 0xFFFFFFFF);
- u32 rsym = static_cast<u32>(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<u64, u64> 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<u8> strtab;
- strtab.resize(strtabsize);
- Memory::ReadBlock(load_base + dynamic[DT_STRTAB], strtab.data(), strtabsize);
-
- VAddr addr = load_base + dynamic[DT_SYMTAB];
- std::vector<Symbol> 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<char*>(&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<u32>(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<u32>(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::vector<u8>>(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 16b41b6dc..431b960b1 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<Symbol>& 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<std::string, Import> imports;
- std::map<std::string, VAddr> exports;
std::string filename;
std::string filepath;