Merge pull request #22 from bunnei/loader-improvements

Refactor loader code and add preliminary NCCH support

src/citra/citra.cpp

@@ -8,7 +8,7 @@
 
 #include "core/system.h"
 #include "core/core.h"
-#include "core/loader.h"
+#include "core/loader/loader.h"
 
 #include "citra/emu_window/emu_window_glfw.h"
 
@@ -16,28 +16,21 @@
 
 /// Application entry point
 int __cdecl main(int argc, char **argv) {
-    std::string program_dir = File::GetCurrentDir();
-
     LogManager::Init();
 
-    EmuWindow_GLFW* emu_window = new EmuWindow_GLFW;
-
-    System::Init(emu_window);
-
-    std::string boot_filename;
-
     if (argc < 2) {
         ERROR_LOG(BOOT, "Failed to load ROM: No ROM specified");
+        return -1;
     }
-    else {
-        boot_filename = argv[1];
-    }
-    std::string error_str;
 
-    bool res = Loader::LoadFile(boot_filename, &error_str);
+    std::string boot_filename = argv[1];
+    EmuWindow_GLFW* emu_window = new EmuWindow_GLFW;
+
+    System::Init(emu_window);
 
-    if (!res) {
-        ERROR_LOG(BOOT, "Failed to load ROM: %s", error_str.c_str());
+    if (Loader::ResultStatus::Success != Loader::LoadFile(boot_filename)) {
+        ERROR_LOG(BOOT, "Failed to load ROM!");
+        return -1;
     }
 
     Core::RunLoop();

src/citra_qt/bootmanager.cpp

@@ -5,7 +5,7 @@
 #include "bootmanager.hxx"
 
 #include "core/core.h"
-#include "core/loader.h"
+#include "core/loader/loader.h"
 #include "core/hw/hw.h"
 
 #include "video_core/video_core.h"

src/citra_qt/main.cpp

@@ -23,9 +23,10 @@
 #include "debugger/graphics_cmdlists.hxx"
 
 #include "core/system.h"
-#include "core/loader.h"
 #include "core/core.h"
+#include "core/loader/loader.h"
 #include "core/arm/disassembler/load_symbol_map.h"
+
 #include "version.h"
 
 
@@ -134,11 +135,8 @@ void GMainWindow::BootGame(const char* filename)
 
     // Load a game or die...
     std::string boot_filename = filename;
-    std::string error_str;
-    bool res = Loader::LoadFile(boot_filename, &error_str);
-
-    if (!res) {
-        ERROR_LOG(BOOT, "Failed to load ROM: %s", error_str.c_str());
+    if (Loader::ResultStatus::Success != Loader::LoadFile(boot_filename)) {
+        ERROR_LOG(BOOT, "Failed to load ROM!");
     }
 
     disasmWidget->Init();

src/core/CMakeLists.txt

@@ -1,6 +1,8 @@
 set(SRCS    core.cpp
             core_timing.cpp
-            loader.cpp
+            loader/elf.cpp
+            loader/loader.cpp
+            loader/ncch.cpp
             mem_map.cpp
             mem_map_funcs.cpp
             system.cpp
@@ -27,7 +29,6 @@ set(SRCS    core.cpp
             arm/interpreter/mmu/tlb.cpp
             arm/interpreter/mmu/wb.cpp
             arm/interpreter/mmu/xscale_copro.cpp
-            elf/elf_reader.cpp
             file_sys/directory_file_system.cpp
             file_sys/meta_file_system.cpp
             hle/hle.cpp
@@ -50,7 +51,9 @@ set(SRCS    core.cpp
 
 set(HEADERS core.h
             core_timing.h
-            loader.h
+            loader/elf.h
+            loader/loader.h
+            loader/ncch.h
             mem_map.h
             system.h
             arm/disassembler/arm_disasm.h
@@ -72,8 +75,6 @@ set(HEADERS core.h
             arm/interpreter/vfp/asm_vfp.h
             arm/interpreter/vfp/vfp.h
             arm/interpreter/vfp/vfp_helper.h
-            elf/elf_reader.h
-            elf/elf_types.h
             file_sys/directory_file_system.h
             file_sys/file_sys.h
             file_sys/meta_file_system.h

src/core/core.vcxproj

@@ -162,7 +162,6 @@
     <ClCompile Include="arm\interpreter\vfp\vfpsingle.cpp" />
     <ClCompile Include="core.cpp" />
     <ClCompile Include="core_timing.cpp" />
-    <ClCompile Include="elf\elf_reader.cpp" />
     <ClCompile Include="file_sys\directory_file_system.cpp" />
     <ClCompile Include="file_sys\meta_file_system.cpp" />
     <ClCompile Include="hle\config_mem.cpp" />
@@ -182,7 +181,9 @@
     <ClCompile Include="hw\gpu.cpp" />
     <ClCompile Include="hw\hw.cpp" />
     <ClCompile Include="hw\ndma.cpp" />
-    <ClCompile Include="loader.cpp" />
+    <ClCompile Include="loader\elf.cpp" />
+    <ClCompile Include="loader\loader.cpp" />
+    <ClCompile Include="loader\ncch.cpp" />
     <ClCompile Include="mem_map.cpp" />
     <ClCompile Include="mem_map_funcs.cpp" />
     <ClCompile Include="system.cpp" />
@@ -210,8 +211,6 @@
     <ClInclude Include="arm\interpreter\vfp\vfp_helper.h" />
     <ClInclude Include="core.h" />
     <ClInclude Include="core_timing.h" />
-    <ClInclude Include="elf\elf_reader.h" />
-    <ClInclude Include="elf\elf_types.h" />
     <ClInclude Include="file_sys\directory_file_system.h" />
     <ClInclude Include="file_sys\file_sys.h" />
     <ClInclude Include="file_sys\meta_file_system.h" />
@@ -233,7 +232,9 @@
     <ClInclude Include="hw\gpu.h" />
     <ClInclude Include="hw\hw.h" />
     <ClInclude Include="hw\ndma.h" />
-    <ClInclude Include="loader.h" />
+    <ClInclude Include="loader\elf.h" />
+    <ClInclude Include="loader\loader.h" />
+    <ClInclude Include="loader\ncch.h" />
     <ClInclude Include="mem_map.h" />
     <ClInclude Include="system.h" />
   </ItemGroup>
@@ -243,4 +244,4 @@
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
   </ImportGroup>
-</Project>
+</Project>

src/core/core.vcxproj.filters

@@ -16,9 +16,6 @@
     <Filter Include="hw">
       <UniqueIdentifier>{d1158fc4-3e0f-431f-9d3b-f30bbfeb4ad5}</UniqueIdentifier>
     </Filter>
-    <Filter Include="elf">
-      <UniqueIdentifier>{7ae34319-6d72-4d12-bc62-9b438ba9241f}</UniqueIdentifier>
-    </Filter>
     <Filter Include="hle">
       <UniqueIdentifier>{8b62769e-3e2a-4a57-a7bc-b3b2933c2bc7}</UniqueIdentifier>
     </Filter>
@@ -34,6 +31,9 @@
     <Filter Include="hle\kernel">
       <UniqueIdentifier>{8089d94b-5faa-43dc-854b-ffd2fa2e7fe3}</UniqueIdentifier>
     </Filter>
+    <Filter Include="loader">
+      <UniqueIdentifier>{491d5558-5f3a-4283-8ba4-0a58b1984e37}</UniqueIdentifier>
+    </Filter>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="arm\disassembler\arm_disasm.cpp">
@@ -72,11 +72,7 @@
     <ClCompile Include="hw\hw.cpp">
       <Filter>hw</Filter>
     </ClCompile>
-    <ClCompile Include="elf\elf_reader.cpp">
-      <Filter>elf</Filter>
-    </ClCompile>
     <ClCompile Include="core.cpp" />
-    <ClCompile Include="loader.cpp" />
     <ClCompile Include="mem_map.cpp" />
     <ClCompile Include="mem_map_funcs.cpp" />
     <ClCompile Include="system.cpp" />
@@ -171,6 +167,15 @@
     <ClCompile Include="hle\service\ndm.cpp">
       <Filter>hle\service</Filter>
     </ClCompile>
+    <ClCompile Include="loader\loader.cpp">
+      <Filter>loader</Filter>
+    </ClCompile>
+    <ClCompile Include="loader\ncch.cpp">
+      <Filter>loader</Filter>
+    </ClCompile>
+    <ClCompile Include="loader\elf.cpp">
+      <Filter>loader</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="arm\disassembler\arm_disasm.h">
@@ -212,18 +217,11 @@
     <ClInclude Include="hw\hw.h">
       <Filter>hw</Filter>
     </ClInclude>
-    <ClInclude Include="elf\elf_reader.h">
-      <Filter>elf</Filter>
-    </ClInclude>
-    <ClInclude Include="elf\elf_types.h">
-      <Filter>elf</Filter>
-    </ClInclude>
     <ClInclude Include="arm\arm_interface.h">
       <Filter>arm</Filter>
     </ClInclude>
     <ClInclude Include="core.h" />
     <ClInclude Include="core_timing.h" />
-    <ClInclude Include="loader.h" />
     <ClInclude Include="mem_map.h" />
     <ClInclude Include="system.h" />
     <ClInclude Include="hle\hle.h">
@@ -307,8 +305,17 @@
     <ClInclude Include="hle\service\ndm.h">
       <Filter>hle\service</Filter>
     </ClInclude>
+    <ClInclude Include="loader\loader.h">
+      <Filter>loader</Filter>
+    </ClInclude>
+    <ClInclude Include="loader\ncch.h">
+      <Filter>loader</Filter>
+    </ClInclude>
+    <ClInclude Include="loader\elf.h">
+      <Filter>loader</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <Text Include="CMakeLists.txt" />
   </ItemGroup>
-</Project>
+</Project>

src/core/elf/elf_reader.cpp

@@ -1,190 +0,0 @@
-// Copyright 2013 Dolphin Emulator Project
-// Licensed under GPLv2
-// Refer to the license.txt file included.
-
-#include <string>
-
-#include "common/common.h"
-
-#include "common/symbols.h"
-#include "core/mem_map.h"
-#include "core/elf/elf_reader.h"
-
-//void bswap(Elf32_Word &w) {w = Common::swap32(w);}
-//void bswap(Elf32_Half &w) {w = Common::swap16(w);}
-
-#define bswap(w) w // Dirty bswap disable for now... 3DS is little endian, anyway
-
-static void byteswapHeader(Elf32_Ehdr &ELF_H)
-{
-	bswap(ELF_H.e_type);
-	bswap(ELF_H.e_machine);
-	bswap(ELF_H.e_ehsize);
-	bswap(ELF_H.e_phentsize);
-	bswap(ELF_H.e_phnum);
-	bswap(ELF_H.e_shentsize);
-	bswap(ELF_H.e_shnum);
-	bswap(ELF_H.e_shstrndx);
-	bswap(ELF_H.e_version);
-	bswap(ELF_H.e_entry);
-	bswap(ELF_H.e_phoff);
-	bswap(ELF_H.e_shoff);
-	bswap(ELF_H.e_flags);
-}
-
-static void byteswapSegment(Elf32_Phdr &sec)
-{
-	bswap(sec.p_align);
-	bswap(sec.p_filesz);
-	bswap(sec.p_flags);
-	bswap(sec.p_memsz);
-	bswap(sec.p_offset);
-	bswap(sec.p_paddr);
-	bswap(sec.p_vaddr);
-	bswap(sec.p_type);
-}
-
-static void byteswapSection(Elf32_Shdr &sec)
-{
-	bswap(sec.sh_addr);
-	bswap(sec.sh_addralign);
-	bswap(sec.sh_entsize);
-	bswap(sec.sh_flags);
-	bswap(sec.sh_info);
-	bswap(sec.sh_link);
-	bswap(sec.sh_name);
-	bswap(sec.sh_offset);
-	bswap(sec.sh_size);
-	bswap(sec.sh_type);
-}
-
-ElfReader::ElfReader(void *ptr)
-{
-	base = (char*)ptr;
-	base32 = (u32 *)ptr;
-	header = (Elf32_Ehdr*)ptr;
-	byteswapHeader(*header);
-
-	segments = (Elf32_Phdr *)(base + header->e_phoff);
-	sections = (Elf32_Shdr *)(base + header->e_shoff);
-
-	entryPoint = header->e_entry;
-
-    LoadSymbols();
-}
-
-const char *ElfReader::GetSectionName(int section) const
-{
-	if (sections[section].sh_type == SHT_NULL)
-		return nullptr;
-
-	int nameOffset = sections[section].sh_name;
-	char *ptr = (char*)GetSectionDataPtr(header->e_shstrndx);
-
-	if (ptr)
-		return ptr + nameOffset;
-	else
-		return nullptr;
-}
-
-bool ElfReader::LoadInto(u32 vaddr)
-{
-	DEBUG_LOG(MASTER_LOG,"String section: %i", header->e_shstrndx);
-
-	// Should we relocate?
-	bRelocate = (header->e_type != ET_EXEC);
-
-	if (bRelocate)
-	{
-		DEBUG_LOG(MASTER_LOG,"Relocatable module");
-		entryPoint += vaddr;
-	}
-	else
-	{
-		DEBUG_LOG(MASTER_LOG,"Prerelocated executable");
-	}
-
-	INFO_LOG(MASTER_LOG,"%i segments:", header->e_phnum);
-
-	// First pass : Get the bits into RAM
-	u32 segmentVAddr[32];
-
-	u32 baseAddress = bRelocate?vaddr:0;
-
-	for (int i = 0; i < header->e_phnum; i++)
-	{
-		Elf32_Phdr *p = segments + i;
-
-		INFO_LOG(MASTER_LOG, "Type: %i Vaddr: %08x Filesz: %i Memsz: %i ", p->p_type, p->p_vaddr, p->p_filesz, p->p_memsz);
-
-		if (p->p_type == PT_LOAD)
-		{
-			segmentVAddr[i] = baseAddress + p->p_vaddr;
-			u32 writeAddr = segmentVAddr[i];
-
-			const u8 *src = GetSegmentPtr(i);
-			u8 *dst = Memory::GetPointer(writeAddr);
-			u32 srcSize = p->p_filesz;
-			u32 dstSize = p->p_memsz;
-			u32 *s = (u32*)src;
-			u32 *d = (u32*)dst;
-			for (int j = 0; j < (int)(srcSize + 3) / 4; j++)
-			{
-				*d++ = /*_byteswap_ulong*/(*s++);
-			}
-			if (srcSize < dstSize)
-			{
-				//memset(dst + srcSize, 0, dstSize-srcSize); //zero out bss
-			}
-			INFO_LOG(MASTER_LOG,"Loadable Segment Copied to %08x, size %08x", writeAddr, p->p_memsz);
-		}
-	}
-
-
-    INFO_LOG(MASTER_LOG,"Done loading.");
-	return true;
-}
-
-SectionID ElfReader::GetSectionByName(const char *name, int firstSection) const
-{
-	for (int i = firstSection; i < header->e_shnum; i++)
-	{
-		const char *secname = GetSectionName(i);
-
-		if (secname != nullptr && strcmp(name, secname) == 0)
-			return i;
-	}
-	return -1;
-}
-
-bool ElfReader::LoadSymbols()
-{
-	bool hasSymbols = false;
-	SectionID sec = GetSectionByName(".symtab");
-	if (sec != -1)
-	{
-		int stringSection = sections[sec].sh_link;
-		const char *stringBase = (const char *)GetSectionDataPtr(stringSection);
-
-		//We have a symbol table!
-		Elf32_Sym *symtab = (Elf32_Sym *)(GetSectionDataPtr(sec));
-		int numSymbols = sections[sec].sh_size / sizeof(Elf32_Sym);
-		for (int sym = 0; sym < numSymbols; sym++)
-		{
-            int size = symtab[sym].st_size;
-			if (size == 0)
-				continue;
-
-			// int bind = symtab[sym].st_info >> 4;
-			int type = symtab[sym].st_info & 0xF;
-
-			const char *name = stringBase + symtab[sym].st_name;
-
-            Symbols::Add(symtab[sym].st_value, name, size, type);
-
-            hasSymbols = true;
-		}
-	}
-
-    return hasSymbols;
-}

src/core/elf/elf_reader.h

@@ -1,75 +0,0 @@
-// Copyright 2013 Dolphin Emulator Project
-// Licensed under GPLv2
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/elf/elf_types.h"
-
-enum KnownElfTypes
-{
-	KNOWNELF_PSP = 0,
-	KNOWNELF_DS  = 1,
-	KNOWNELF_GBA = 2,
-	KNOWNELF_GC  = 3,
-};
-
-typedef int SectionID;
-
-class ElfReader
-{
-private:
-	char *base;
-	u32 *base32;
-
-	Elf32_Ehdr *header;
-	Elf32_Phdr *segments;
-	Elf32_Shdr *sections;
-
-	u32 *sectionAddrs;
-	bool bRelocate;
-	u32 entryPoint;
-
-public:
-	ElfReader(void *ptr);
-	~ElfReader() { }
-
-	u32 Read32(int off) const { return base32[off>>2]; }
-
-	// Quick accessors
-	ElfType GetType() const { return (ElfType)(header->e_type); }
-	ElfMachine GetMachine() const { return (ElfMachine)(header->e_machine); }
-	u32 GetEntryPoint() const { return entryPoint; }
-	u32 GetFlags() const { return (u32)(header->e_flags); }
-	bool LoadInto(u32 vaddr);
-	bool LoadSymbols();
-
-	int GetNumSegments() const { return (int)(header->e_phnum); }
-	int GetNumSections() const { return (int)(header->e_shnum); }
-	const u8 *GetPtr(int offset) const { return (u8*)base + offset; }
-	const char *GetSectionName(int section) const;
-	const u8 *GetSectionDataPtr(int section) const
-	{
-		if (section < 0 || section >= header->e_shnum)
-			return nullptr;
-		if (sections[section].sh_type != SHT_NOBITS)
-			return GetPtr(sections[section].sh_offset);
-		else
-			return nullptr;
-	}
-	bool IsCodeSection(int section) const
-	{
-		return sections[section].sh_type == SHT_PROGBITS;
-	}
-	const u8 *GetSegmentPtr(int segment)
-	{
-		return GetPtr(segments[segment].p_offset);
-	}
-	u32 GetSectionAddr(SectionID section) const { return sectionAddrs[section]; }
-	int GetSectionSize(SectionID section) const { return sections[section].sh_size; }
-	SectionID GetSectionByName(const char *name, int firstSection = 0) const; //-1 for not found
-
-	bool DidRelocate() {
-		return bRelocate;
-	}
-};

src/core/elf/elf_types.h

@@ -1,281 +0,0 @@
-// Copyright 2013 Dolphin Emulator Project
-// Licensed under GPLv2
-// Refer to the license.txt file included.
-
-#pragma once
-
-// ELF Header Constants
-
-// File type
-enum ElfType
-{
-	ET_NONE   = 0,
-	ET_REL    = 1,
-	ET_EXEC   = 2,
-	ET_DYN    = 3,
-	ET_CORE   = 4,
-	ET_LOPROC = 0xFF00,
-	ET_HIPROC = 0xFFFF,
-};
-
-// Machine/Architecture
-enum ElfMachine
-{
-	EM_NONE  = 0,
-	EM_M32   = 1,
-	EM_SPARC = 2,
-	EM_386   = 3,
-	EM_68K   = 4,
-	EM_88K   = 5,
-	EM_860   = 7,
-	EM_MIPS  = 8
-};
-
-// File version
-#define EV_NONE    0
-#define EV_CURRENT 1
-
-// Identification index
-#define EI_MAG0    0
-#define EI_MAG1    1
-#define EI_MAG2    2
-#define EI_MAG3    3
-#define EI_CLASS   4
-#define EI_DATA    5
-#define EI_VERSION 6
-#define EI_PAD     7
-#define EI_NIDENT 16
-
-// Magic number
-#define ELFMAG0 0x7F
-#define ELFMAG1  'E'
-#define ELFMAG2  'L'
-#define ELFMAG3  'F'
-
-// File class
-#define ELFCLASSNONE 0
-#define ELFCLASS32   1
-#define ELFCLASS64   2
-
-// Encoding
-#define ELFDATANONE 0
-#define ELFDATA2LSB 1
-#define ELFDATA2MSB 2
-
-
-
-// Sections constants
-
-// Section indexes
-#define SHN_UNDEF          0
-#define SHN_LORESERVE 0xFF00
-#define SHN_LOPROC    0xFF00
-#define SHN_HIPROC    0xFF1F
-#define SHN_ABS       0xFFF1
-#define SHN_COMMON    0xFFF2
-#define SHN_HIRESERVE 0xFFFF
-
-// Section types
-#define SHT_NULL            0
-#define SHT_PROGBITS        1
-#define SHT_SYMTAB          2
-#define SHT_STRTAB          3
-#define SHT_RELA            4
-#define SHT_HASH            5
-#define SHT_DYNAMIC         6
-#define SHT_NOTE            7
-#define SHT_NOBITS          8
-#define SHT_REL             9
-#define SHT_SHLIB          10
-#define SHT_DYNSYM         11
-#define SHT_LOPROC 0x70000000
-#define SHT_HIPROC 0x7FFFFFFF
-#define SHT_LOUSER 0x80000000
-#define SHT_HIUSER 0xFFFFFFFF
-
-// Custom section types
-#define SHT_PSPREL 0x700000a0
-
-
-// Section flags
-enum ElfSectionFlags
-{
-	SHF_WRITE     = 0x1,
-	SHF_ALLOC     = 0x2,
-	SHF_EXECINSTR = 0x4,
-	SHF_MASKPROC  = 0xF0000000,
-};
-
-// Symbol binding
-#define STB_LOCAL   0
-#define STB_GLOBAL  1
-#define STB_WEAK    2
-#define STB_LOPROC 13
-#define STB_HIPROC 15
-
-// Symbol types
-#define STT_NOTYPE   0
-#define STT_OBJECT   1
-#define STT_FUNC     2
-#define STT_SECTION  3
-#define STT_FILE     4
-#define STT_LOPROC  13
-#define STT_HIPROC  15
-
-// Undefined name
-#define STN_UNDEF 0
-
-// Relocation types
-#define R_386_NONE      0
-#define R_386_32        1
-#define R_386_PC32      2
-#define R_386_GOT32     3
-#define R_386_PLT32     4
-#define R_386_COPY      5
-#define R_386_GLOB_DAT  6
-#define R_386_JMP_SLOT  7
-#define R_386_RELATIVE  8
-#define R_386_GOTOFF    9
-#define R_386_GOTPC    10
-
-// Segment types
-#define PT_NULL             0
-#define PT_LOAD             1
-#define PT_DYNAMIC          2
-#define PT_INTERP           3
-#define PT_NOTE             4
-#define PT_SHLIB            5
-#define PT_PHDR             6
-#define PT_LOPROC  0x70000000
-#define PT_HIPROC  0x7FFFFFFF
-
-// Segment flags
-#define PF_X 1
-#define PF_W 2
-#define PF_R 4
-
-// Dynamic Array Tags
-#define DT_NULL              0
-#define DT_NEEDED            1
-#define DT_PLTRELSZ          2
-#define DT_PLTGOT            3
-#define DT_HASH              4
-#define DT_STRTAB            5
-#define DT_SYMTAB            6
-#define DT_RELA              7
-#define DT_RELASZ            8
-#define DT_RELAENT           9
-#define DT_STRSZ            10
-#define DT_SYMENT           11
-#define DT_INIT             12
-#define DT_FINI             13
-#define DT_SONAME           14
-#define DT_RPATH            15
-#define DT_SYMBOLIC         16
-#define DT_REL              17
-#define DT_RELSZ            18
-#define DT_RELENT           19
-#define DT_PLTREL           20
-#define DT_DEBUG            21
-#define DT_TEXTREL          22
-#define DT_JMPREL           23
-#define DT_LOPROC   0x70000000
-#define DT_HIPROC   0x7FFFFFFF
-
-typedef unsigned int  Elf32_Addr;
-typedef unsigned short Elf32_Half;
-typedef unsigned int  Elf32_Off;
-typedef signed   int  Elf32_Sword;
-typedef unsigned int  Elf32_Word;
-
-
-// ELF file header
-struct Elf32_Ehdr
-{
-	unsigned char e_ident[EI_NIDENT];
-	Elf32_Half    e_type;
-	Elf32_Half    e_machine;
-	Elf32_Word    e_version;
-	Elf32_Addr    e_entry;
-	Elf32_Off     e_phoff;
-	Elf32_Off     e_shoff;
-	Elf32_Word    e_flags;
-	Elf32_Half    e_ehsize;
-	Elf32_Half    e_phentsize;
-	Elf32_Half    e_phnum;
-	Elf32_Half    e_shentsize;
-	Elf32_Half    e_shnum;
-	Elf32_Half    e_shstrndx;
-};
-
-// Section header
-struct Elf32_Shdr
-{
-	Elf32_Word sh_name;
-	Elf32_Word sh_type;
-	Elf32_Word sh_flags;
-	Elf32_Addr sh_addr;
-	Elf32_Off  sh_offset;
-	Elf32_Word sh_size;
-	Elf32_Word sh_link;
-	Elf32_Word sh_info;
-	Elf32_Word sh_addralign;
-	Elf32_Word sh_entsize;
-};
-
-// Segment header
-struct Elf32_Phdr
-{
-	Elf32_Word p_type;
-	Elf32_Off  p_offset;
-	Elf32_Addr p_vaddr;
-	Elf32_Addr p_paddr;
-	Elf32_Word p_filesz;
-	Elf32_Word p_memsz;
-	Elf32_Word p_flags;
-	Elf32_Word p_align;
-};
-
-// Symbol table entry
-struct Elf32_Sym
-{
-	Elf32_Word    st_name;
-	Elf32_Addr    st_value;
-	Elf32_Word    st_size;
-	unsigned char st_info;
-	unsigned char st_other;
-	Elf32_Half    st_shndx;
-};
-
-#define ELF32_ST_BIND(i)   ((i)>>4)
-#define ELF32_ST_TYPE(i)   ((i)&0xf)
-#define ELF32_ST_INFO(b,t) (((b)<<4)+((t)&0xf))
-
-// Relocation entries
-struct Elf32_Rel
-{
-	Elf32_Addr r_offset;
-	Elf32_Word r_info;
-};
-
-struct Elf32_Rela
-{
-	Elf32_Addr  r_offset;
-	Elf32_Word  r_info;
-	Elf32_Sword r_addend;
-};
-
-#define ELF32_R_SYM(i) ((i)>>8)
-#define ELF32_R_TYPE(i) ((unsigned char)(i))
-#define ELF32_R_INFO(s,t) (((s)<<8 )+(unsigned char)(t))
-
-
-struct Elf32_Dyn
-{
-	Elf32_Sword d_tag;
-	union
-	{
-		Elf32_Word d_val;
-		Elf32_Addr d_ptr;
-	} d_un;
-};

src/core/loader.cpp

@@ -1,275 +0,0 @@
-// Copyright 2014 Citra Emulator Project
-// Licensed under GPLv2
-// Refer to the license.txt file included.
-
-#include "common/common_types.h"
-#include "common/file_util.h"
-
-#include "core/loader.h"
-#include "core/system.h"
-#include "core/core.h"
-#include "core/file_sys/directory_file_system.h"
-#include "core/elf/elf_reader.h"
-#include "core/hle/kernel/kernel.h"
-#include "core/mem_map.h"
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-/// Loads an extracted CXI from a directory
-bool LoadDirectory_CXI(std::string &filename) {
-    std::string full_path = filename;
-    std::string path, file, extension;
-    SplitPath(ReplaceAll(full_path, "\\", "/"), &path, &file, &extension);
-#if EMU_PLATFORM == PLATFORM_WINDOWS
-    path = ReplaceAll(path, "/", "\\");
-#endif
-    DirectoryFileSystem *fs = new DirectoryFileSystem(&System::g_ctr_file_system, path);
-    System::g_ctr_file_system.Mount("fs:", fs);
-
-    std::string final_name = "fs:/" + file + extension;
-    File::IOFile f(filename, "rb");
-
-    if (f.IsOpen()) {
-        // TODO(ShizZy): read here to memory....
-    }
-    ERROR_LOG(TIME, "Unimplemented function!");
-    return true;
-}
-
-/// Loads a CTR ELF file
-bool Load_ELF(std::string &filename) {
-    std::string full_path = filename;
-    std::string path, file, extension;
-    SplitPath(ReplaceAll(full_path, "\\", "/"), &path, &file, &extension);
-#if EMU_PLATFORM == PLATFORM_WINDOWS
-    path = ReplaceAll(path, "/", "\\");
-#endif
-    File::IOFile f(filename, "rb");
-
-    if (f.IsOpen()) {
-        u64 size = f.GetSize();
-        u8* buffer = new u8[size];
-        ElfReader* elf_reader = NULL;
-
-        f.ReadBytes(buffer, size);
-
-        elf_reader = new ElfReader(buffer);
-        elf_reader->LoadInto(0x00100000);
-
-        Kernel::LoadExec(elf_reader->GetEntryPoint());
-
-        delete[] buffer;
-        delete elf_reader;
-    } else {
-        return false;
-    }
-    f.Close();
-
-    return true;
-}
-
-/// Loads a Launcher DAT file
-bool Load_DAT(std::string &filename) {
-    std::string full_path = filename;
-    std::string path, file, extension;
-    SplitPath(ReplaceAll(full_path, "\\", "/"), &path, &file, &extension);
-#if EMU_PLATFORM == PLATFORM_WINDOWS
-    path = ReplaceAll(path, "/", "\\");
-#endif
-    File::IOFile f(filename, "rb");
-
-    if (f.IsOpen()) {
-        u64 size = f.GetSize();
-        u8* buffer = new u8[size];
-
-        f.ReadBytes(buffer, size);
-
-        /**
-        * (mattvail) We shouldn't really support this type of file
-        * but for the sake of making it easier... we'll temporarily/hackishly
-        * allow it. No sense in making a proper reader for this.
-        */
-        u32 entry_point = 0x00100000; // write to same entrypoint as elf
-        u32 payload_offset = 0xA150;
-        
-        const u8 *src = &buffer[payload_offset];
-        u8 *dst = Memory::GetPointer(entry_point);
-        u32 srcSize = size - payload_offset; //just load everything...
-        u32 *s = (u32*)src;
-        u32 *d = (u32*)dst;
-        for (int j = 0; j < (int)(srcSize + 3) / 4; j++)
-        {
-            *d++ = (*s++);
-        }
-        
-        Kernel::LoadExec(entry_point);
-
-
-        delete[] buffer;
-    }
-    else {
-        return false;
-    }
-    f.Close();
-
-    return true;
-}
-
-
-/// Loads a CTR BIN file extracted from an ExeFS
-bool Load_BIN(std::string &filename) {
-    std::string full_path = filename;
-    std::string path, file, extension;
-    SplitPath(ReplaceAll(full_path, "\\", "/"), &path, &file, &extension);
-#if EMU_PLATFORM == PLATFORM_WINDOWS
-    path = ReplaceAll(path, "/", "\\");
-#endif
-    File::IOFile f(filename, "rb");
-
-    if (f.IsOpen()) {
-        u64 size = f.GetSize();
-        u8* buffer = new u8[size];
-
-        f.ReadBytes(buffer, size);
-
-        u32 entry_point = 0x00100000; // Hardcoded, read from exheader
-        
-        const u8 *src = buffer;
-        u8 *dst = Memory::GetPointer(entry_point);
-        u32 srcSize = size;
-        u32 *s = (u32*)src;
-        u32 *d = (u32*)dst;
-        for (int j = 0; j < (int)(srcSize + 3) / 4; j++)
-        {
-            *d++ = (*s++);
-        }
-        
-        Kernel::LoadExec(entry_point);
-
-        delete[] buffer;
-    }
-    else {
-        return false;
-    }
-    f.Close();
-
-    return true;
-}
-
-namespace Loader {
-
-bool IsBootableDirectory() {
-    ERROR_LOG(TIME, "Unimplemented function!");
-    return true;
-}
-
-/**
- * Identifies the type of a bootable file
- * @param filename String filename of bootable file
- * @todo (ShizZy) this function sucks... make it actually check file contents etc.
- * @return FileType of file
- */
-FileType IdentifyFile(std::string &filename) {
-    if (filename.size() == 0) {
-        ERROR_LOG(LOADER, "invalid filename %s", filename.c_str());
-        return FILETYPE_ERROR;
-    }
-    std::string extension = filename.size() >= 5 ? filename.substr(filename.size() - 4) : "";
-
-    if (File::IsDirectory(filename)) {
-        if (IsBootableDirectory()) {
-            return FILETYPE_DIRECTORY_CXI;
-        }
-        else {
-            return FILETYPE_NORMAL_DIRECTORY;
-        }
-    }
-    else if (!strcasecmp(extension.c_str(), ".elf")) {
-        return FILETYPE_CTR_ELF; // TODO(bunnei): Do some filetype checking :p
-    }
-    else if (!strcasecmp(extension.c_str(), ".axf")) {
-        return FILETYPE_CTR_ELF; // TODO(bunnei): Do some filetype checking :p
-    }
-    else if (!strcasecmp(extension.c_str(), ".bin")) {
-        return FILETYPE_CTR_BIN;
-    }
-    else if (!strcasecmp(extension.c_str(), ".dat")) {
-        return FILETYPE_LAUNCHER_DAT;
-    }
-    else if (!strcasecmp(extension.c_str(), ".zip")) {
-        return FILETYPE_ARCHIVE_ZIP;
-    }
-    else if (!strcasecmp(extension.c_str(), ".rar")) {
-        return FILETYPE_ARCHIVE_RAR;
-    }
-    else if (!strcasecmp(extension.c_str(), ".r00")) {
-        return FILETYPE_ARCHIVE_RAR;
-    }
-    else if (!strcasecmp(extension.c_str(), ".r01")) {
-        return FILETYPE_ARCHIVE_RAR;
-    }
-    return FILETYPE_UNKNOWN;
-}
-
-/**
- * Identifies and loads a bootable file
- * @param filename String filename of bootable file
- * @param error_string Point to string to put error message if an error has occurred
- * @return True on success, otherwise false
- */
-bool LoadFile(std::string &filename, std::string *error_string) {
-    INFO_LOG(LOADER, "Identifying file...");
-
-    // Note that this can modify filename!
-    switch (IdentifyFile(filename)) {
-
-    case FILETYPE_CTR_ELF:
-        return Load_ELF(filename);
-
-    case FILETYPE_CTR_BIN:
-        return Load_BIN(filename);
-
-    case FILETYPE_LAUNCHER_DAT:
-        return Load_DAT(filename);
-
-    case FILETYPE_DIRECTORY_CXI:
-        return LoadDirectory_CXI(filename);
-
-    case FILETYPE_ERROR:
-        ERROR_LOG(LOADER, "Could not read file");
-        *error_string = "Error reading file";
-        break;
-
-    case FILETYPE_ARCHIVE_RAR:
-#ifdef WIN32
-        *error_string = "RAR file detected (Require WINRAR)";
-#else
-        *error_string = "RAR file detected (Require UnRAR)";
-#endif
-        break;
-
-    case FILETYPE_ARCHIVE_ZIP:
-#ifdef WIN32
-        *error_string = "ZIP file detected (Require WINRAR)";
-#else
-        *error_string = "ZIP file detected (Require UnRAR)";
-#endif
-        break;
-
-    case FILETYPE_NORMAL_DIRECTORY:
-        ERROR_LOG(LOADER, "Just a directory.");
-        *error_string = "Just a directory.";
-        break;
-
-    case FILETYPE_UNKNOWN_BIN:
-    case FILETYPE_UNKNOWN_ELF:
-    case FILETYPE_UNKNOWN:
-    default:
-        ERROR_LOG(LOADER, "Failed to identify file");
-        *error_string = " Failed to identify file";
-        break;
-    }
-    return false;
-}
-
-} // namespace

src/core/loader.h

@@ -1,54 +0,0 @@
-// Copyright 2014 Citra Emulator Project
-// Licensed under GPLv2
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "common/common.h"
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-namespace Loader {
-
-enum FileType {
-    FILETYPE_ERROR,
-
-    FILETYPE_CTR_CCI,
-    FILETYPE_CTR_CIA,
-    FILETYPE_CTR_CXI,
-    FILETYPE_CTR_ELF,
-    FILETYPE_CTR_BIN,
-
-    FILETYPE_LAUNCHER_DAT,
-
-    FILETYPE_DIRECTORY_CXI,
-    
-    FILETYPE_UNKNOWN_BIN,
-    FILETYPE_UNKNOWN_ELF,
-    
-    FILETYPE_ARCHIVE_RAR,
-    FILETYPE_ARCHIVE_ZIP,
-    
-    FILETYPE_NORMAL_DIRECTORY,
-    
-    FILETYPE_UNKNOWN
-};
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-/**
- * Identifies the type of a bootable file
- * @param filename String filename of bootable file
- * @return FileType of file
- */
-FileType IdentifyFile(std::string &filename);
-
-/**
- * Identifies and loads a bootable file
- * @param filename String filename of bootable file
- * @param error_string Point to string to put error message if an error has occurred
- * @return True on success, otherwise false
- */
-bool LoadFile(std::string &filename, std::string *error_string);
-
-} // namespace

src/core/loader/elf.cpp

@@ -0,0 +1,370 @@
+// Copyright 2013 Dolphin Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#include <string>
+#include <memory>
+
+#include "common/common.h"
+#include "common/file_util.h"
+#include "common/symbols.h"
+
+#include "core/mem_map.h"
+#include "core/loader/elf.h"
+#include "core/hle/kernel/kernel.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// ELF Header Constants
+
+// File type
+enum ElfType {
+    ET_NONE = 0,
+    ET_REL = 1,
+    ET_EXEC = 2,
+    ET_DYN = 3,
+    ET_CORE = 4,
+    ET_LOPROC = 0xFF00,
+    ET_HIPROC = 0xFFFF,
+};
+
+// Machine/Architecture
+enum ElfMachine {
+    EM_NONE = 0,
+    EM_M32 = 1,
+    EM_SPARC = 2,
+    EM_386 = 3,
+    EM_68K = 4,
+    EM_88K = 5,
+    EM_860 = 7,
+    EM_MIPS = 8
+};
+
+// File version
+#define EV_NONE    0
+#define EV_CURRENT 1
+
+// Identification index
+#define EI_MAG0    0
+#define EI_MAG1    1
+#define EI_MAG2    2
+#define EI_MAG3    3
+#define EI_CLASS   4
+#define EI_DATA    5
+#define EI_VERSION 6
+#define EI_PAD     7
+#define EI_NIDENT 16
+
+// Magic number
+#define ELFMAG0 0x7F
+#define ELFMAG1  'E'
+#define ELFMAG2  'L'
+#define ELFMAG3  'F'
+
+// Sections constants
+
+// Section types
+#define SHT_NULL            0
+#define SHT_PROGBITS        1
+#define SHT_SYMTAB          2
+#define SHT_STRTAB          3
+#define SHT_RELA            4
+#define SHT_HASH            5
+#define SHT_DYNAMIC         6
+#define SHT_NOTE            7
+#define SHT_NOBITS          8
+#define SHT_REL             9
+#define SHT_SHLIB          10
+#define SHT_DYNSYM         11
+#define SHT_LOPROC 0x70000000
+#define SHT_HIPROC 0x7FFFFFFF
+#define SHT_LOUSER 0x80000000
+#define SHT_HIUSER 0xFFFFFFFF
+
+// Section flags
+enum ElfSectionFlags
+{
+    SHF_WRITE = 0x1,
+    SHF_ALLOC = 0x2,
+    SHF_EXECINSTR = 0x4,
+    SHF_MASKPROC = 0xF0000000,
+};
+
+// Segment types
+#define PT_NULL             0
+#define PT_LOAD             1
+#define PT_DYNAMIC          2
+#define PT_INTERP           3
+#define PT_NOTE             4
+#define PT_SHLIB            5
+#define PT_PHDR             6
+#define PT_LOPROC  0x70000000
+#define PT_HIPROC  0x7FFFFFFF
+
+typedef unsigned int  Elf32_Addr;
+typedef unsigned short Elf32_Half;
+typedef unsigned int  Elf32_Off;
+typedef signed   int  Elf32_Sword;
+typedef unsigned int  Elf32_Word;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// ELF file header
+
+struct Elf32_Ehdr {
+    unsigned char e_ident[EI_NIDENT];
+    Elf32_Half    e_type;
+    Elf32_Half    e_machine;
+    Elf32_Word    e_version;
+    Elf32_Addr    e_entry;
+    Elf32_Off     e_phoff;
+    Elf32_Off     e_shoff;
+    Elf32_Word    e_flags;
+    Elf32_Half    e_ehsize;
+    Elf32_Half    e_phentsize;
+    Elf32_Half    e_phnum;
+    Elf32_Half    e_shentsize;
+    Elf32_Half    e_shnum;
+    Elf32_Half    e_shstrndx;
+};
+
+// Section header
+struct Elf32_Shdr {
+    Elf32_Word sh_name;
+    Elf32_Word sh_type;
+    Elf32_Word sh_flags;
+    Elf32_Addr sh_addr;
+    Elf32_Off  sh_offset;
+    Elf32_Word sh_size;
+    Elf32_Word sh_link;
+    Elf32_Word sh_info;
+    Elf32_Word sh_addralign;
+    Elf32_Word sh_entsize;
+};
+
+// Segment header
+struct Elf32_Phdr {
+    Elf32_Word p_type;
+    Elf32_Off  p_offset;
+    Elf32_Addr p_vaddr;
+    Elf32_Addr p_paddr;
+    Elf32_Word p_filesz;
+    Elf32_Word p_memsz;
+    Elf32_Word p_flags;
+    Elf32_Word p_align;
+};
+
+// Symbol table entry
+struct Elf32_Sym {
+    Elf32_Word    st_name;
+    Elf32_Addr    st_value;
+    Elf32_Word    st_size;
+    unsigned char st_info;
+    unsigned char st_other;
+    Elf32_Half    st_shndx;
+};
+
+// Relocation entries
+struct Elf32_Rel {
+    Elf32_Addr r_offset;
+    Elf32_Word r_info;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// ElfReader class
+
+typedef int SectionID;
+
+class ElfReader {
+private:
+    char *base;
+    u32 *base32;
+
+    Elf32_Ehdr *header;
+    Elf32_Phdr *segments;
+    Elf32_Shdr *sections;
+
+    u32 *sectionAddrs;
+    bool relocate;
+    u32 entryPoint;
+
+public:
+    ElfReader(void *ptr);
+    ~ElfReader() { }
+
+    u32 Read32(int off) const { return base32[off >> 2]; }
+
+    // Quick accessors
+    ElfType GetType() const { return (ElfType)(header->e_type); }
+    ElfMachine GetMachine() const { return (ElfMachine)(header->e_machine); }
+    u32 GetEntryPoint() const { return entryPoint; }
+    u32 GetFlags() const { return (u32)(header->e_flags); }
+    bool LoadInto(u32 vaddr);
+    bool LoadSymbols();
+
+    int GetNumSegments() const { return (int)(header->e_phnum); }
+    int GetNumSections() const { return (int)(header->e_shnum); }
+    const u8 *GetPtr(int offset) const { return (u8*)base + offset; }
+    const char *GetSectionName(int section) const;
+    const u8 *GetSectionDataPtr(int section) const {
+        if (section < 0 || section >= header->e_shnum)
+            return nullptr;
+        if (sections[section].sh_type != SHT_NOBITS)
+            return GetPtr(sections[section].sh_offset);
+        else
+            return nullptr;
+    }
+    bool IsCodeSection(int section) const {
+        return sections[section].sh_type == SHT_PROGBITS;
+    }
+    const u8 *GetSegmentPtr(int segment) {
+        return GetPtr(segments[segment].p_offset);
+    }
+    u32 GetSectionAddr(SectionID section) const { return sectionAddrs[section]; }
+    int GetSectionSize(SectionID section) const { return sections[section].sh_size; }
+    SectionID GetSectionByName(const char *name, int firstSection = 0) const; //-1 for not found
+
+    bool DidRelocate() {
+        return relocate;
+    }
+};
+
+ElfReader::ElfReader(void *ptr) {
+    base = (char*)ptr;
+    base32 = (u32 *)ptr;
+    header = (Elf32_Ehdr*)ptr;
+
+    segments = (Elf32_Phdr *)(base + header->e_phoff);
+    sections = (Elf32_Shdr *)(base + header->e_shoff);
+
+    entryPoint = header->e_entry;
+
+    LoadSymbols();
+}
+
+const char *ElfReader::GetSectionName(int section) const {
+    if (sections[section].sh_type == SHT_NULL)
+        return nullptr;
+
+    int name_offset = sections[section].sh_name;
+    char *ptr = (char*)GetSectionDataPtr(header->e_shstrndx);
+
+    if (ptr)
+        return ptr + name_offset;
+
+    return nullptr;
+}
+
+bool ElfReader::LoadInto(u32 vaddr) {
+    DEBUG_LOG(MASTER_LOG, "String section: %i", header->e_shstrndx);
+
+    // Should we relocate?
+    relocate = (header->e_type != ET_EXEC);
+
+    if (relocate) {
+        DEBUG_LOG(MASTER_LOG, "Relocatable module");
+        entryPoint += vaddr;
+    } else {
+        DEBUG_LOG(MASTER_LOG, "Prerelocated executable");
+    }
+    INFO_LOG(MASTER_LOG, "%i segments:", header->e_phnum);
+
+    // First pass : Get the bits into RAM
+    u32 segment_addr[32];
+    u32 base_addr = relocate ? vaddr : 0;
+
+    for (int i = 0; i < header->e_phnum; i++) {
+        Elf32_Phdr *p = segments + i;
+        INFO_LOG(MASTER_LOG, "Type: %i Vaddr: %08x Filesz: %i Memsz: %i ", p->p_type, p->p_vaddr, 
+            p->p_filesz, p->p_memsz);
+
+        if (p->p_type == PT_LOAD) {
+            segment_addr[i] = base_addr + p->p_vaddr;
+            memcpy(Memory::GetPointer(segment_addr[i]), GetSegmentPtr(i), p->p_filesz);
+            INFO_LOG(MASTER_LOG, "Loadable Segment Copied to %08x, size %08x", segment_addr[i], 
+                p->p_memsz);
+        }
+    }
+    INFO_LOG(MASTER_LOG, "Done loading.");
+    return true;
+}
+
+SectionID ElfReader::GetSectionByName(const char *name, int firstSection) const {
+    for (int i = firstSection; i < header->e_shnum; i++) {
+        const char *secname = GetSectionName(i);
+
+        if (secname != nullptr && strcmp(name, secname) == 0)
+            return i;
+    }
+    return -1;
+}
+
+bool ElfReader::LoadSymbols() {
+    bool hasSymbols = false;
+    SectionID sec = GetSectionByName(".symtab");
+    if (sec != -1) {
+        int stringSection = sections[sec].sh_link;
+        const char *stringBase = (const char *)GetSectionDataPtr(stringSection);
+
+        //We have a symbol table!
+        Elf32_Sym *symtab = (Elf32_Sym *)(GetSectionDataPtr(sec));
+        int numSymbols = sections[sec].sh_size / sizeof(Elf32_Sym);
+        for (int sym = 0; sym < numSymbols; sym++) {
+            int size = symtab[sym].st_size;
+            if (size == 0)
+                continue;
+
+            int type = symtab[sym].st_info & 0xF;
+
+            const char *name = stringBase + symtab[sym].st_name;
+
+            Symbols::Add(symtab[sym].st_value, name, size, type);
+
+            hasSymbols = true;
+        }
+    }
+
+    return hasSymbols;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Loader namespace
+
+namespace Loader {
+
+/// AppLoader_ELF constructor
+AppLoader_ELF::AppLoader_ELF(const std::string& filename) : is_loaded(false) {
+    this->filename = filename;
+}
+
+/// AppLoader_NCCH destructor
+AppLoader_ELF::~AppLoader_ELF() {
+}
+
+/**
+ * Loads an NCCH file (e.g. from a CCI, or the first NCCH in a CXI)
+ * @param error_string Pointer to string to put error message if an error has occurred
+ * @todo Move NCSD parsing out of here and create a separate function for loading these
+ * @return True on success, otherwise false
+ */
+ResultStatus AppLoader_ELF::Load() {
+    INFO_LOG(LOADER, "Loading ELF file %s...", filename.c_str());
+
+    if (is_loaded)
+        return ResultStatus::ErrorAlreadyLoaded;
+
+    File::IOFile file(filename, "rb");
+
+    if (file.IsOpen()) {
+        u32 size = (u32)file.GetSize();
+        std::unique_ptr<u8[]> buffer(new u8[size]);
+        file.ReadBytes(&buffer[0], size);
+
+        ElfReader elf_reader(&buffer[0]);
+        elf_reader.LoadInto(0x00100000);
+        Kernel::LoadExec(elf_reader.GetEntryPoint());
+    } else {
+        return ResultStatus::Error;
+    }
+    return ResultStatus::Success;
+}
+
+} // namespace Loader

src/core/loader/elf.h

@@ -0,0 +1,32 @@
+// Copyright 2013 Dolphin Emulator Project / Citra Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "common/common_types.h"
+#include "core/loader/loader.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Loader namespace
+
+namespace Loader {
+
+/// Loads an ELF/AXF file
+class AppLoader_ELF : public AppLoader {
+public:
+    AppLoader_ELF(const std::string& filename);
+    ~AppLoader_ELF();
+
+    /**
+     * Load the bootable file
+     * @return ResultStatus result of function
+     */
+    ResultStatus Load();
+
+private:
+    std::string filename;
+    bool        is_loaded;
+};
+
+} // namespace Loader

src/core/loader/loader.cpp

@@ -0,0 +1,77 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#include <memory>
+
+#include "core/loader/loader.h"
+#include "core/loader/elf.h"
+#include "core/loader/ncch.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace Loader {
+
+/**
+ * Identifies the type of a bootable file
+ * @param filename String filename of bootable file
+ * @todo (ShizZy) this function sucks... make it actually check file contents etc.
+ * @return FileType of file
+ */
+FileType IdentifyFile(const std::string &filename) {
+    if (filename.size() == 0) {
+        ERROR_LOG(LOADER, "invalid filename %s", filename.c_str());
+        return FileType::Error;
+    }
+    std::string extension = filename.size() >= 5 ? filename.substr(filename.size() - 4) : "";
+
+    if (!strcasecmp(extension.c_str(), ".elf")) {
+        return FileType::ELF; // TODO(bunnei): Do some filetype checking :p
+    }
+    else if (!strcasecmp(extension.c_str(), ".axf")) {
+        return FileType::ELF; // TODO(bunnei): Do some filetype checking :p
+    }
+    else if (!strcasecmp(extension.c_str(), ".cxi")) {
+        return FileType::CXI; // TODO(bunnei): Do some filetype checking :p
+    }
+    else if (!strcasecmp(extension.c_str(), ".cci")) {
+        return FileType::CCI; // TODO(bunnei): Do some filetype checking :p
+    }
+    return FileType::Unknown;
+}
+
+/**
+ * Identifies and loads a bootable file
+ * @param filename String filename of bootable file
+ * @return ResultStatus result of function
+ */
+ResultStatus LoadFile(const std::string& filename) {
+    INFO_LOG(LOADER, "Loading file %s...", filename.c_str());
+
+    switch (IdentifyFile(filename)) {
+
+    // Standard ELF file format...
+    case FileType::ELF: {
+        return AppLoader_ELF(filename).Load();
+    }
+
+    // NCCH/NCSD container formats...
+    case FileType::CXI:
+    case FileType::CCI: {
+        return AppLoader_NCCH(filename).Load();
+    }
+
+    // Error occurred durring IdentifyFile...
+    case FileType::Error:
+
+    // IdentifyFile could know identify file type...
+    case FileType::Unknown:
+
+    default:
+        return ResultStatus::ErrorInvalidFormat;
+    }
+
+    return ResultStatus::Error;
+}
+
+} // namespace Loader

src/core/loader/loader.h

@@ -0,0 +1,121 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <vector>
+
+#include "common/common.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Loader namespace
+
+namespace Loader {
+
+/// File types supported by CTR
+enum class FileType {
+    Error,
+    Unknown,
+    CCI,
+    CXI,
+    CIA,
+    ELF,
+};
+
+/// Return type for functions in Loader namespace
+enum class ResultStatus {
+    Success,
+    Error,
+    ErrorInvalidFormat,
+    ErrorNotImplemented,
+    ErrorNotLoaded,
+    ErrorNotUsed,
+    ErrorAlreadyLoaded,
+};
+
+/// Interface for loading an application
+class AppLoader : NonCopyable {
+public:
+    AppLoader() { }
+    virtual ~AppLoader() { }
+
+    /**
+     * Load the application
+     * @return ResultStatus result of function
+     */
+    virtual ResultStatus Load() = 0;
+
+    /**
+     * Get the code (typically .code section) of the application
+     * @param error ResultStatus result of function
+     * @return Reference to code buffer
+     */
+    virtual const std::vector<u8>& ReadCode(ResultStatus& error) const {
+        error = ResultStatus::ErrorNotImplemented;
+        return code;
+    }
+
+    /**
+     * Get the icon (typically icon section) of the application
+     * @param error ResultStatus result of function
+     * @return Reference to icon buffer
+     */
+    virtual const std::vector<u8>& ReadIcon(ResultStatus& error) const {
+        error = ResultStatus::ErrorNotImplemented;
+        return icon;
+    }
+
+    /**
+     * Get the banner (typically banner section) of the application
+     * @param error ResultStatus result of function
+     * @return Reference to banner buffer
+     */
+    virtual const std::vector<u8>& ReadBanner(ResultStatus& error) const {
+        error = ResultStatus::ErrorNotImplemented;
+        return banner;
+    }
+
+    /**
+     * Get the logo (typically logo section) of the application
+     * @param error ResultStatus result of function
+     * @return Reference to logo buffer
+     */
+    virtual const std::vector<u8>& ReadLogo(ResultStatus& error) const {
+        error = ResultStatus::ErrorNotImplemented;
+        return logo;
+    }
+
+    /**
+     * Get the RomFs archive of the application
+     * @param error ResultStatus result of function
+     * @return Reference to RomFs archive buffer
+     */
+    virtual const std::vector<u8>& ReadRomFS(ResultStatus& error) const {
+        error = ResultStatus::ErrorNotImplemented;
+        return romfs;
+    }
+
+protected:
+    std::vector<u8> code;   ///< ExeFS .code section
+    std::vector<u8> icon;   ///< ExeFS .icon section
+    std::vector<u8> banner; ///< ExeFS .banner section
+    std::vector<u8> logo;   ///< ExeFS .logo section
+    std::vector<u8> romfs;  ///< RomFs archive
+};
+
+/**
+ * Identifies the type of a bootable file
+ * @param filename String filename of bootable file
+ * @return FileType of file
+ */
+FileType IdentifyFile(const std::string &filename);
+
+/**
+ * Identifies and loads a bootable file
+ * @param filename String filename of bootable file
+ * @return ResultStatus result of function
+ */
+ResultStatus LoadFile(const std::string& filename);
+
+} // namespace

src/core/loader/ncch.cpp

@@ -0,0 +1,312 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#include <memory>
+
+#include "common/file_util.h"
+
+#include "core/loader/ncch.h"
+#include "core/hle/kernel/kernel.h"
+#include "core/mem_map.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Loader namespace
+
+namespace Loader {
+
+static const int kMaxSections   = 8;        ///< Maximum number of sections (files) in an ExeFs
+static const int kBlockSize     = 0x200;    ///< Size of ExeFS blocks (in bytes)
+
+/**
+ * Get the decompressed size of an LZSS compressed ExeFS file
+ * @param buffer Buffer of compressed file
+ * @param size Size of compressed buffer
+ * @return Size of decompressed buffer
+ */
+u32 LZSS_GetDecompressedSize(u8* buffer, u32 size) {
+    u32 offset_size = *(u32*)(buffer + size - 4);
+    return offset_size + size;
+}
+
+/**
+ * Decompress ExeFS file (compressed with LZSS)
+ * @param compressed Compressed buffer
+ * @param compressed_size Size of compressed buffer
+ * @param decompressed Decompressed buffer
+ * @param decompressed_size Size of decompressed buffer
+ * @return True on success, otherwise false
+ */
+bool LZSS_Decompress(u8* compressed, u32 compressed_size, u8* decompressed, u32 decompressed_size) {
+    u8* footer = compressed + compressed_size - 8;
+    u32 buffer_top_and_bottom = *(u32*)footer;
+    u32 i, j;
+    u32 out = decompressed_size;
+    u32 index = compressed_size - ((buffer_top_and_bottom >> 24) & 0xFF);
+    u8 control;
+    u32 stop_index = compressed_size - (buffer_top_and_bottom & 0xFFFFFF);
+
+    memset(decompressed, 0, decompressed_size);
+    memcpy(decompressed, compressed, compressed_size);
+
+    while(index > stop_index) {
+        control = compressed[--index];
+
+        for(i = 0; i < 8; i++) {
+            if(index <= stop_index)
+                break;
+            if(index <= 0)
+                break;
+            if(out <= 0)
+                break;
+
+            if(control & 0x80) {
+                // Check if compression is out of bounds
+                if(index < 2) {
+                    return false;
+                }
+                index -= 2;
+
+                u32 segment_offset = compressed[index] | (compressed[index + 1] << 8);
+                u32 segment_size = ((segment_offset >> 12) & 15) + 3;
+                segment_offset &= 0x0FFF;
+                segment_offset += 2;
+
+                // Check if compression is out of bounds
+                if(out < segment_size) {
+                    return false;
+                }
+                for(j = 0; j < segment_size; j++) {
+                    u8 data;
+                    // Check if compression is out of bounds
+                    if(out + segment_offset >= decompressed_size) {
+                        return false;
+                    }
+                    data  = decompressed[out + segment_offset];
+                    decompressed[--out] = data;
+                }
+            } else {
+                // Check if compression is out of bounds
+                if(out < 1) {
+                    return false;
+                }
+                decompressed[--out] = compressed[--index];
+            }
+            control <<= 1;
+        }
+    }
+    return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// AppLoader_NCCH class
+
+/// AppLoader_NCCH constructor
+AppLoader_NCCH::AppLoader_NCCH(const std::string& filename) {
+    this->filename = filename;
+    is_loaded = false;
+    is_compressed = false;
+    entry_point = 0;
+    ncch_offset = 0;
+    exefs_offset = 0;
+}
+
+/// AppLoader_NCCH destructor
+AppLoader_NCCH::~AppLoader_NCCH() {
+    if (file.IsOpen())
+        file.Close();
+}
+
+/**
+ * Loads .code section into memory for booting
+ * @return ResultStatus result of function
+ */
+ResultStatus AppLoader_NCCH::LoadExec() {
+    if (!is_loaded) 
+        return ResultStatus::ErrorNotLoaded;
+
+    ResultStatus res;
+    code = ReadCode(res);
+
+    if (ResultStatus::Success == res) {
+        Memory::WriteBlock(entry_point, &code[0], code.size());
+        Kernel::LoadExec(entry_point);
+    }
+    return res;
+}
+
+/**
+ * Reads an application ExeFS section of an NCCH file into AppLoader (e.g. .code, .logo, etc.)
+ * @param name Name of section to read out of NCCH file
+ * @param buffer Vector to read data into
+ * @param error ResultStatus result of function
+ * @return Reference to buffer of data that was read
+ */
+const std::vector<u8>& AppLoader_NCCH::LoadSectionExeFS(const char* name, std::vector<u8>& buffer, 
+    ResultStatus& error) {
+    // Iterate through the ExeFs archive until we find the .code file...
+    for (int i = 0; i < kMaxSections; i++) {
+        // Load the specified section...
+        if (strcmp((const char*)exefs_header.section[i].name, name) == 0) {
+            INFO_LOG(LOADER, "ExeFS section %d:", i);
+            INFO_LOG(LOADER, "    name:   %s", exefs_header.section[i].name);
+            INFO_LOG(LOADER, "    offset: 0x%08X", exefs_header.section[i].offset);
+            INFO_LOG(LOADER, "    size:   0x%08X", exefs_header.section[i].size);
+
+            s64 section_offset = (exefs_header.section[i].offset + exefs_offset + 
+                sizeof(ExeFs_Header) + ncch_offset);
+            file.Seek(section_offset, 0);
+
+            // Section is compressed...
+            if (i == 0 && is_compressed) {
+                // Read compressed .code section...
+                std::unique_ptr<u8[]> temp_buffer(new u8[exefs_header.section[i].size]);
+                file.ReadBytes(&temp_buffer[0], exefs_header.section[i].size);
+
+                // Decompress .code section...
+                u32 decompressed_size = LZSS_GetDecompressedSize(&temp_buffer[0], 
+                    exefs_header.section[i].size);
+                buffer.resize(decompressed_size);
+                if (!LZSS_Decompress(&temp_buffer[0], exefs_header.section[i].size, &buffer[0],
+                    decompressed_size)) {
+                    error = ResultStatus::ErrorInvalidFormat;
+                    return buffer;
+                }
+            // Section is uncompressed...
+            } else {
+                buffer.resize(exefs_header.section[i].size);
+                file.ReadBytes(&buffer[0], exefs_header.section[i].size);
+            }
+            error = ResultStatus::Success;
+            return buffer;
+        }
+    }
+    error = ResultStatus::ErrorNotUsed;
+    return buffer;
+} 
+
+/**
+ * Loads an NCCH file (e.g. from a CCI, or the first NCCH in a CXI)
+ * @param error_string Pointer to string to put error message if an error has occurred
+ * @todo Move NCSD parsing out of here and create a separate function for loading these
+ * @return True on success, otherwise false
+ */
+ResultStatus AppLoader_NCCH::Load() {
+    INFO_LOG(LOADER, "Loading NCCH file %s...", filename.c_str());
+
+    if (is_loaded)
+        return ResultStatus::ErrorAlreadyLoaded;
+
+    file = File::IOFile(filename, "rb");
+
+    if (file.IsOpen()) {
+        file.ReadBytes(&ncch_header, sizeof(NCCH_Header));
+
+        // Skip NCSD header and load first NCCH (NCSD is just a container of NCCH files)...
+        if (0 == memcmp(&ncch_header.magic, "NCSD", 4)) {
+            WARN_LOG(LOADER, "Only loading the first (bootable) NCCH within the NCSD file!");
+            ncch_offset = 0x4000;
+            file.Seek(ncch_offset, 0);
+            file.ReadBytes(&ncch_header, sizeof(NCCH_Header));
+        }
+        
+        // Verify we are loading the correct file type...
+        if (0 != memcmp(&ncch_header.magic, "NCCH", 4))
+            return ResultStatus::ErrorInvalidFormat;
+
+        // Read ExHeader...
+
+        file.ReadBytes(&exheader_header, sizeof(ExHeader_Header));
+
+        is_compressed = (exheader_header.codeset_info.flags.flag & 1) == 1;
+        entry_point = exheader_header.codeset_info.text.address;
+
+        INFO_LOG(LOADER, "Name:            %s", exheader_header.codeset_info.name);
+        INFO_LOG(LOADER, "Code compressed: %s", is_compressed ? "yes" : "no");
+        INFO_LOG(LOADER, "Entry point:     0x%08X", entry_point);
+
+        // Read ExeFS...
+
+        exefs_offset = ncch_header.exefs_offset * kBlockSize;
+        u32 exefs_size = ncch_header.exefs_size * kBlockSize;
+
+        INFO_LOG(LOADER, "ExeFS offset:    0x%08X", exefs_offset);
+        INFO_LOG(LOADER, "ExeFS size:      0x%08X", exefs_size);
+
+        file.Seek(exefs_offset + ncch_offset, 0);
+        file.ReadBytes(&exefs_header, sizeof(ExeFs_Header));
+
+        is_loaded = true; // Set state to loaded
+
+        LoadExec(); // Load the executable into memory for booting
+
+        return ResultStatus::Success;
+    }
+    return ResultStatus::Error;
+}
+
+/**
+ * Get the code (typically .code section) of the application
+ * @param error ResultStatus result of function
+ * @return Reference to code buffer
+ */
+const std::vector<u8>& AppLoader_NCCH::ReadCode(ResultStatus& error) {
+    return LoadSectionExeFS(".code", code, error);
+}
+
+/**
+ * Get the icon (typically icon section) of the application
+ * @param error ResultStatus result of function
+ * @return Reference to icon buffer
+ */
+const std::vector<u8>& AppLoader_NCCH::ReadIcon(ResultStatus& error) {
+    return LoadSectionExeFS("icon", icon, error);
+}
+
+/**
+ * Get the banner (typically banner section) of the application
+ * @param error ResultStatus result of function
+ * @return Reference to banner buffer
+ */
+const std::vector<u8>& AppLoader_NCCH::ReadBanner(ResultStatus& error) {
+    return LoadSectionExeFS("banner", banner, error);
+}
+
+/**
+ * Get the logo (typically logo section) of the application
+ * @param error ResultStatus result of function
+ * @return Reference to logo buffer
+ */
+const std::vector<u8>& AppLoader_NCCH::ReadLogo(ResultStatus& error) {
+    return LoadSectionExeFS("logo", logo, error);
+}
+
+/**
+ * Get the RomFs archive of the application
+ * @param error ResultStatus result of function
+ * @return Reference to RomFs archive buffer
+ */
+const std::vector<u8>& AppLoader_NCCH::ReadRomFS(ResultStatus& error) {
+    // Check if the NCCH has a RomFS...
+    if (ncch_header.romfs_offset != 0 && ncch_header.romfs_size != 0) {
+        u32 romfs_offset = ncch_offset + (ncch_header.romfs_offset * kBlockSize) + 0x1000;
+        u32 romfs_size = (ncch_header.romfs_size * kBlockSize) - 0x1000;
+
+        INFO_LOG(LOADER, "RomFS offset:    0x%08X", romfs_offset);
+        INFO_LOG(LOADER, "RomFS size:      0x%08X", romfs_size);
+
+        romfs.resize(romfs_size);
+
+        file.Seek(romfs_offset, 0);
+        file.ReadBytes(&romfs[0], romfs_size);
+
+        error = ResultStatus::Success;
+        return romfs;
+    } else {
+        NOTICE_LOG(LOADER, "RomFS unused");
+    }
+    error = ResultStatus::ErrorNotUsed;
+    return romfs;
+}
+
+} // namespace Loader

src/core/loader/ncch.h

@@ -0,0 +1,227 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "common/common.h"
+#include "common/file_util.h"
+
+#include "core/loader/loader.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+/// NCCH header (Note: "NCCH" appears to be a publically unknown acronym)
+
+struct NCCH_Header {
+    u8 signature[0x100];
+    char magic[4];
+    u32 content_size;
+    u8 partition_id[8];
+    u16 maker_code;
+    u16 version;
+    u8 reserved_0[4];
+    u8 program_id[8];
+    u8 temp_flag;
+    u8 reserved_1[0x2f];
+    u8 product_code[0x10];
+    u8 extended_header_hash[0x20];
+    u32 extended_header_size;
+    u8 reserved_2[4];
+    u8 flags[8];
+    u32 plain_region_offset;
+    u32 plain_region_size;
+    u8 reserved_3[8];
+    u32 exefs_offset;
+    u32 exefs_size;
+    u32 exefs_hash_region_size;
+    u8 reserved_4[4];
+    u32 romfs_offset;
+    u32 romfs_size;
+    u32 romfs_hash_region_size;
+    u8 reserved_5[4];
+    u8 exefs_super_block_hash[0x20];
+    u8 romfs_super_block_hash[0x20];
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// ExeFS (executable file system) headers
+
+typedef struct {
+    char name[8];
+    u32 offset;
+    u32 size;
+} ExeFs_SectionHeader;
+
+typedef struct {
+    ExeFs_SectionHeader section[8];
+    u8 reserved[0x80];
+    u8 hashes[8][0x20];
+} ExeFs_Header;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// ExHeader (executable file system header) headers
+
+struct ExHeader_SystemInfoFlags{
+    u8 reserved[5];
+    u8 flag;
+    u8 remaster_version[2];
+};
+
+struct ExHeader_CodeSegmentInfo{
+    u32 address;
+    u32 num_max_pages;
+    u32 code_size;
+};
+
+struct ExHeader_CodeSetInfo {
+    u8 name[8];
+    ExHeader_SystemInfoFlags flags;
+    ExHeader_CodeSegmentInfo text;
+    u8 stacksize[4];
+    ExHeader_CodeSegmentInfo ro;
+    u8 reserved[4];
+    ExHeader_CodeSegmentInfo data;
+    u8 bsssize[4];
+};
+
+struct ExHeader_DependencyList{
+    u8 program_id[0x30][8];
+};
+
+struct ExHeader_SystemInfo{
+    u32 save_data_size;
+    u8 reserved[4];
+    u8 jump_id[8];
+    u8 reserved_2[0x30];
+};
+
+struct ExHeader_StorageInfo{
+    u8 ext_save_data_id[8];
+    u8 system_save_data_id[8];
+    u8 reserved[8];
+    u8 access_info[7];
+    u8 other_attributes;
+};
+
+struct ExHeader_ARM11_SystemLocalCaps{
+    u8 program_id[8];
+    u8 flags[8];
+    u8 resource_limit_descriptor[0x10][2];
+    ExHeader_StorageInfo storage_info;
+    u8 service_access_control[0x20][8];
+    u8 reserved[0x1f];
+    u8 resource_limit_category;
+};
+
+struct ExHeader_ARM11_KernelCaps{
+    u8 descriptors[28][4];
+    u8 reserved[0x10];
+};
+
+struct ExHeader_ARM9_AccessControl{
+    u8 descriptors[15];
+    u8 descversion;
+};
+
+struct ExHeader_Header{
+    ExHeader_CodeSetInfo codeset_info;
+    ExHeader_DependencyList dependency_list;
+    ExHeader_SystemInfo system_info;
+    ExHeader_ARM11_SystemLocalCaps arm11_system_local_caps;
+    ExHeader_ARM11_KernelCaps arm11_kernel_caps;
+    ExHeader_ARM9_AccessControl arm9_access_control;
+    struct {
+        u8 signature[0x100];
+        u8 ncch_public_key_modulus[0x100];
+        ExHeader_ARM11_SystemLocalCaps arm11_system_local_caps;
+        ExHeader_ARM11_KernelCaps arm11_kernel_caps;
+        ExHeader_ARM9_AccessControl arm9_access_control;
+    } access_desc;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Loader namespace
+
+namespace Loader {
+
+/// Loads an NCCH file (e.g. from a CCI, or the first NCCH in a CXI)
+class AppLoader_NCCH : public AppLoader {
+public:
+    AppLoader_NCCH(const std::string& filename);
+    ~AppLoader_NCCH();
+
+    /**
+     * Load the application
+     * @return ResultStatus result of function
+     */
+    ResultStatus Load();
+
+    /**
+     * Get the code (typically .code section) of the application
+     * @param error ResultStatus result of function
+     * @return Reference to code buffer
+     */
+    const std::vector<u8>& ReadCode(ResultStatus& error);
+
+    /**
+     * Get the icon (typically icon section) of the application
+     * @param error ResultStatus result of function
+     * @return Reference to icon buffer
+     */
+    const std::vector<u8>& ReadIcon(ResultStatus& error);
+
+    /**
+     * Get the banner (typically banner section) of the application
+     * @param error ResultStatus result of function
+     * @return Reference to banner buffer
+     */
+    const std::vector<u8>& ReadBanner(ResultStatus& error);
+
+    /**
+     * Get the logo (typically logo section) of the application
+     * @param error ResultStatus result of function
+     * @return Reference to logo buffer
+     */
+    const std::vector<u8>& ReadLogo(ResultStatus& error);
+
+    /**
+     * Get the RomFs archive of the application
+     * @param error ResultStatus result of function
+     * @return Reference to RomFs archive buffer
+     */
+    const std::vector<u8>& ReadRomFS(ResultStatus& error);
+
+private:
+
+    /**
+     * Reads an application ExeFS section of an NCCH file into AppLoader (e.g. .code, .logo, etc.)
+     * @param name Name of section to read out of NCCH file
+     * @param buffer Vector to read data into
+     * @param error ResultStatus result of function
+     * @return Reference to buffer of data that was read
+     */
+    const std::vector<u8>& LoadSectionExeFS(const char* name, std::vector<u8>& buffer, 
+        ResultStatus& error);
+
+    /**
+     * Loads .code section into memory for booting
+     * @return ResultStatus result of function
+     */
+    ResultStatus LoadExec();
+
+    File::IOFile    file;
+    std::string     filename;
+
+    bool            is_loaded;
+    bool            is_compressed;
+
+    u32             entry_point;
+    u32             ncch_offset; // Offset to NCCH header, can be 0 or after NCSD header
+    u32             exefs_offset;
+    
+    NCCH_Header     ncch_header;
+    ExeFs_Header    exefs_header;
+    ExHeader_Header exheader_header;
+};
+
+} // namespace Loader

src/core/mem_map.h

@@ -139,6 +139,8 @@ void Write8(const u32 addr, const u8 data);
 void Write16(const u32 addr, const u16 data);
 void Write32(const u32 addr, const u32 data);
 
+void WriteBlock(const u32 addr, const u8* data, const int size);
+
 u8* GetPointer(const u32 Address);
 
 /**

src/core/mem_map_funcs.cpp

@@ -293,4 +293,16 @@ void Write64(const u32 addr, const u64 data) {
     _Write<u64_le>(addr, data);
 }
 
+void WriteBlock(const u32 addr, const u8* data, const int size) {
+    int offset = 0;
+    while (offset < (size & ~3))
+        Write32(addr + offset, *(u32*)&data[offset += 4]);
+
+    if (size & 2)
+        Write16(addr + offset, *(u16*)&data[offset += 2]);
+
+    if (size & 1)
+        Write8(addr + offset, data[offset]);
+}
+
 } // namespace