44 files changed, 1055 insertions, 351 deletions

diff --git a/src/common/common_types.h b/src/common/common_types.h
index ee18eac81..844d34965 100644
--- a/src/common/common_types.h
+++ b/src/common/common_types.h
@@ -24,6 +24,7 @@
 
 #pragma once
 
+#include <array>
 #include <cstdint>
 
 #ifdef _MSC_VER
@@ -47,8 +48,11 @@ typedef double f64; ///< 64-bit floating point
 
 // TODO: It would be nice to eventually replace these with strong types that prevent accidental
 // conversion between each other.
-typedef u32 VAddr; ///< Represents a pointer in the userspace virtual address space.
-typedef u32 PAddr; ///< Represents a pointer in the ARM11 physical address space.
+typedef u64 VAddr; ///< Represents a pointer in the userspace virtual address space.
+typedef u64 PAddr; ///< Represents a pointer in the ARM11 physical address space.
+
+using u128 = std::array<std::uint64_t, 2>;
+static_assert(sizeof(u128) == 16, "u128 must be 128 bits wide");
 
 // An inheritable class to disallow the copy constructor and operator= functions
 class NonCopyable {
diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
index 2618da18c..8b25eaf0a 100644
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -6,6 +6,8 @@ set(SRCS
             arm/dyncom/arm_dyncom_interpreter.cpp
             arm/dyncom/arm_dyncom_thumb.cpp
             arm/dyncom/arm_dyncom_trans.cpp
+            arm/unicorn/arm_unicorn.cpp
+            arm/unicorn/unicorn_dynload.c
             arm/skyeye_common/armstate.cpp
             arm/skyeye_common/armsupp.cpp
             arm/skyeye_common/vfp/vfp.cpp
@@ -178,8 +180,11 @@ 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
             memory.cpp
@@ -199,6 +204,8 @@ set(HEADERS
             arm/dyncom/arm_dyncom_run.h
             arm/dyncom/arm_dyncom_thumb.h
             arm/dyncom/arm_dyncom_trans.h
+            arm/unicorn/arm_unicorn.h
+            arm/unicorn/unicorn_dynload.h
             arm/skyeye_common/arm_regformat.h
             arm/skyeye_common/armstate.h
             arm/skyeye_common/armsupp.h
@@ -379,8 +386,11 @@ 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
             tracer/citrace.h
@@ -395,7 +405,7 @@ set(HEADERS
 create_directory_groups(${SRCS} ${HEADERS})
 add_library(core STATIC ${SRCS} ${HEADERS})
 target_link_libraries(core PUBLIC common PRIVATE audio_core network video_core)
-target_link_libraries(core PUBLIC Boost::boost PRIVATE cryptopp dynarmic fmt)
+target_link_libraries(core PUBLIC Boost::boost PRIVATE cryptopp dynarmic fmt lz4_static)
 if (ENABLE_WEB_SERVICE)
     target_link_libraries(core PUBLIC json-headers web_service)
 endif()
diff --git a/src/core/arm/arm_interface.h b/src/core/arm/arm_interface.h
index ba528403c..0b3096347 100644
--- a/src/core/arm/arm_interface.h
+++ b/src/core/arm/arm_interface.h
@@ -5,6 +5,7 @@
 #pragma once
 
 #include "common/common_types.h"
+#include "core/hle/kernel/vm_manager.h"
 #include "core/arm/skyeye_common/arm_regformat.h"
 #include "core/arm/skyeye_common/vfp/asm_vfp.h"
 
@@ -14,14 +15,18 @@ public:
     virtual ~ARM_Interface() {}
 
     struct ThreadContext {
-        u32 cpu_registers[13];
-        u32 sp;
-        u32 lr;
-        u32 pc;
-        u32 cpsr;
-        u32 fpu_registers[64];
-        u32 fpscr;
-        u32 fpexc;
+        u64 cpu_registers[30];
+        u64 lr;
+        u64 sp;
+        u64 pc;
+        u64 cpsr;
+        u128 fpu_registers[32];
+        u64 fpscr;
+        u64 fpexc;
+
+
+        // TODO(bunnei): Fix once we have proper support for tpidrro_el0, etc. in the JIT
+        VAddr tls_address;
     };
 
     /**
@@ -38,6 +43,8 @@ public:
         Run(1);
     }
 
+    virtual void MapBackingMemory(VAddr address, size_t size, u8* memory, Kernel::VMAPermission perms) {}
+
     /// Clear all instruction cache
     virtual void ClearInstructionCache() = 0;
 
@@ -48,27 +55,31 @@ public:
      * Set the Program Counter to an address
      * @param addr Address to set PC to
      */
-    virtual void SetPC(u32 addr) = 0;
+    virtual void SetPC(u64 addr) = 0;
 
     /*
      * Get the current Program Counter
      * @return Returns current PC
      */
-    virtual u32 GetPC() const = 0;
+    virtual u64 GetPC() const = 0;
 
     /**
      * Get an ARM register
-     * @param index Register index (0-15)
+     * @param index Register index
      * @return Returns the value in the register
      */
-    virtual u32 GetReg(int index) const = 0;
+    virtual u64 GetReg(int index) const = 0;
 
     /**
      * Set an ARM register
-     * @param index Register index (0-15)
+     * @param index Register index
      * @param value Value to set register to
      */
-    virtual void SetReg(int index, u32 value) = 0;
+    virtual void SetReg(int index, u64 value) = 0;
+
+    virtual const u128& GetExtReg(int index) const = 0;
+
+    virtual void SetExtReg(int index, u128& value) = 0;
 
     /**
      * Gets the value of a VFP register
@@ -124,6 +135,10 @@ public:
      */
     virtual void SetCP15Register(CP15Register reg, u32 value) = 0;
 
+    virtual VAddr GetTlsAddress() const = 0;
+
+    virtual void SetTlsAddress(VAddr address) = 0;
+
     /**
      * Saves the current CPU context
      * @param ctx Thread context to save
diff --git a/src/core/arm/dynarmic/arm_dynarmic.cpp b/src/core/arm/dynarmic/arm_dynarmic.cpp
index 2cb56d12f..6dcab5bab 100644
--- a/src/core/arm/dynarmic/arm_dynarmic.cpp
+++ b/src/core/arm/dynarmic/arm_dynarmic.cpp
@@ -14,98 +14,108 @@
 #include "core/hle/svc.h"
 #include "core/memory.h"
 
-static void InterpreterFallback(u32 pc, Dynarmic::Jit* jit, void* user_arg) {
-    ARMul_State* state = static_cast<ARMul_State*>(user_arg);
+static void InterpreterFallback(u64 pc, Dynarmic::Jit* jit, void* user_arg) {
+    UNIMPLEMENTED_MSG("InterpreterFallback for ARM64 JIT does not exist!");
+}
 
-    state->Reg = jit->Regs();
-    state->Cpsr = jit->Cpsr();
-    state->Reg[15] = pc;
-    state->ExtReg = jit->ExtRegs();
-    state->VFP[VFP_FPSCR] = jit->Fpscr();
-    state->NumInstrsToExecute = 1;
+static bool IsReadOnlyMemory(u64 vaddr) {
+    // TODO(bunnei): ImplementMe
+    return false;
+}
 
-    InterpreterMainLoop(state);
+u8 MemoryRead8(const u64 addr) {
+    return Memory::Read8(static_cast<VAddr>(addr));
+}
 
-    bool is_thumb = (state->Cpsr & (1 << 5)) != 0;
-    state->Reg[15] &= (is_thumb ? 0xFFFFFFFE : 0xFFFFFFFC);
+u16 MemoryRead16(const u64 addr) {
+    return Memory::Read16(static_cast<VAddr>(addr));
+}
 
-    jit->Regs() = state->Reg;
-    jit->Cpsr() = state->Cpsr;
-    jit->ExtRegs() = state->ExtReg;
-    jit->SetFpscr(state->VFP[VFP_FPSCR]);
+u32 MemoryRead32(const u64 addr) {
+    return Memory::Read32(static_cast<VAddr>(addr));
 }
 
-static bool IsReadOnlyMemory(u32 vaddr) {
-    // TODO(bunnei): ImplementMe
-    return false;
+u64 MemoryRead64(const u64 addr) {
+    return Memory::Read64(static_cast<VAddr>(addr));
+}
+
+void MemoryWrite8(const u64 addr, const u8 data) {
+    Memory::Write8(static_cast<VAddr>(addr), data);
+}
+
+void MemoryWrite16(const u64 addr, const u16 data) {
+    Memory::Write16(static_cast<VAddr>(addr), data);
+}
+
+void MemoryWrite32(const u64 addr, const u32 data) {
+    Memory::Write32(static_cast<VAddr>(addr), data);
+}
+
+void MemoryWrite64(const u64 addr, const u64 data) {
+    Memory::Write64(static_cast<VAddr>(addr), data);
 }
 
-static Dynarmic::UserCallbacks GetUserCallbacks(
-    const std::shared_ptr<ARMul_State>& interpeter_state, Memory::PageTable* current_page_table) {
+static Dynarmic::UserCallbacks GetUserCallbacks(ARM_Dynarmic* this_) {
     Dynarmic::UserCallbacks user_callbacks{};
     user_callbacks.InterpreterFallback = &InterpreterFallback;
-    user_callbacks.user_arg = static_cast<void*>(interpeter_state.get());
+    user_callbacks.user_arg = static_cast<void*>(this_);
     user_callbacks.CallSVC = &SVC::CallSVC;
     user_callbacks.memory.IsReadOnlyMemory = &IsReadOnlyMemory;
-    user_callbacks.memory.ReadCode = &Memory::Read32;
-    user_callbacks.memory.Read8 = &Memory::Read8;
-    user_callbacks.memory.Read16 = &Memory::Read16;
-    user_callbacks.memory.Read32 = &Memory::Read32;
-    user_callbacks.memory.Read64 = &Memory::Read64;
-    user_callbacks.memory.Write8 = &Memory::Write8;
-    user_callbacks.memory.Write16 = &Memory::Write16;
-    user_callbacks.memory.Write32 = &Memory::Write32;
-    user_callbacks.memory.Write64 = &Memory::Write64;
-    user_callbacks.page_table = &current_page_table->pointers;
-    user_callbacks.coprocessors[15] = std::make_shared<DynarmicCP15>(interpeter_state);
+    user_callbacks.memory.ReadCode = &MemoryRead32;
+    user_callbacks.memory.Read8 = &MemoryRead8;
+    user_callbacks.memory.Read16 = &MemoryRead16;
+    user_callbacks.memory.Read32 = &MemoryRead32;
+    user_callbacks.memory.Read64 = &MemoryRead64;
+    user_callbacks.memory.Write8 = &MemoryWrite8;
+    user_callbacks.memory.Write16 = &MemoryWrite16;
+    user_callbacks.memory.Write32 = &MemoryWrite32;
+    user_callbacks.memory.Write64 = &MemoryWrite64;
+    //user_callbacks.page_table = Memory::GetCurrentPageTablePointers();
     return user_callbacks;
 }
 
 ARM_Dynarmic::ARM_Dynarmic(PrivilegeMode initial_mode) {
-    interpreter_state = std::make_shared<ARMul_State>(initial_mode);
-    PageTableChanged();
 }
 
-void ARM_Dynarmic::SetPC(u32 pc) {
-    jit->Regs()[15] = pc;
+void ARM_Dynarmic::MapBackingMemory(VAddr address, size_t size, u8* memory, Kernel::VMAPermission perms) {
+}
+
+void ARM_Dynarmic::SetPC(u64 pc) {
+    jit->Regs64()[32] = pc;
+}
+
+u64 ARM_Dynarmic::GetPC() const {
+    return jit->Regs64()[32];
+}
+
+u64 ARM_Dynarmic::GetReg(int index) const {
+    return jit->Regs64()[index];
 }
 
-u32 ARM_Dynarmic::GetPC() const {
-    return jit->Regs()[15];
+void ARM_Dynarmic::SetReg(int index, u64 value) {
+    jit->Regs64()[index] = value;
 }
 
-u32 ARM_Dynarmic::GetReg(int index) const {
-    return jit->Regs()[index];
+const u128& ARM_Dynarmic::GetExtReg(int index) const {
+    return jit->ExtRegs64()[index];
 }
 
-void ARM_Dynarmic::SetReg(int index, u32 value) {
-    jit->Regs()[index] = value;
+void ARM_Dynarmic::SetExtReg(int index, u128& value) {
+    jit->ExtRegs64()[index] = value;
 }
 
 u32 ARM_Dynarmic::GetVFPReg(int index) const {
-    return jit->ExtRegs()[index];
+    return {};
 }
 
 void ARM_Dynarmic::SetVFPReg(int index, u32 value) {
-    jit->ExtRegs()[index] = value;
 }
 
 u32 ARM_Dynarmic::GetVFPSystemReg(VFPSystemRegister reg) const {
-    if (reg == VFP_FPSCR) {
-        return jit->Fpscr();
-    }
-
-    // Dynarmic does not implement and/or expose other VFP registers, fallback to interpreter state
-    return interpreter_state->VFP[reg];
+    return {};
 }
 
 void ARM_Dynarmic::SetVFPSystemReg(VFPSystemRegister reg, u32 value) {
-    if (reg == VFP_FPSCR) {
-        jit->SetFpscr(value);
-    }
-
-    // Dynarmic does not implement and/or expose other VFP registers, fallback to interpreter state
-    interpreter_state->VFP[reg] = value;
 }
 
 u32 ARM_Dynarmic::GetCPSR() const {
@@ -117,11 +127,18 @@ void ARM_Dynarmic::SetCPSR(u32 cpsr) {
 }
 
 u32 ARM_Dynarmic::GetCP15Register(CP15Register reg) {
-    return interpreter_state->CP15[reg];
+    return {};
 }
 
 void ARM_Dynarmic::SetCP15Register(CP15Register reg, u32 value) {
-    interpreter_state->CP15[reg] = value;
+}
+
+VAddr ARM_Dynarmic::GetTlsAddress() const {
+    return jit->TlsAddr();
+}
+
+void ARM_Dynarmic::SetTlsAddress(VAddr address) {
+    jit->TlsAddr() = address;
 }
 
 MICROPROFILE_DEFINE(ARM_Jit, "ARM JIT", "ARM JIT", MP_RGB(255, 64, 64));
@@ -136,29 +153,29 @@ void ARM_Dynarmic::ExecuteInstructions(int num_instructions) {
 }
 
 void ARM_Dynarmic::SaveContext(ARM_Interface::ThreadContext& ctx) {
-    memcpy(ctx.cpu_registers, jit->Regs().data(), sizeof(ctx.cpu_registers));
-    memcpy(ctx.fpu_registers, jit->ExtRegs().data(), sizeof(ctx.fpu_registers));
+    memcpy(ctx.cpu_registers, jit->Regs64().data(), sizeof(ctx.cpu_registers));
+    memcpy(ctx.fpu_registers, jit->ExtRegs64().data(), sizeof(ctx.fpu_registers));
 
-    ctx.sp = jit->Regs()[13];
-    ctx.lr = jit->Regs()[14];
-    ctx.pc = jit->Regs()[15];
+    ctx.lr = jit->Regs64()[30];
+    ctx.sp = jit->Regs64()[31];
+    ctx.pc = jit->Regs64()[32];
     ctx.cpsr = jit->Cpsr();
 
-    ctx.fpscr = jit->Fpscr();
-    ctx.fpexc = interpreter_state->VFP[VFP_FPEXC];
+    // TODO(bunnei): Fix once we have proper support for tpidrro_el0, etc. in the JIT
+    ctx.tls_address = jit->TlsAddr();
 }
 
 void ARM_Dynarmic::LoadContext(const ARM_Interface::ThreadContext& ctx) {
-    memcpy(jit->Regs().data(), ctx.cpu_registers, sizeof(ctx.cpu_registers));
-    memcpy(jit->ExtRegs().data(), ctx.fpu_registers, sizeof(ctx.fpu_registers));
+    memcpy(jit->Regs64().data(), ctx.cpu_registers, sizeof(ctx.cpu_registers));
+    memcpy(jit->ExtRegs64().data(), ctx.fpu_registers, sizeof(ctx.fpu_registers));
 
-    jit->Regs()[13] = ctx.sp;
-    jit->Regs()[14] = ctx.lr;
-    jit->Regs()[15] = ctx.pc;
+    jit->Regs64()[30] = ctx.lr;
+    jit->Regs64()[31] = ctx.sp;
+    jit->Regs64()[32] = ctx.pc;
     jit->Cpsr() = ctx.cpsr;
 
-    jit->SetFpscr(ctx.fpscr);
-    interpreter_state->VFP[VFP_FPEXC] = ctx.fpexc;
+    // TODO(bunnei): Fix once we have proper support for tpidrro_el0, etc. in the JIT
+    jit->TlsAddr() = ctx.tls_address;
 }
 
 void ARM_Dynarmic::PrepareReschedule() {
@@ -180,6 +197,6 @@ void ARM_Dynarmic::PageTableChanged() {
         return;
     }
 
-    jit = new Dynarmic::Jit(GetUserCallbacks(interpreter_state, current_page_table));
+    jit = new Dynarmic::Jit(GetUserCallbacks(this), Dynarmic::Arch::ARM64);
     jits.emplace(current_page_table, std::unique_ptr<Dynarmic::Jit>(jit));
 }
diff --git a/src/core/arm/dynarmic/arm_dynarmic.h b/src/core/arm/dynarmic/arm_dynarmic.h
index 0b00158a5..6567359b0 100644
--- a/src/core/arm/dynarmic/arm_dynarmic.h
+++ b/src/core/arm/dynarmic/arm_dynarmic.h
@@ -19,10 +19,14 @@ class ARM_Dynarmic final : public ARM_Interface {
 public:
     ARM_Dynarmic(PrivilegeMode initial_mode);
 
-    void SetPC(u32 pc) override;
-    u32 GetPC() const override;
-    u32 GetReg(int index) const override;
-    void SetReg(int index, u32 value) override;
+    void MapBackingMemory(VAddr address, size_t size, u8* memory, Kernel::VMAPermission perms) override;
+
+    void SetPC(u64 pc) override;
+    u64 GetPC() const override;
+    u64 GetReg(int index) const override;
+    void SetReg(int index, u64 value) override;
+    const u128& GetExtReg(int index) const override;
+    void SetExtReg(int index, u128& value) override;
     u32 GetVFPReg(int index) const override;
     void SetVFPReg(int index, u32 value) override;
     u32 GetVFPSystemReg(VFPSystemRegister reg) const override;
@@ -31,6 +35,8 @@ public:
     void SetCPSR(u32 cpsr) override;
     u32 GetCP15Register(CP15Register reg) override;
     void SetCP15Register(CP15Register reg, u32 value) override;
+    VAddr GetTlsAddress() const override;
+    void SetTlsAddress(VAddr address) override;
 
     void SaveContext(ThreadContext& ctx) override;
     void LoadContext(const ThreadContext& ctx) override;
@@ -45,5 +51,4 @@ private:
     Dynarmic::Jit* jit = nullptr;
     Memory::PageTable* current_page_table = nullptr;
     std::map<Memory::PageTable*, std::unique_ptr<Dynarmic::Jit>> jits;
-    std::shared_ptr<ARMul_State> interpreter_state;
 };
diff --git a/src/core/arm/dyncom/arm_dyncom.cpp b/src/core/arm/dyncom/arm_dyncom.cpp
index 4d72aef77..5ebf7a2f1 100644
--- a/src/core/arm/dyncom/arm_dyncom.cpp
+++ b/src/core/arm/dyncom/arm_dyncom.cpp
@@ -25,26 +25,33 @@ void ARM_DynCom::ClearInstructionCache() {
     trans_cache_buf_top = 0;
 }
 
-void ARM_DynCom::PageTableChanged() {
-    ClearInstructionCache();
+void ARM_DynCom::SetPC(u64 pc) {
+    state->Reg[15] = pc;
 }
 
-void ARM_DynCom::SetPC(u32 pc) {
-    state->Reg[15] = pc;
+void ARM_DynCom::PageTableChanged() {
+    ClearInstructionCache();
 }
 
-u32 ARM_DynCom::GetPC() const {
+u64 ARM_DynCom::GetPC() const {
     return state->Reg[15];
 }
 
-u32 ARM_DynCom::GetReg(int index) const {
+u64 ARM_DynCom::GetReg(int index) const {
     return state->Reg[index];
 }
 
-void ARM_DynCom::SetReg(int index, u32 value) {
+void ARM_DynCom::SetReg(int index, u64 value) {
     state->Reg[index] = value;
 }
 
+const u128& ARM_DynCom::GetExtReg(int index) const {
+    return {};
+}
+
+void ARM_DynCom::SetExtReg(int index, u128& value) {
+}
+
 u32 ARM_DynCom::GetVFPReg(int index) const {
     return state->ExtReg[index];
 }
@@ -77,6 +84,13 @@ void ARM_DynCom::SetCP15Register(CP15Register reg, u32 value) {
     state->CP15[reg] = value;
 }
 
+VAddr ARM_DynCom::GetTlsAddress() const {
+    return {};
+}
+
+void ARM_DynCom::SetTlsAddress(VAddr /*address*/) {
+}
+
 void ARM_DynCom::ExecuteInstructions(int num_instructions) {
     state->NumInstrsToExecute = num_instructions;
 
diff --git a/src/core/arm/dyncom/arm_dyncom.h b/src/core/arm/dyncom/arm_dyncom.h
index fc1ffed6a..cc3c0f3da 100644
--- a/src/core/arm/dyncom/arm_dyncom.h
+++ b/src/core/arm/dyncom/arm_dyncom.h
@@ -18,10 +18,12 @@ public:
     void ClearInstructionCache() override;
     void PageTableChanged() override;
 
-    void SetPC(u32 pc) override;
-    u32 GetPC() const override;
-    u32 GetReg(int index) const override;
-    void SetReg(int index, u32 value) override;
+    void SetPC(u64 pc) override;
+    u64 GetPC() const override;
+    u64 GetReg(int index) const override;
+    void SetReg(int index, u64 value) override;
+    const u128& GetExtReg(int index) const override;
+    void SetExtReg(int index, u128& value) override;
     u32 GetVFPReg(int index) const override;
     void SetVFPReg(int index, u32 value) override;
     u32 GetVFPSystemReg(VFPSystemRegister reg) const override;
@@ -30,6 +32,8 @@ public:
     void SetCPSR(u32 cpsr) override;
     u32 GetCP15Register(CP15Register reg) override;
     void SetCP15Register(CP15Register reg, u32 value) override;
+    VAddr GetTlsAddress() const override;
+    void SetTlsAddress(VAddr address) override;
 
     void SaveContext(ThreadContext& ctx) override;
     void LoadContext(const ThreadContext& ctx) override;
diff --git a/src/core/core.cpp b/src/core/core.cpp
index 0c7a72987..c5448630f 100644
--- a/src/core/core.cpp
+++ b/src/core/core.cpp
@@ -9,6 +9,7 @@
 #include "core/arm/arm_interface.h"
 #include "core/arm/dynarmic/arm_dynarmic.h"
 #include "core/arm/dyncom/arm_dyncom.h"
+#include "core/arm/unicorn/arm_unicorn.h"
 #include "core/core.h"
 #include "core/core_timing.h"
 #include "core/gdbstub/gdbstub.h"
@@ -115,7 +116,6 @@ System::ResultStatus System::Load(EmuWindow* emu_window, const std::string& file
             return ResultStatus::ErrorLoader;
         }
     }
-    Memory::SetCurrentPageTable(&Kernel::g_current_process->vm_manager.page_table);
     status = ResultStatus::Success;
     return status;
 }
diff --git a/src/core/file_sys/archive_savedata.cpp b/src/core/file_sys/archive_savedata.cpp
index 61f7654f7..67076c73f 100644
--- a/src/core/file_sys/archive_savedata.cpp
+++ b/src/core/file_sys/archive_savedata.cpp
@@ -15,16 +15,19 @@ ArchiveFactory_SaveData::ArchiveFactory_SaveData(
     : sd_savedata_source(sd_savedata) {}
 
 ResultVal<std::unique_ptr<ArchiveBackend>> ArchiveFactory_SaveData::Open(const Path& path) {
-    return sd_savedata_source->Open(Kernel::g_current_process->codeset->program_id);
+    UNIMPLEMENTED();
+    return {}; //sd_savedata_source->Open(Kernel::g_current_process->codeset->program_id);
 }
 
 ResultCode ArchiveFactory_SaveData::Format(const Path& path,
                                            const FileSys::ArchiveFormatInfo& format_info) {
-    return sd_savedata_source->Format(Kernel::g_current_process->codeset->program_id, format_info);
+    UNIMPLEMENTED();
+    return RESULT_SUCCESS; //sd_savedata_source->Format(Kernel::g_current_process->codeset->program_id, format_info);
 }
 
 ResultVal<ArchiveFormatInfo> ArchiveFactory_SaveData::GetFormatInfo(const Path& path) const {
-    return sd_savedata_source->GetFormatInfo(Kernel::g_current_process->codeset->program_id);
+    UNIMPLEMENTED();
+    return {}; //sd_savedata_source->GetFormatInfo(Kernel::g_current_process->codeset->program_id);
 }
 
 } // namespace FileSys
diff --git a/src/core/file_sys/archive_selfncch.cpp b/src/core/file_sys/archive_selfncch.cpp
index a16941c70..3222000cf 100644
--- a/src/core/file_sys/archive_selfncch.cpp
+++ b/src/core/file_sys/archive_selfncch.cpp
@@ -278,9 +278,10 @@ void ArchiveFactory_SelfNCCH::Register(Loader::AppLoader& app_loader) {
 }
 
 ResultVal<std::unique_ptr<ArchiveBackend>> ArchiveFactory_SelfNCCH::Open(const Path& path) {
-    auto archive = std::make_unique<SelfNCCHArchive>(
-        ncch_data[Kernel::g_current_process->codeset->program_id]);
-    return MakeResult<std::unique_ptr<ArchiveBackend>>(std::move(archive));
+    //auto archive = std::make_unique<SelfNCCHArchive>(
+    //    ncch_data[Kernel::g_current_process->codeset->program_id]);
+    //return MakeResult<std::unique_ptr<ArchiveBackend>>(std::move(archive));
+    return {};
 }
 
 ResultCode ArchiveFactory_SelfNCCH::Format(const Path&, const FileSys::ArchiveFormatInfo&) {
diff --git a/src/core/gdbstub/gdbstub.h b/src/core/gdbstub/gdbstub.h
index 38177e32c..8f12c6a1d 100644
--- a/src/core/gdbstub/gdbstub.h
+++ b/src/core/gdbstub/gdbstub.h
@@ -69,7 +69,7 @@ void HandlePacket();
  * @param addr Address to search from.
  * @param type Type of breakpoint.
  */
-BreakpointAddress GetNextBreakpointFromAddress(u32 addr, GDBStub::BreakpointType type);
+BreakpointAddress GetNextBreakpointFromAddress(PAddr addr, GDBStub::BreakpointType type);
 
 /**
  * Check if a breakpoint of the specified type exists at the given address.
@@ -77,7 +77,7 @@ BreakpointAddress GetNextBreakpointFromAddress(u32 addr, GDBStub::BreakpointType
  * @param addr Address of breakpoint.
  * @param type Type of breakpoint.
  */
-bool CheckBreakpoint(u32 addr, GDBStub::BreakpointType type);
+bool CheckBreakpoint(PAddr addr, GDBStub::BreakpointType type);
 
 // If set to true, the CPU will halt at the beginning of the next CPU loop.
 bool GetCpuHaltFlag();
diff --git a/src/core/hle/function_wrappers.h b/src/core/hle/function_wrappers.h
index f93439f21..31fda6db3 100644
--- a/src/core/hle/function_wrappers.h
+++ b/src/core/hle/function_wrappers.h
@@ -20,23 +20,41 @@ namespace HLE {
  * HLE a function return from the current ARM11 userland process
  * @param res Result to return
  */
-static inline void FuncReturn(u32 res) {
+static inline void FuncReturn(u64 res) {
     Core::CPU().SetReg(0, res);
 }
 
-/**
- * HLE a function return (64-bit) from the current ARM11 userland process
- * @param res Result to return (64-bit)
- * @todo Verify that this function is correct
- */
-static inline void FuncReturn64(u64 res) {
-    Core::CPU().SetReg(0, (u32)(res & 0xFFFFFFFF));
-    Core::CPU().SetReg(1, (u32)((res >> 32) & 0xFFFFFFFF));
-}
-
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Function wrappers that return type ResultCode
 
+template <ResultCode func(u64)>
+void Wrap() {
+    FuncReturn(func(PARAM(0)).raw);
+}
+
+template <ResultCode func(u32, u64, u32)>
+void Wrap() {
+    FuncReturn(func(PARAM(0), PARAM(1), PARAM(2)).raw);
+}
+
+template <ResultCode func(u64, u32)>
+void Wrap() {
+    FuncReturn(func(PARAM(0), PARAM(1)).raw);
+}
+
+template <ResultCode func(u64, u64, u64)>
+void Wrap() {
+    FuncReturn(func(PARAM(0), PARAM(1), PARAM(2)).raw);
+}
+
+template <ResultCode func(u64*, u64, u64, u64)>
+void Wrap() {
+    u64 param_1 = 0;
+    u32 retval = func(&param_1, PARAM(1), PARAM(2), PARAM(3)).raw;
+    Core::CPU().SetReg(1, param_1);
+    FuncReturn(retval);
+}
+
 template <ResultCode func(u32, u32, u32, u32)>
 void Wrap() {
     FuncReturn(func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)).raw);
@@ -84,6 +102,14 @@ void Wrap() {
         func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), (((s64)PARAM(5) << 32) | PARAM(4))).raw);
 }
 
+template <ResultCode func(u32, u64*)>
+void Wrap() {
+    u64 param_1 = 0;
+    u32 retval = func(PARAM(0), &param_1).raw;
+    Core::CPU().SetReg(1, param_1);
+    FuncReturn(retval);
+}
+
 template <ResultCode func(u32*)>
 void Wrap() {
     u32 param_1 = 0;
@@ -99,16 +125,17 @@ void Wrap() {
     FuncReturn(retval);
 }
 
-template <ResultCode func(MemoryInfo*, PageInfo*, u32)>
+template <ResultCode func(MemoryInfo*, PageInfo*, u64)>
 void Wrap() {
     MemoryInfo memory_info = {};
     PageInfo page_info = {};
     u32 retval = func(&memory_info, &page_info, PARAM(2)).raw;
-    Core::CPU().SetReg(1, memory_info.base_address);
-    Core::CPU().SetReg(2, memory_info.size);
-    Core::CPU().SetReg(3, memory_info.permission);
-    Core::CPU().SetReg(4, memory_info.state);
-    Core::CPU().SetReg(5, page_info.flags);
+
+    Memory::Write64(PARAM(0), memory_info.base_address);
+    Memory::Write64(PARAM(0) + 8, memory_info.size);
+    Memory::Write64(PARAM(0) + 16, memory_info.permission);
+    Memory::Write64(PARAM(0) + 24, memory_info.state);
+
     FuncReturn(retval);
 }
 
@@ -138,7 +165,7 @@ void Wrap() {
     FuncReturn(func(PARAM(0), (s32)PARAM(1)).raw);
 }
 
-template <ResultCode func(u32*, u32)>
+template <ResultCode func(u32*, u64)>
 void Wrap() {
     u32 param_1 = 0;
     u32 retval = func(&param_1, PARAM(1)).raw;
@@ -226,6 +253,11 @@ void Wrap() {
     FuncReturn(retval);
 }
 
+template <ResultCode func(u32, u32, u32)>
+void Wrap() {
+    FuncReturn(func(PARAM(0), PARAM(1), PARAM(2)).raw);
+}
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Function wrappers that return type u32
 
@@ -255,9 +287,9 @@ void Wrap() {
     func(PARAM(0), PARAM(1));
 }
 
-template <void func(u8)>
+template <void func(u64, u64, u64)>
 void Wrap() {
-    func((u8)PARAM(0));
+    func(PARAM(0), PARAM(1), PARAM(2));
 }
 
 #undef PARAM
diff --git a/src/core/hle/kernel/mutex.cpp b/src/core/hle/kernel/mutex.cpp
index 2cbca5e5b..30dade552 100644
--- a/src/core/hle/kernel/mutex.cpp
+++ b/src/core/hle/kernel/mutex.cpp
@@ -25,10 +25,11 @@ void ReleaseThreadMutexes(Thread* thread) {
 Mutex::Mutex() {}
 Mutex::~Mutex() {}
 
-SharedPtr<Mutex> Mutex::Create(bool initial_locked, std::string name) {
+SharedPtr<Mutex> Mutex::Create(bool initial_locked, VAddr addr, std::string name) {
     SharedPtr<Mutex> mutex(new Mutex);
 
     mutex->lock_count = 0;
+    mutex->addr = addr;
     mutex->name = std::move(name);
     mutex->holding_thread = nullptr;
 
diff --git a/src/core/hle/kernel/mutex.h b/src/core/hle/kernel/mutex.h
index bacacd690..503d3ee75 100644
--- a/src/core/hle/kernel/mutex.h
+++ b/src/core/hle/kernel/mutex.h
@@ -21,7 +21,7 @@ public:
      * @param name Optional name of mutex
      * @return Pointer to new Mutex object
      */
-    static SharedPtr<Mutex> Create(bool initial_locked, std::string name = "Unknown");
+    static SharedPtr<Mutex> Create(bool initial_locked, VAddr addr, std::string name = "Unknown");
 
     std::string GetTypeName() const override {
         return "Mutex";
@@ -39,6 +39,7 @@ public:
     u32 priority;                     ///< The priority of the mutex, used for priority inheritance.
     std::string name;                 ///< Name of mutex (optional)
     SharedPtr<Thread> holding_thread; ///< Thread that has acquired the mutex
+    VAddr addr;
 
     /**
      * Elevate the mutex priority to the best priority
diff --git a/src/core/hle/kernel/process.cpp b/src/core/hle/kernel/process.cpp
index cf3163e0f..9e145866f 100644
--- a/src/core/hle/kernel/process.cpp
+++ b/src/core/hle/kernel/process.cpp
@@ -30,10 +30,10 @@ CodeSet::~CodeSet() {}
 
 u32 Process::next_process_id;
 
-SharedPtr<Process> Process::Create(SharedPtr<CodeSet> code_set) {
+SharedPtr<Process> Process::Create(std::string&& name) {
     SharedPtr<Process> process(new Process);
 
-    process->codeset = std::move(code_set);
+    process->name = std::move(name);
     process->flags.raw = 0;
     process->flags.memory_region.Assign(MemoryRegion::APPLICATION);
 
@@ -112,25 +112,7 @@ void Process::ParseKernelCaps(const u32* kernel_caps, size_t len) {
     }
 }
 
-void Process::Run(s32 main_thread_priority, u32 stack_size) {
-    memory_region = GetMemoryRegion(flags.memory_region);
-
-    auto MapSegment = [&](CodeSet::Segment& segment, VMAPermission permissions,
-                          MemoryState memory_state) {
-        auto vma = vm_manager
-                       .MapMemoryBlock(segment.addr, codeset->memory, segment.offset, segment.size,
-                                       memory_state)
-                       .Unwrap();
-        vm_manager.Reprotect(vma, permissions);
-        misc_memory_used += segment.size;
-        memory_region->used += segment.size;
-    };
-
-    // Map CodeSet segments
-    MapSegment(codeset->code, VMAPermission::ReadExecute, MemoryState::Code);
-    MapSegment(codeset->rodata, VMAPermission::Read, MemoryState::Code);
-    MapSegment(codeset->data, VMAPermission::ReadWrite, MemoryState::Private);
-
+void Process::Run(VAddr entry_point, s32 main_thread_priority, u32 stack_size) {
     // Allocate and map stack
     vm_manager
         .MapMemoryBlock(Memory::HEAP_VADDR_END - stack_size,
@@ -147,7 +129,28 @@ void Process::Run(s32 main_thread_priority, u32 stack_size) {
     }
 
     vm_manager.LogLayout(Log::Level::Debug);
-    Kernel::SetupMainThread(codeset->entrypoint, main_thread_priority, this);
+
+    Kernel::SetupMainThread(entry_point, main_thread_priority, this);
+}
+
+void Process::LoadModule(SharedPtr<CodeSet> module_, VAddr base_addr) {
+    memory_region = GetMemoryRegion(flags.memory_region);
+
+    auto MapSegment = [&](CodeSet::Segment& segment, VMAPermission permissions,
+        MemoryState memory_state) {
+        auto vma = vm_manager
+            .MapMemoryBlock(segment.addr + base_addr, module_->memory, segment.offset, segment.size,
+                memory_state)
+            .Unwrap();
+        vm_manager.Reprotect(vma, permissions);
+        misc_memory_used += segment.size;
+        memory_region->used += segment.size;
+    };
+
+    // Map CodeSet segments
+    MapSegment(module_->code, VMAPermission::ReadWrite, MemoryState::Private);
+    MapSegment(module_->rodata, VMAPermission::Read, MemoryState::Static);
+    MapSegment(module_->data, VMAPermission::ReadWrite, MemoryState::Static);
 }
 
 VAddr Process::GetLinearHeapAreaAddress() const {
diff --git a/src/core/hle/kernel/process.h b/src/core/hle/kernel/process.h
index b52211d2a..f05f2703e 100644
--- a/src/core/hle/kernel/process.h
+++ b/src/core/hle/kernel/process.h
@@ -79,7 +79,11 @@ struct CodeSet final : public Object {
         u32 size = 0;
     };
 
-    Segment code, rodata, data;
+    Segment segments[3];
+    Segment& code = segments[0];
+    Segment& rodata = segments[1];
+    Segment& data = segments[2];
+
     VAddr entrypoint;
 
 private:
@@ -89,13 +93,13 @@ private:
 
 class Process final : public Object {
 public:
-    static SharedPtr<Process> Create(SharedPtr<CodeSet> code_set);
+    static SharedPtr<Process> Create(std::string&& name);
 
     std::string GetTypeName() const override {
         return "Process";
     }
     std::string GetName() const override {
-        return codeset->name;
+        return name;
     }
 
     static const HandleType HANDLE_TYPE = HandleType::Process;
@@ -105,7 +109,6 @@ public:
 
     static u32 next_process_id;
 
-    SharedPtr<CodeSet> codeset;
     /// Resource limit descriptor for this process
     SharedPtr<ResourceLimit> resource_limit;
 
@@ -134,7 +137,9 @@ public:
     /**
      * Applies address space changes and launches the process main thread.
      */
-    void Run(s32 main_thread_priority, u32 stack_size);
+    void Run(VAddr entry_point, s32 main_thread_priority, u32 stack_size);
+
+    void LoadModule(SharedPtr<CodeSet> module_, VAddr base_addr);
 
     ///////////////////////////////////////////////////////////////////////////////////////////////
     // Memory Management
@@ -160,6 +165,8 @@ public:
     /// This vector will grow as more pages are allocated for new threads.
     std::vector<std::bitset<8>> tls_slots;
 
+    std::string name;
+
     VAddr GetLinearHeapAreaAddress() const;
     VAddr GetLinearHeapBase() const;
     VAddr GetLinearHeapLimit() const;
diff --git a/src/core/hle/kernel/semaphore.cpp b/src/core/hle/kernel/semaphore.cpp
index fcf586728..2605b2595 100644
--- a/src/core/hle/kernel/semaphore.cpp
+++ b/src/core/hle/kernel/semaphore.cpp
@@ -13,7 +13,7 @@ namespace Kernel {
 Semaphore::Semaphore() {}
 Semaphore::~Semaphore() {}
 
-ResultVal<SharedPtr<Semaphore>> Semaphore::Create(s32 initial_count, s32 max_count,
+ResultVal<SharedPtr<Semaphore>> Semaphore::Create(s32 initial_count, s32 max_count, VAddr address,
                                                   std::string name) {
 
     if (initial_count > max_count)
@@ -25,6 +25,7 @@ ResultVal<SharedPtr<Semaphore>> Semaphore::Create(s32 initial_count, s32 max_cou
     // and the rest is reserved for the caller thread
     semaphore->max_count = max_count;
     semaphore->available_count = initial_count;
+    semaphore->address = address;
     semaphore->name = std::move(name);
 
     return MakeResult<SharedPtr<Semaphore>>(std::move(semaphore));
diff --git a/src/core/hle/kernel/semaphore.h b/src/core/hle/kernel/semaphore.h
index 7b0cacf2e..77c491a24 100644
--- a/src/core/hle/kernel/semaphore.h
+++ b/src/core/hle/kernel/semaphore.h
@@ -22,7 +22,7 @@ public:
      * @param name Optional name of semaphore
      * @return The created semaphore
      */
-    static ResultVal<SharedPtr<Semaphore>> Create(s32 initial_count, s32 max_count,
+    static ResultVal<SharedPtr<Semaphore>> Create(s32 initial_count, s32 max_count, VAddr address,
                                                   std::string name = "Unknown");
 
     std::string GetTypeName() const override {
@@ -39,6 +39,7 @@ public:
 
     s32 max_count;       ///< Maximum number of simultaneous holders the semaphore can have
     s32 available_count; ///< Number of free slots left in the semaphore
+    VAddr address;
     std::string name;    ///< Name of semaphore (optional)
 
     bool ShouldWait(Thread* thread) const override;
diff --git a/src/core/hle/kernel/thread.cpp b/src/core/hle/kernel/thread.cpp
index 0f7970ebe..75df49ac2 100644
--- a/src/core/hle/kernel/thread.cpp
+++ b/src/core/hle/kernel/thread.cpp
@@ -358,8 +358,8 @@ std::tuple<u32, u32, bool> GetFreeThreadLocalSlot(std::vector<std::bitset<8>>& t
  * @param entry_point Address of entry point for execution
  * @param arg User argument for thread
  */
-static void ResetThreadContext(ARM_Interface::ThreadContext& context, u32 stack_top,
-                               u32 entry_point, u32 arg) {
+static void ResetThreadContext(ARM_Interface::ThreadContext& context, VAddr stack_top,
+                               VAddr entry_point, u64 arg) {
     memset(&context, 0, sizeof(ARM_Interface::ThreadContext));
 
     context.cpu_registers[0] = arg;
@@ -446,7 +446,7 @@ ResultVal<SharedPtr<Thread>> Thread::Create(std::string name, VAddr entry_point,
         // Map the page to the current process' address space.
         // TODO(Subv): Find the correct MemoryState for this region.
         vm_manager.MapMemoryBlock(Memory::TLS_AREA_VADDR + available_page * Memory::PAGE_SIZE,
-                                  linheap_memory, offset, Memory::PAGE_SIZE, MemoryState::Private);
+                                  linheap_memory, offset, Memory::PAGE_SIZE, MemoryState::Static);
     }
 
     // Mark the slot as used
@@ -495,6 +495,9 @@ void Thread::BoostPriority(u32 priority) {
 }
 
 SharedPtr<Thread> SetupMainThread(u32 entry_point, u32 priority, SharedPtr<Process> owner_process) {
+    // Setup page table so we can write to memory
+    SetCurrentPageTable(&Kernel::g_current_process->vm_manager.page_table);
+
     // Initialize new "main" thread
     auto thread_res = Thread::Create("main", entry_point, priority, 0, THREADPROCESSORID_0,
                                      Memory::HEAP_VADDR_END, owner_process);
diff --git a/src/core/hle/kernel/thread.h b/src/core/hle/kernel/thread.h
index 314fba81f..fafcab156 100644
--- a/src/core/hle/kernel/thread.h
+++ b/src/core/hle/kernel/thread.h
@@ -184,8 +184,8 @@ public:
     u32 thread_id;
 
     u32 status;
-    u32 entry_point;
-    u32 stack_top;
+    VAddr entry_point;
+    VAddr stack_top;
 
     u32 nominal_priority; ///< Nominal thread priority, as set by the emulated application
     u32 current_priority; ///< Current thread priority, can be temporarily changed
@@ -250,13 +250,13 @@ void Reschedule();
  * Arbitrate the highest priority thread that is waiting
  * @param address The address for which waiting threads should be arbitrated
  */
-Thread* ArbitrateHighestPriorityThread(u32 address);
+Thread* ArbitrateHighestPriorityThread(VAddr address);
 
 /**
  * Arbitrate all threads currently waiting.
  * @param address The address for which waiting threads should be arbitrated
  */
-void ArbitrateAllThreads(u32 address);
+void ArbitrateAllThreads(VAddr address);
 
 /**
  * Gets the current thread
diff --git a/src/core/hle/kernel/vm_manager.cpp b/src/core/hle/kernel/vm_manager.cpp
index 7a007c065..9762ef535 100644
--- a/src/core/hle/kernel/vm_manager.cpp
+++ b/src/core/hle/kernel/vm_manager.cpp
@@ -4,8 +4,10 @@
 
 #include <iterator>
 #include "common/assert.h"
+#include "core/arm/arm_interface.h"
 #include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/vm_manager.h"
+#include "core/core.h"
 #include "core/memory.h"
 #include "core/memory_setup.h"
 #include "core/mmio.h"
@@ -60,7 +62,7 @@ void VMManager::Reset() {
     page_table.attributes.fill(Memory::PageType::Unmapped);
     page_table.cached_res_count.fill(0);
 
-    UpdatePageTableForVMA(initial_vma);
+    //UpdatePageTableForVMA(initial_vma);
 }
 
 VMManager::VMAHandle VMManager::FindVMA(VAddr target) const {
@@ -73,7 +75,7 @@ VMManager::VMAHandle VMManager::FindVMA(VAddr target) const {
 
 ResultVal<VMManager::VMAHandle> VMManager::MapMemoryBlock(VAddr target,
                                                           std::shared_ptr<std::vector<u8>> block,
-                                                          size_t offset, u32 size,
+                                                          size_t offset, u64 size,
                                                           MemoryState state) {
     ASSERT(block != nullptr);
     ASSERT(offset + size <= block->size());
@@ -83,6 +85,8 @@ ResultVal<VMManager::VMAHandle> VMManager::MapMemoryBlock(VAddr target,
     VirtualMemoryArea& final_vma = vma_handle->second;
     ASSERT(final_vma.size == size);
 
+    Core::CPU().MapBackingMemory(target, size, block->data() + offset, VMAPermission::ReadWriteExecute);
+
     final_vma.type = VMAType::AllocatedMemoryBlock;
     final_vma.permissions = VMAPermission::ReadWrite;
     final_vma.meminfo_state = state;
@@ -93,7 +97,7 @@ ResultVal<VMManager::VMAHandle> VMManager::MapMemoryBlock(VAddr target,
     return MakeResult<VMAHandle>(MergeAdjacent(vma_handle));
 }
 
-ResultVal<VMManager::VMAHandle> VMManager::MapBackingMemory(VAddr target, u8* memory, u32 size,
+ResultVal<VMManager::VMAHandle> VMManager::MapBackingMemory(VAddr target, u8* memory, u64 size,
                                                             MemoryState state) {
     ASSERT(memory != nullptr);
 
@@ -102,6 +106,8 @@ ResultVal<VMManager::VMAHandle> VMManager::MapBackingMemory(VAddr target, u8* me
     VirtualMemoryArea& final_vma = vma_handle->second;
     ASSERT(final_vma.size == size);
 
+    Core::CPU().MapBackingMemory(target, size, memory, VMAPermission::ReadWriteExecute);
+
     final_vma.type = VMAType::BackingMemory;
     final_vma.permissions = VMAPermission::ReadWrite;
     final_vma.meminfo_state = state;
@@ -111,7 +117,7 @@ ResultVal<VMManager::VMAHandle> VMManager::MapBackingMemory(VAddr target, u8* me
     return MakeResult<VMAHandle>(MergeAdjacent(vma_handle));
 }
 
-ResultVal<VMManager::VMAHandle> VMManager::MapMMIO(VAddr target, PAddr paddr, u32 size,
+ResultVal<VMManager::VMAHandle> VMManager::MapMMIO(VAddr target, PAddr paddr, u64 size,
                                                    MemoryState state,
                                                    Memory::MMIORegionPointer mmio_handler) {
     // This is the appropriately sized VMA that will turn into our allocation.
@@ -145,7 +151,7 @@ VMManager::VMAIter VMManager::Unmap(VMAIter vma_handle) {
     return MergeAdjacent(vma_handle);
 }
 
-ResultCode VMManager::UnmapRange(VAddr target, u32 size) {
+ResultCode VMManager::UnmapRange(VAddr target, u64 size) {
     CASCADE_RESULT(VMAIter vma, CarveVMARange(target, size));
     VAddr target_end = target + size;
 
@@ -170,7 +176,7 @@ VMManager::VMAHandle VMManager::Reprotect(VMAHandle vma_handle, VMAPermission ne
     return MergeAdjacent(iter);
 }
 
-ResultCode VMManager::ReprotectRange(VAddr target, u32 size, VMAPermission new_perms) {
+ResultCode VMManager::ReprotectRange(VAddr target, u64 size, VMAPermission new_perms) {
     CASCADE_RESULT(VMAIter vma, CarveVMARange(target, size));
     VAddr target_end = target + size;
 
@@ -213,7 +219,7 @@ VMManager::VMAIter VMManager::StripIterConstness(const VMAHandle& iter) {
     return vma_map.erase(iter, iter); // Erases an empty range of elements
 }
 
-ResultVal<VMManager::VMAIter> VMManager::CarveVMA(VAddr base, u32 size) {
+ResultVal<VMManager::VMAIter> VMManager::CarveVMA(VAddr base, u64 size) {
     ASSERT_MSG((size & Memory::PAGE_MASK) == 0, "non-page aligned size: 0x%8X", size);
     ASSERT_MSG((base & Memory::PAGE_MASK) == 0, "non-page aligned base: 0x%08X", base);
 
@@ -229,8 +235,8 @@ ResultVal<VMManager::VMAIter> VMManager::CarveVMA(VAddr base, u32 size) {
         return ERR_INVALID_ADDRESS_STATE;
     }
 
-    u32 start_in_vma = base - vma.base;
-    u32 end_in_vma = start_in_vma + size;
+    u64 start_in_vma = base - vma.base;
+    u64 end_in_vma = start_in_vma + size;
 
     if (end_in_vma > vma.size) {
         // Requested allocation doesn't fit inside VMA
@@ -249,7 +255,7 @@ ResultVal<VMManager::VMAIter> VMManager::CarveVMA(VAddr base, u32 size) {
     return MakeResult<VMAIter>(vma_handle);
 }
 
-ResultVal<VMManager::VMAIter> VMManager::CarveVMARange(VAddr target, u32 size) {
+ResultVal<VMManager::VMAIter> VMManager::CarveVMARange(VAddr target, u64 size) {
     ASSERT_MSG((size & Memory::PAGE_MASK) == 0, "non-page aligned size: 0x%8X", size);
     ASSERT_MSG((target & Memory::PAGE_MASK) == 0, "non-page aligned base: 0x%08X", target);
 
@@ -278,7 +284,7 @@ ResultVal<VMManager::VMAIter> VMManager::CarveVMARange(VAddr target, u32 size) {
     return MakeResult<VMAIter>(begin_vma);
 }
 
-VMManager::VMAIter VMManager::SplitVMA(VMAIter vma_handle, u32 offset_in_vma) {
+VMManager::VMAIter VMManager::SplitVMA(VMAIter vma_handle, u64 offset_in_vma) {
     VirtualMemoryArea& old_vma = vma_handle->second;
     VirtualMemoryArea new_vma = old_vma; // Make a copy of the VMA
 
diff --git a/src/core/hle/kernel/vm_manager.h b/src/core/hle/kernel/vm_manager.h
index 1302527bb..cb5bb8243 100644
--- a/src/core/hle/kernel/vm_manager.h
+++ b/src/core/hle/kernel/vm_manager.h
@@ -64,7 +64,7 @@ struct VirtualMemoryArea {
     /// Virtual base address of the region.
     VAddr base = 0;
     /// Size of the region.
-    u32 size = 0;
+    u64 size = 0;
 
     VMAType type = VMAType::Free;
     VMAPermission permissions = VMAPermission::None;
@@ -109,7 +109,7 @@ public:
      * used.
      * @note This is the limit used by the New 3DS kernel. Old 3DS used 0x20000000.
      */
-    static const u32 MAX_ADDRESS = 0x40000000;
+    static const VAddr MAX_ADDRESS = 0x8000000000;
 
     /**
      * A map covering the entirety of the managed address space, keyed by the `base` field of each
@@ -142,7 +142,7 @@ public:
      * @param state MemoryState tag to attach to the VMA.
      */
     ResultVal<VMAHandle> MapMemoryBlock(VAddr target, std::shared_ptr<std::vector<u8>> block,
-                                        size_t offset, u32 size, MemoryState state);
+                                        size_t offset, u64 size, MemoryState state);
 
     /**
      * Maps an unmanaged host memory pointer at a given address.
@@ -152,7 +152,7 @@ public:
      * @param size Size of the mapping.
      * @param state MemoryState tag to attach to the VMA.
      */
-    ResultVal<VMAHandle> MapBackingMemory(VAddr target, u8* memory, u32 size, MemoryState state);
+    ResultVal<VMAHandle> MapBackingMemory(VAddr target, u8* memory, u64 size, MemoryState state);
 
     /**
      * Maps a memory-mapped IO region at a given address.
@@ -163,17 +163,17 @@ public:
      * @param state MemoryState tag to attach to the VMA.
      * @param mmio_handler The handler that will implement read and write for this MMIO region.
      */
-    ResultVal<VMAHandle> MapMMIO(VAddr target, PAddr paddr, u32 size, MemoryState state,
+    ResultVal<VMAHandle> MapMMIO(VAddr target, PAddr paddr, u64 size, MemoryState state,
                                  Memory::MMIORegionPointer mmio_handler);
 
     /// Unmaps a range of addresses, splitting VMAs as necessary.
-    ResultCode UnmapRange(VAddr target, u32 size);
+    ResultCode UnmapRange(VAddr target, u64 size);
 
     /// Changes the permissions of the given VMA.
     VMAHandle Reprotect(VMAHandle vma, VMAPermission new_perms);
 
     /// Changes the permissions of a range of addresses, splitting VMAs as necessary.
-    ResultCode ReprotectRange(VAddr target, u32 size, VMAPermission new_perms);
+    ResultCode ReprotectRange(VAddr target, u64 size, VMAPermission new_perms);
 
     /**
      * Scans all VMAs and updates the page table range of any that use the given vector as backing
@@ -201,19 +201,19 @@ private:
      * Carves a VMA of a specific size at the specified address by splitting Free VMAs while doing
      * the appropriate error checking.
      */
-    ResultVal<VMAIter> CarveVMA(VAddr base, u32 size);
+    ResultVal<VMAIter> CarveVMA(VAddr base, u64 size);
 
     /**
      * Splits the edges of the given range of non-Free VMAs so that there is a VMA split at each
      * end of the range.
      */
-    ResultVal<VMAIter> CarveVMARange(VAddr base, u32 size);
+    ResultVal<VMAIter> CarveVMARange(VAddr base, u64 size);
 
     /**
      * Splits a VMA in two, at the specified offset.
      * @returns the right side of the split, with the original iterator becoming the left side.
      */
-    VMAIter SplitVMA(VMAIter vma, u32 offset_in_vma);
+    VMAIter SplitVMA(VMAIter vma, u64 offset_in_vma);
 
     /**
      * Checks for and merges the specified VMA with adjacent ones if possible.
diff --git a/src/core/hle/service/apt/apt.cpp b/src/core/hle/service/apt/apt.cpp
index 59ea9823d..912ab550d 100644
--- a/src/core/hle/service/apt/apt.cpp
+++ b/src/core/hle/service/apt/apt.cpp
@@ -1073,7 +1073,17 @@ void Init() {
                                      MemoryPermission::ReadWrite, MemoryPermission::Read, 0,
                                      Kernel::MemoryRegion::SYSTEM, "APT:SharedFont");
 
-    lock = Kernel::Mutex::Create(false, "APT_U:Lock");
+    if (LoadSharedFont()) {
+        shared_font_loaded = true;
+    } else if (LoadLegacySharedFont()) {
+        LOG_WARNING(Service_APT, "Loaded shared font by legacy method");
+        shared_font_loaded = true;
+    } else {
+        LOG_WARNING(Service_APT, "Unable to load shared font");
+        shared_font_loaded = false;
+    }
+
+    lock = Kernel::Mutex::Create(false, 0, "APT_U:Lock");
 
     cpu_percent = 0;
     unknown_ns_state_field = 0;
diff --git a/src/core/hle/service/csnd_snd.cpp b/src/core/hle/service/csnd_snd.cpp
index 9471ec1ef..aac903ccb 100644
--- a/src/core/hle/service/csnd_snd.cpp
+++ b/src/core/hle/service/csnd_snd.cpp
@@ -47,7 +47,7 @@ static void Initialize(Interface* self) {
                                                  MemoryPermission::ReadWrite, 0,
                                                  Kernel::MemoryRegion::BASE, "CSND:SharedMemory");
 
-    mutex = Kernel::Mutex::Create(false, "CSND:mutex");
+    mutex = Kernel::Mutex::Create(false, 0, "CSND:mutex");
 
     cmd_buff[1] = RESULT_SUCCESS.raw;
     cmd_buff[2] = IPC::CopyHandleDesc(2);
diff --git a/src/core/hle/service/ldr_ro/cro_helper.cpp b/src/core/hle/service/ldr_ro/cro_helper.cpp
index f78545f37..6128f8a6c 100644
--- a/src/core/hle/service/ldr_ro/cro_helper.cpp
+++ b/src/core/hle/service/ldr_ro/cro_helper.cpp
@@ -274,7 +274,7 @@ ResultVal<VAddr> CROHelper::RebaseSegmentTable(u32 cro_size, VAddr data_segment_
         }
         SetEntry(i, segment);
     }
-    return MakeResult<u32>(prev_data_segment + module_address);
+    return MakeResult<VAddr>(prev_data_segment + module_address);
 }
 
 ResultCode CROHelper::RebaseExportNamedSymbolTable() {
diff --git a/src/core/hle/service/sm/srv.cpp b/src/core/hle/service/sm/srv.cpp
index 5c955cf54..fb873981c 100644
--- a/src/core/hle/service/sm/srv.cpp
+++ b/src/core/hle/service/sm/srv.cpp
@@ -62,7 +62,7 @@ void SRV::EnableNotification(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp(ctx, 0x2, 0, 0);
 
     notification_semaphore =
-        Kernel::Semaphore::Create(0, MAX_PENDING_NOTIFICATIONS, "SRV:Notification").Unwrap();
+        Kernel::Semaphore::Create(0, MAX_PENDING_NOTIFICATIONS, 0, "SRV:Notification").Unwrap();
 
     IPC::RequestBuilder rb = rp.MakeBuilder(1, 2);
     rb.Push(RESULT_SUCCESS);
diff --git a/src/core/hle/svc.cpp b/src/core/hle/svc.cpp
index e8ca419d5..e4b803046 100644
--- a/src/core/hle/svc.cpp
+++ b/src/core/hle/svc.cpp
@@ -31,7 +31,6 @@
 #include "core/hle/kernel/timer.h"
 #include "core/hle/kernel/vm_manager.h"
 #include "core/hle/kernel/wait_object.h"
-#include "core/hle/lock.h"
 #include "core/hle/result.h"
 #include "core/hle/service/service.h"
 
@@ -201,21 +200,17 @@ static ResultCode UnmapMemoryBlock(Kernel::Handle handle, u32 addr) {
 }
 
 /// Connect to an OS service given the port name, returns the handle to the port to out
-static ResultCode ConnectToPort(Kernel::Handle* out_handle, VAddr port_name_address) {
-    if (!Memory::IsValidVirtualAddress(port_name_address))
+static ResultCode ConnectToPort(Kernel::Handle* out_handle, const char* port_name) {
+    if (port_name == nullptr)
         return Kernel::ERR_NOT_FOUND;
-
-    static constexpr std::size_t PortNameMaxLength = 11;
-    // Read 1 char beyond the max allowed port name to detect names that are too long.
-    std::string port_name = Memory::ReadCString(port_name_address, PortNameMaxLength + 1);
-    if (port_name.size() > PortNameMaxLength)
+    if (std::strlen(port_name) > 11)
         return Kernel::ERR_PORT_NAME_TOO_LONG;
 
-    LOG_TRACE(Kernel_SVC, "called port_name=%s", port_name.c_str());
+    LOG_TRACE(Kernel_SVC, "called port_name=%s", port_name);
 
     auto it = Service::g_kernel_named_ports.find(port_name);
     if (it == Service::g_kernel_named_ports.end()) {
-        LOG_WARNING(Kernel_SVC, "tried to connect to unknown port: %s", port_name.c_str());
+        LOG_WARNING(Kernel_SVC, "tried to connect to unknown port: %s", port_name);
         return Kernel::ERR_NOT_FOUND;
     }
 
@@ -275,24 +270,6 @@ static ResultCode WaitSynchronization1(Kernel::Handle handle, s64 nano_seconds)
         // Create an event to wake the thread up after the specified nanosecond delay has passed
         thread->WakeAfterDelay(nano_seconds);
 
-        thread->wakeup_callback = [](ThreadWakeupReason reason,
-                                     Kernel::SharedPtr<Kernel::Thread> thread,
-                                     Kernel::SharedPtr<Kernel::WaitObject> object) {
-
-            ASSERT(thread->status == THREADSTATUS_WAIT_SYNCH_ANY);
-
-            if (reason == ThreadWakeupReason::Timeout) {
-                thread->SetWaitSynchronizationResult(Kernel::RESULT_TIMEOUT);
-                return;
-            }
-
-            ASSERT(reason == ThreadWakeupReason::Signal);
-            thread->SetWaitSynchronizationResult(RESULT_SUCCESS);
-
-            // WaitSynchronization1 doesn't have an output index like WaitSynchronizationN, so we
-            // don't have to do anything else here.
-        };
-
         Core::System::GetInstance().PrepareReschedule();
 
         // Note: The output of this SVC will be set to RESULT_SUCCESS if the thread
@@ -307,11 +284,12 @@ static ResultCode WaitSynchronization1(Kernel::Handle handle, s64 nano_seconds)
 }
 
 /// Wait for the given handles to synchronize, timeout after the specified nanoseconds
-static ResultCode WaitSynchronizationN(s32* out, VAddr handles_address, s32 handle_count,
+static ResultCode WaitSynchronizationN(s32* out, Kernel::Handle* handles, s32 handle_count,
                                        bool wait_all, s64 nano_seconds) {
     Kernel::Thread* thread = Kernel::GetCurrentThread();
 
-    if (!Memory::IsValidVirtualAddress(handles_address))
+    // Check if 'handles' is invalid
+    if (handles == nullptr)
         return Kernel::ERR_INVALID_POINTER;
 
     // NOTE: on real hardware, there is no nullptr check for 'out' (tested with firmware 4.4). If
@@ -326,8 +304,7 @@ static ResultCode WaitSynchronizationN(s32* out, VAddr handles_address, s32 hand
     std::vector<ObjectPtr> objects(handle_count);
 
     for (int i = 0; i < handle_count; ++i) {
-        Kernel::Handle handle = Memory::Read32(handles_address + i * sizeof(Kernel::Handle));
-        auto object = Kernel::g_handle_table.Get<Kernel::WaitObject>(handle);
+        auto object = Kernel::g_handle_table.Get<Kernel::WaitObject>(handles[i]);
         if (object == nullptr)
             return ERR_INVALID_HANDLE;
         objects[i] = object;
@@ -366,23 +343,6 @@ static ResultCode WaitSynchronizationN(s32* out, VAddr handles_address, s32 hand
         // Create an event to wake the thread up after the specified nanosecond delay has passed
         thread->WakeAfterDelay(nano_seconds);
 
-        thread->wakeup_callback = [](ThreadWakeupReason reason,
-                                     Kernel::SharedPtr<Kernel::Thread> thread,
-                                     Kernel::SharedPtr<Kernel::WaitObject> object) {
-
-            ASSERT(thread->status == THREADSTATUS_WAIT_SYNCH_ALL);
-
-            if (reason == ThreadWakeupReason::Timeout) {
-                thread->SetWaitSynchronizationResult(Kernel::RESULT_TIMEOUT);
-                return;
-            }
-
-            ASSERT(reason == ThreadWakeupReason::Signal);
-
-            thread->SetWaitSynchronizationResult(RESULT_SUCCESS);
-            // The wait_all case does not update the output index.
-        };
-
         Core::System::GetInstance().PrepareReschedule();
 
         // This value gets set to -1 by default in this case, it is not modified after this.
@@ -400,7 +360,7 @@ static ResultCode WaitSynchronizationN(s32* out, VAddr handles_address, s32 hand
             // We found a ready object, acquire it and set the result value
             Kernel::WaitObject* object = itr->get();
             object->Acquire(thread);
-            *out = static_cast<s32>(std::distance(objects.begin(), itr));
+            *out = std::distance(objects.begin(), itr);
             return RESULT_SUCCESS;
         }
 
@@ -428,37 +388,22 @@ static ResultCode WaitSynchronizationN(s32* out, VAddr handles_address, s32 hand
         // Create an event to wake the thread up after the specified nanosecond delay has passed
         thread->WakeAfterDelay(nano_seconds);
 
-        thread->wakeup_callback = [](ThreadWakeupReason reason,
-                                     Kernel::SharedPtr<Kernel::Thread> thread,
-                                     Kernel::SharedPtr<Kernel::WaitObject> object) {
-
-            ASSERT(thread->status == THREADSTATUS_WAIT_SYNCH_ANY);
-
-            if (reason == ThreadWakeupReason::Timeout) {
-                thread->SetWaitSynchronizationResult(Kernel::RESULT_TIMEOUT);
-                return;
-            }
-
-            ASSERT(reason == ThreadWakeupReason::Signal);
-
-            thread->SetWaitSynchronizationResult(RESULT_SUCCESS);
-            thread->SetWaitSynchronizationOutput(thread->GetWaitObjectIndex(object.get()));
-        };
-
         Core::System::GetInstance().PrepareReschedule();
 
         // Note: The output of this SVC will be set to RESULT_SUCCESS if the thread resumes due to a
         // signal in one of its wait objects.
         // Otherwise we retain the default value of timeout, and -1 in the out parameter
+        thread->wait_set_output = true;
         *out = -1;
         return Kernel::RESULT_TIMEOUT;
     }
 }
 
 /// In a single operation, sends a IPC reply and waits for a new request.
-static ResultCode ReplyAndReceive(s32* index, VAddr handles_address, s32 handle_count,
+static ResultCode ReplyAndReceive(s32* index, Kernel::Handle* handles, s32 handle_count,
                                   Kernel::Handle reply_target) {
-    if (!Memory::IsValidVirtualAddress(handles_address))
+    // 'handles' has to be a valid pointer even if 'handle_count' is 0.
+    if (handles == nullptr)
         return Kernel::ERR_INVALID_POINTER;
 
     // Check if 'handle_count' is invalid
@@ -469,8 +414,7 @@ static ResultCode ReplyAndReceive(s32* index, VAddr handles_address, s32 handle_
     std::vector<ObjectPtr> objects(handle_count);
 
     for (int i = 0; i < handle_count; ++i) {
-        Kernel::Handle handle = Memory::Read32(handles_address + i * sizeof(Kernel::Handle));
-        auto object = Kernel::g_handle_table.Get<Kernel::WaitObject>(handle);
+        auto object = Kernel::g_handle_table.Get<Kernel::WaitObject>(handles[i]);
         if (object == nullptr)
             return ERR_INVALID_HANDLE;
         objects[i] = object;
@@ -524,7 +468,7 @@ static ResultCode ReplyAndReceive(s32* index, VAddr handles_address, s32 handle_
         // We found a ready object, acquire it and set the result value
         Kernel::WaitObject* object = itr->get();
         object->Acquire(thread);
-        *index = static_cast<s32>(std::distance(objects.begin(), itr));
+        *index = std::distance(objects.begin(), itr);
 
         if (object->GetHandleType() == Kernel::HandleType::ServerSession) {
             auto server_session = static_cast<Kernel::ServerSession*>(object);
@@ -538,6 +482,8 @@ static ResultCode ReplyAndReceive(s32* index, VAddr handles_address, s32 handle_
 
     // No objects were ready to be acquired, prepare to suspend the thread.
 
+    // TODO(Subv): Perform IPC translation upon wakeup.
+
     // Put the thread to sleep
     thread->status = THREADSTATUS_WAIT_SYNCH_ANY;
 
@@ -549,24 +495,12 @@ static ResultCode ReplyAndReceive(s32* index, VAddr handles_address, s32 handle_
 
     thread->wait_objects = std::move(objects);
 
-    thread->wakeup_callback = [](ThreadWakeupReason reason,
-                                 Kernel::SharedPtr<Kernel::Thread> thread,
-                                 Kernel::SharedPtr<Kernel::WaitObject> object) {
-
-        ASSERT(thread->status == THREADSTATUS_WAIT_SYNCH_ANY);
-        ASSERT(reason == ThreadWakeupReason::Signal);
-
-        thread->SetWaitSynchronizationResult(RESULT_SUCCESS);
-        thread->SetWaitSynchronizationOutput(thread->GetWaitObjectIndex(object.get()));
-
-        // TODO(Subv): Perform IPC translation upon wakeup.
-    };
-
     Core::System::GetInstance().PrepareReschedule();
 
     // Note: The output of this SVC will be set to RESULT_SUCCESS if the thread resumes due to a
     // signal in one of its wait objects, or to 0xC8A01836 if there was a translation error.
     // By default the index is set to -1.
+    thread->wait_set_output = true;
     *index = -1;
     return RESULT_SUCCESS;
 }
@@ -623,10 +557,8 @@ static void Break(u8 break_reason) {
 }
 
 /// Used to output a message on a debug hardware unit - does nothing on a retail unit
-static void OutputDebugString(VAddr address, int len) {
-    std::vector<char> string(len);
-    Memory::ReadBlock(address, string.data(), len);
-    LOG_DEBUG(Debug_Emulated, "%.*s", len, string.data());
+static void OutputDebugString(const char* string, int len) {
+    LOG_DEBUG(Debug_Emulated, "%.*s", len, string);
 }
 
 /// Get resource limit
@@ -644,9 +576,9 @@ static ResultCode GetResourceLimit(Kernel::Handle* resource_limit, Kernel::Handl
 }
 
 /// Get resource limit current values
-static ResultCode GetResourceLimitCurrentValues(VAddr values, Kernel::Handle resource_limit_handle,
-                                                VAddr names, u32 name_count) {
-    LOG_TRACE(Kernel_SVC, "called resource_limit=%08X, names=%08X, name_count=%d",
+static ResultCode GetResourceLimitCurrentValues(s64* values, Kernel::Handle resource_limit_handle,
+                                                u32* names, u32 name_count) {
+    LOG_TRACE(Kernel_SVC, "called resource_limit=%08X, names=%p, name_count=%d",
               resource_limit_handle, names, name_count);
 
     SharedPtr<Kernel::ResourceLimit> resource_limit =
@@ -654,19 +586,16 @@ static ResultCode GetResourceLimitCurrentValues(VAddr values, Kernel::Handle res
     if (resource_limit == nullptr)
         return ERR_INVALID_HANDLE;
 
-    for (unsigned int i = 0; i < name_count; ++i) {
-        u32 name = Memory::Read32(names + i * sizeof(u32));
-        s64 value = resource_limit->GetCurrentResourceValue(name);
-        Memory::Write64(values + i * sizeof(u64), value);
-    }
+    for (unsigned int i = 0; i < name_count; ++i)
+        values[i] = resource_limit->GetCurrentResourceValue(names[i]);
 
     return RESULT_SUCCESS;
 }
 
 /// Get resource limit max values
-static ResultCode GetResourceLimitLimitValues(VAddr values, Kernel::Handle resource_limit_handle,
-                                              VAddr names, u32 name_count) {
-    LOG_TRACE(Kernel_SVC, "called resource_limit=%08X, names=%08X, name_count=%d",
+static ResultCode GetResourceLimitLimitValues(s64* values, Kernel::Handle resource_limit_handle,
+                                              u32* names, u32 name_count) {
+    LOG_TRACE(Kernel_SVC, "called resource_limit=%08X, names=%p, name_count=%d",
               resource_limit_handle, names, name_count);
 
     SharedPtr<Kernel::ResourceLimit> resource_limit =
@@ -674,11 +603,8 @@ static ResultCode GetResourceLimitLimitValues(VAddr values, Kernel::Handle resou
     if (resource_limit == nullptr)
         return ERR_INVALID_HANDLE;
 
-    for (unsigned int i = 0; i < name_count; ++i) {
-        u32 name = Memory::Read32(names + i * sizeof(u32));
-        s64 value = resource_limit->GetMaxResourceValue(names);
-        Memory::Write64(values + i * sizeof(u64), value);
-    }
+    for (unsigned int i = 0; i < name_count; ++i)
+        values[i] = resource_limit->GetMaxResourceValue(names[i]);
 
     return RESULT_SUCCESS;
 }
@@ -729,9 +655,8 @@ static ResultCode CreateThread(Kernel::Handle* out_handle, u32 priority, u32 ent
                   "Newly created thread must run in the SysCore (Core1), unimplemented.");
     }
 
-    CASCADE_RESULT(SharedPtr<Thread> thread,
-                   Kernel::Thread::Create(name, entry_point, priority, arg, processor_id, stack_top,
-                                          Kernel::g_current_process));
+    CASCADE_RESULT(SharedPtr<Thread> thread, Kernel::Thread::Create(name, entry_point, priority,
+                                                                    arg, processor_id, stack_top));
 
     thread->context.fpscr =
         FPSCR_DEFAULT_NAN | FPSCR_FLUSH_TO_ZERO | FPSCR_ROUND_TOZERO; // 0x03C00000
@@ -756,7 +681,7 @@ static void ExitThread() {
 }
 
 /// Gets the priority for the specified thread
-static ResultCode GetThreadPriority(u32* priority, Kernel::Handle handle) {
+static ResultCode GetThreadPriority(s32* priority, Kernel::Handle handle) {
     const SharedPtr<Kernel::Thread> thread = Kernel::g_handle_table.Get<Kernel::Thread>(handle);
     if (thread == nullptr)
         return ERR_INVALID_HANDLE;
@@ -766,7 +691,7 @@ static ResultCode GetThreadPriority(u32* priority, Kernel::Handle handle) {
 }
 
 /// Sets the priority for the specified thread
-static ResultCode SetThreadPriority(Kernel::Handle handle, u32 priority) {
+static ResultCode SetThreadPriority(Kernel::Handle handle, s32 priority) {
     if (priority > THREADPRIO_LOWEST) {
         return Kernel::ERR_OUT_OF_RANGE;
     }
@@ -1051,7 +976,7 @@ static void SleepThread(s64 nanoseconds) {
 static s64 GetSystemTick() {
     s64 result = CoreTiming::GetTicks();
     // Advance time to defeat dumb games (like Cubic Ninja) that busy-wait for the frame to end.
-    CoreTiming::AddTicks(150); // Measured time between two calls on a 9.2 o3DS with Ninjhax 1.1b
+    Core::CPU().AddTicks(150); // Measured time between two calls on a 9.2 o3DS with Ninjhax 1.1b
     return result;
 }
 
@@ -1110,9 +1035,9 @@ static ResultCode CreateMemoryBlock(Kernel::Handle* out_handle, u32 addr, u32 si
 }
 
 static ResultCode CreatePort(Kernel::Handle* server_port, Kernel::Handle* client_port,
-                             VAddr name_address, u32 max_sessions) {
+                             const char* name, u32 max_sessions) {
     // TODO(Subv): Implement named ports.
-    ASSERT_MSG(name_address == 0, "Named ports are currently unimplemented");
+    ASSERT_MSG(name == nullptr, "Named ports are currently unimplemented");
 
     using Kernel::ServerPort;
     using Kernel::ClientPort;
@@ -1263,7 +1188,7 @@ struct FunctionDef {
     Func* func;
     const char* name;
 };
-} // namespace
+}
 
 static const FunctionDef SVC_Table[] = {
     {0x00, nullptr, "Unknown"},
@@ -1407,9 +1332,6 @@ MICROPROFILE_DEFINE(Kernel_SVC, "Kernel", "SVC", MP_RGB(70, 200, 70));
 void CallSVC(u32 immediate) {
     MICROPROFILE_SCOPE(Kernel_SVC);
 
-    // Lock the global kernel mutex when we enter the kernel HLE.
-    std::lock_guard<std::recursive_mutex> lock(HLE::g_hle_lock);
-
     const FunctionDef* info = GetSVCInfo(immediate);
     if (info) {
         if (info->func) {
@@ -1420,4 +1342,4 @@ void CallSVC(u32 immediate) {
     }
 }
 
-} // namespace SVC
+} // namespace
diff --git a/src/core/hw/gpu.cpp b/src/core/hw/gpu.cpp
index 83ad9d898..d1bfe51e6 100644
--- a/src/core/hw/gpu.cpp
+++ b/src/core/hw/gpu.cpp
@@ -515,15 +515,15 @@ template void Write<u8>(u32 addr, const u8 data);
 
 /// Update hardware
 static void VBlankCallback(u64 userdata, int cycles_late) {
-    VideoCore::g_renderer->SwapBuffers();
-
-    // Signal to GSP that GPU interrupt has occurred
-    // TODO(yuriks): hwtest to determine if PDC0 is for the Top screen and PDC1 for the Sub
-    // screen, or if both use the same interrupts and these two instead determine the
-    // beginning and end of the VBlank period. If needed, split the interrupt firing into
-    // two different intervals.
-    Service::GSP::SignalInterrupt(Service::GSP::InterruptId::PDC0);
-    Service::GSP::SignalInterrupt(Service::GSP::InterruptId::PDC1);
+    //VideoCore::g_renderer->SwapBuffers();
+
+    //// Signal to GSP that GPU interrupt has occurred
+    //// TODO(yuriks): hwtest to determine if PDC0 is for the Top screen and PDC1 for the Sub
+    //// screen, or if both use the same interrupts and these two instead determine the
+    //// beginning and end of the VBlank period. If needed, split the interrupt firing into
+    //// two different intervals.
+    //Service::GSP::SignalInterrupt(Service::GSP::InterruptId::PDC0);
+    //Service::GSP::SignalInterrupt(Service::GSP::InterruptId::PDC1);
 
     // Reschedule recurrent event
     CoreTiming::ScheduleEvent(frame_ticks - cycles_late, vblank_event);
diff --git a/src/core/loader/3dsx.cpp b/src/core/loader/3dsx.cpp
index 918038f1e..7b0342cc9 100644
--- a/src/core/loader/3dsx.cpp
+++ b/src/core/loader/3dsx.cpp
@@ -267,15 +267,15 @@ ResultStatus AppLoader_THREEDSX::Load(Kernel::SharedPtr<Kernel::Process>& proces
         return ResultStatus::Error;
     codeset->name = filename;
 
-    process = Kernel::Process::Create(std::move(codeset));
+    process = Kernel::Process::Create("main");
+    process->LoadModule(codeset, codeset->entrypoint);
     process->svc_access_mask.set();
     process->address_mappings = default_address_mappings;
 
     // Attach the default resource limit (APPLICATION) to the process
     process->resource_limit =
         Kernel::ResourceLimit::GetForCategory(Kernel::ResourceLimitCategory::APPLICATION);
-
-    process->Run(48, Kernel::DEFAULT_STACK_SIZE);
+    process->Run(codeset->entrypoint, 48, Kernel::DEFAULT_STACK_SIZE);
 
     Service::FS::RegisterSelfNCCH(*this);
 
diff --git a/src/core/loader/elf.cpp b/src/core/loader/elf.cpp
index e36e42120..9969a8c39 100644
--- a/src/core/loader/elf.cpp
+++ b/src/core/loader/elf.cpp
@@ -364,12 +364,19 @@ SectionID ElfReader::GetSectionByName(const char* name, int firstSection) const
 namespace Loader {
 
 FileType AppLoader_ELF::IdentifyType(FileUtil::IOFile& file) {
-    u32 magic;
+    static constexpr u16 ELF_MACHINE_ARM{0x28};
+
+    u32 magic = 0;
     file.Seek(0, SEEK_SET);
     if (1 != file.ReadArray<u32>(&magic, 1))
         return FileType::Error;
 
-    if (MakeMagic('\x7f', 'E', 'L', 'F') == magic)
+    u16 machine = 0;
+    file.Seek(18, SEEK_SET);
+    if (1 != file.ReadArray<u16>(&machine, 1))
+        return FileType::Error;
+
+    if (MakeMagic('\x7f', 'E', 'L', 'F') == magic && ELF_MACHINE_ARM == machine)
         return FileType::ELF;
 
     return FileType::Error;
@@ -394,7 +401,8 @@ ResultStatus AppLoader_ELF::Load(Kernel::SharedPtr<Kernel::Process>& process) {
     SharedPtr<CodeSet> codeset = elf_reader.LoadInto(Memory::PROCESS_IMAGE_VADDR);
     codeset->name = filename;
 
-    process = Kernel::Process::Create(std::move(codeset));
+    process = Kernel::Process::Create("main");
+    process->LoadModule(codeset, codeset->entrypoint);
     process->svc_access_mask.set();
     process->address_mappings = default_address_mappings;
 
@@ -402,7 +410,7 @@ ResultStatus AppLoader_ELF::Load(Kernel::SharedPtr<Kernel::Process>& process) {
     process->resource_limit =
         Kernel::ResourceLimit::GetForCategory(Kernel::ResourceLimitCategory::APPLICATION);
 
-    process->Run(48, Kernel::DEFAULT_STACK_SIZE);
+    process->Run(codeset->entrypoint, 48, Kernel::DEFAULT_STACK_SIZE);
 
     is_loaded = true;
     return ResultStatus::Success;
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 be719d74c..73318c584 100644
--- a/src/core/loader/loader.cpp
+++ b/src/core/loader/loader.cpp
@@ -10,6 +10,8 @@
 #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"
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -32,6 +34,8 @@ FileType IdentifyFile(FileUtil::IOFile& file) {
     CHECK_TYPE(THREEDSX)
     CHECK_TYPE(ELF)
     CHECK_TYPE(NCCH)
+    CHECK_TYPE(NSO)
+    CHECK_TYPE(NRO)
 
 #undef CHECK_TYPE
 
@@ -115,6 +119,14 @@ static std::unique_ptr<AppLoader> GetFileLoader(FileUtil::IOFile&& file, FileTyp
     case FileType::CCI:
         return std::make_unique<AppLoader_NCCH>(std::move(file), filepath);
 
+    // NX NSO file format.
+    case FileType::NSO:
+        return std::make_unique<AppLoader_NSO>(std::move(file), filepath);
+
+    // NX NRO file format.
+    case FileType::NRO:
+        return std::make_unique<AppLoader_NRO>(std::move(file), filepath);
+
     default:
         return nullptr;
     }
diff --git a/src/core/loader/loader.h b/src/core/loader/loader.h
index 82b2be6a3..311785d05 100644
--- a/src/core/loader/loader.h
+++ b/src/core/loader/loader.h
@@ -34,6 +34,8 @@ enum class FileType {
     CIA,
     ELF,
     THREEDSX, // 3DSX
+    NSO,
+    NRO,
 };
 
 /**
diff --git a/src/core/loader/ncch.cpp b/src/core/loader/ncch.cpp
index 52686e364..e33a37b2e 100644
--- a/src/core/loader/ncch.cpp
+++ b/src/core/loader/ncch.cpp
@@ -118,7 +118,8 @@ ResultStatus AppLoader_NCCH::LoadExec(Kernel::SharedPtr<Kernel::Process>& proces
         codeset->entrypoint = codeset->code.addr;
         codeset->memory = std::make_shared<std::vector<u8>>(std::move(code));
 
-        process = Kernel::Process::Create(std::move(codeset));
+        process = Kernel::Process::Create("main");
+        process->LoadModule(codeset, codeset->entrypoint);
 
         // Attach a resource limit to the process based on the resource limit category
         process->resource_limit =
@@ -138,7 +139,7 @@ ResultStatus AppLoader_NCCH::LoadExec(Kernel::SharedPtr<Kernel::Process>& proces
 
         s32 priority = overlay_ncch->exheader_header.arm11_system_local_caps.priority;
         u32 stack_size = overlay_ncch->exheader_header.codeset_info.stack_size;
-        process->Run(priority, stack_size);
+        process->Run(codeset->entrypoint, priority, stack_size);
         return ResultStatus::Success;
     }
     return ResultStatus::Error;
diff --git a/src/core/loader/nro.cpp b/src/core/loader/nro.cpp
new file mode 100644
index 000000000..24c2c55a9
--- /dev/null
+++ b/src/core/loader/nro.cpp
@@ -0,0 +1,162 @@
+// 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;
+}
+
+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(Kernel::SharedPtr<Kernel::Process>& process) {
+    if (is_loaded) {
+        return ResultStatus::ErrorAlreadyLoaded;
+    }
+    if (!file.IsOpen()) {
+        return ResultStatus::Error;
+    }
+
+    // Load and relocate "main" and "sdk" NSO
+    static constexpr VAddr base_addr{Memory::PROCESS_IMAGE_VADDR};
+    process = Kernel::Process::Create("main");
+    if (!LoadNro(filepath, base_addr)) {
+        return ResultStatus::ErrorInvalidFormat;
+    }
+
+    process->svc_access_mask.set();
+    process->address_mappings = default_address_mappings;
+    process->resource_limit =
+        Kernel::ResourceLimit::GetForCategory(Kernel::ResourceLimitCategory::APPLICATION);
+    process->Run(base_addr, 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..c85768c5b
--- /dev/null
+++ b/src/core/loader/nro.h
@@ -0,0 +1,42 @@
+// 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 filepath)
+        : AppLoader(std::move(file)), 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(Kernel::SharedPtr<Kernel::Process>& process) override;
+
+private:
+    bool LoadNro(const std::string& path, VAddr load_base);
+
+    std::string filepath;
+};
+
+} // namespace Loader
diff --git a/src/core/loader/nso.cpp b/src/core/loader/nso.cpp
new file mode 100644
index 000000000..b1b57d0c0
--- /dev/null
+++ b/src/core/loader/nso.cpp
@@ -0,0 +1,185 @@
+// Copyright 2017 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <vector>
+#include <lz4.h>
+
+#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/nso.h"
+#include "core/memory.h"
+
+namespace Loader {
+
+struct NsoSegmentHeader {
+    u32_le offset;
+    u32_le location;
+    u32_le size;
+    u32_le alignment;
+};
+static_assert(sizeof(NsoSegmentHeader) == 0x10, "NsoSegmentHeader has incorrect size.");
+
+struct NsoHeader {
+    u32_le magic;
+    INSERT_PADDING_BYTES(0xc);
+    std::array<NsoSegmentHeader, 3> segments; // Text, RoData, Data (in that order)
+    u32_le bss_size;
+    INSERT_PADDING_BYTES(0x1c);
+    std::array<u32_le, 3> segments_compressed_size;
+};
+static_assert(sizeof(NsoHeader) == 0x6c, "NsoHeader has incorrect size.");
+
+struct ModHeader {
+    u32_le magic;
+    u32_le dynamic_offset;
+    u32_le bss_start_offset;
+    u32_le bss_end_offset;
+    u32_le eh_frame_hdr_start_offset;
+    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) == 0x1c, "ModHeader has incorrect size.");
+
+FileType AppLoader_NSO::IdentifyType(FileUtil::IOFile& file) {
+    u32 magic = 0;
+    file.Seek(0, SEEK_SET);
+    if (1 != file.ReadArray<u32>(&magic, 1)) {
+        return FileType::Error;
+    }
+
+    if (MakeMagic('N', 'S', 'O', '0') == magic) {
+        return FileType::NSO;
+    }
+
+    return FileType::Error;
+}
+
+static std::vector<u8> ReadSegment(FileUtil::IOFile& file, const NsoSegmentHeader& header,
+                                   int compressed_size) {
+    std::vector<u8> compressed_data;
+    compressed_data.resize(compressed_size);
+
+    file.Seek(header.offset, SEEK_SET);
+    if (compressed_size != file.ReadBytes(compressed_data.data(), compressed_size)) {
+        LOG_CRITICAL(Loader, "Failed to read %d NSO LZ4 compressed bytes", compressed_size);
+        return {};
+    }
+
+    std::vector<u8> uncompressed_data;
+    uncompressed_data.resize(header.size);
+    const int bytes_uncompressed = LZ4_decompress_safe(
+        reinterpret_cast<const char*>(compressed_data.data()),
+        reinterpret_cast<char*>(uncompressed_data.data()), compressed_size, header.size);
+
+    ASSERT_MSG(bytes_uncompressed == header.size && bytes_uncompressed == uncompressed_data.size(),
+               "%d != %d != %d", bytes_uncompressed, header.size, uncompressed_data.size());
+
+    return uncompressed_data;
+}
+
+static constexpr u32 PageAlignSize(u32 size) {
+    return (size + Memory::PAGE_MASK) & ~Memory::PAGE_MASK;
+}
+
+VAddr AppLoader_NSO::LoadNso(const std::string& path, VAddr load_base, bool relocate) {
+    FileUtil::IOFile file(path, "rb");
+    if (!file.IsOpen()) {
+        return {};
+    }
+
+    // Read NSO header
+    NsoHeader nso_header{};
+    file.Seek(0, SEEK_SET);
+    if (sizeof(NsoHeader) != file.ReadBytes(&nso_header, sizeof(NsoHeader))) {
+        return {};
+    }
+    if (nso_header.magic != MakeMagic('N', 'S', 'O', '0')) {
+        return {};
+    }
+
+    // Build program image
+    Kernel::SharedPtr<Kernel::CodeSet> codeset = Kernel::CodeSet::Create("", 0);
+    std::vector<u8> program_image;
+    for (int i = 0; i < nso_header.segments.size(); ++i) {
+        std::vector<u8> data =
+            ReadSegment(file, nso_header.segments[i], nso_header.segments_compressed_size[i]);
+        program_image.resize(nso_header.segments[i].location);
+        program_image.insert(program_image.end(), data.begin(), data.end());
+        codeset->segments[i].addr = nso_header.segments[i].location;
+        codeset->segments[i].offset = nso_header.segments[i].location;
+        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() + 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
+        bss_size = PageAlignSize(mod_header.bss_end_offset - mod_header.bss_start_offset);
+        codeset->data.size += bss_size;
+    }
+    const u32 image_size{PageAlignSize(static_cast<u32>(program_image.size()) + bss_size)};
+    program_image.resize(image_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) {
+        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);
+
+    return load_base + image_size;
+}
+
+ResultStatus AppLoader_NSO::Load(Kernel::SharedPtr<Kernel::Process>& process) {
+    if (is_loaded) {
+        return ResultStatus::ErrorAlreadyLoaded;
+    }
+    if (!file.IsOpen()) {
+        return ResultStatus::Error;
+    }
+
+    // Load and relocate "rtld" NSO
+    static constexpr VAddr base_addr{Memory::PROCESS_IMAGE_VADDR};
+    process = Kernel::Process::Create("main");
+    VAddr next_base_addr{LoadNso(filepath, base_addr)};
+    if (!next_base_addr) {
+        return ResultStatus::ErrorInvalidFormat;
+    }
+
+    // Load and relocate remaining submodules
+    for (const auto& module_name : {"main", "sdk", "subsdk0", "subsdk1"}) {
+        const std::string module_path =
+            filepath.substr(0, filepath.find_last_of("/\\")) + "/" + module_name;
+        next_base_addr = LoadNso(module_path, next_base_addr);
+        if (!next_base_addr) {
+            LOG_WARNING(Loader, "failed to find load module: %s", module_name);
+        }
+    }
+
+    process->svc_access_mask.set();
+    process->address_mappings = default_address_mappings;
+    process->resource_limit =
+        Kernel::ResourceLimit::GetForCategory(Kernel::ResourceLimitCategory::APPLICATION);
+    process->Run(base_addr, 48, Kernel::DEFAULT_STACK_SIZE);
+
+    ResolveImports();
+
+    is_loaded = true;
+    return ResultStatus::Success;
+}
+
+} // namespace Loader
diff --git a/src/core/loader/nso.h b/src/core/loader/nso.h
new file mode 100644
index 000000000..b6b86c209
--- /dev/null
+++ b/src/core/loader/nso.h
@@ -0,0 +1,43 @@
+// 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 NSO file
+class AppLoader_NSO final : public AppLoader, Linker {
+public:
+    AppLoader_NSO(FileUtil::IOFile&& file, std::string filepath)
+        : AppLoader(std::move(file)), 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(Kernel::SharedPtr<Kernel::Process>& process) override;
+
+private:
+    VAddr LoadNso(const std::string& path, VAddr load_base, bool relocate = false);
+
+    std::string filepath;
+};
+
+} // namespace Loader
diff --git a/src/core/memory.cpp b/src/core/memory.cpp
index 7f58be6de..462d68386 100644
--- a/src/core/memory.cpp
+++ b/src/core/memory.cpp
@@ -37,14 +37,14 @@ PageTable* GetCurrentPageTable() {
     return current_page_table;
 }
 
-static void MapPages(PageTable& page_table, u32 base, u32 size, u8* memory, PageType type) {
+static void MapPages(PageTable& page_table, VAddr base, u32 size, u8* memory, PageType type) {
     LOG_DEBUG(HW_Memory, "Mapping %p onto %08X-%08X", memory, base * PAGE_SIZE,
               (base + size) * PAGE_SIZE);
 
     RasterizerFlushVirtualRegion(base << PAGE_BITS, size * PAGE_SIZE,
                                  FlushMode::FlushAndInvalidate);
 
-    u32 end = base + size;
+    VAddr end = base + size;
     while (base != end) {
         ASSERT_MSG(base < PAGE_TABLE_NUM_ENTRIES, "out of range mapping at %08X", base);
 
@@ -303,7 +303,7 @@ u8* GetPhysicalPointer(PAddr address) {
         return nullptr;
     }
 
-    u32 offset_into_region = address - area->paddr_base;
+    u64 offset_into_region = address - area->paddr_base;
 
     u8* target_pointer = nullptr;
     switch (area->paddr_base) {
@@ -339,7 +339,7 @@ void RasterizerMarkRegionCached(PAddr start, u32 size, int count_delta) {
         return;
     }
 
-    u32 num_pages = ((start + size - 1) >> PAGE_BITS) - (start >> PAGE_BITS) + 1;
+    u64 num_pages = ((start + size - 1) >> PAGE_BITS) - (start >> PAGE_BITS) + 1;
     PAddr paddr = start;
 
     for (unsigned i = 0; i < num_pages; ++i, paddr += PAGE_SIZE) {
@@ -443,7 +443,7 @@ void RasterizerFlushVirtualRegion(VAddr start, u32 size, FlushMode mode) {
             VAddr overlap_end = std::min(end, region_end);
 
             PAddr physical_start = TryVirtualToPhysicalAddress(overlap_start).value();
-            u32 overlap_size = overlap_end - overlap_start;
+            u32 overlap_size = static_cast<u32>(overlap_end - overlap_start);
 
             auto* rasterizer = VideoCore::g_renderer->Rasterizer();
             switch (mode) {
diff --git a/src/core/memory.h b/src/core/memory.h
index dd599f73e..9a04b9a16 100644
--- a/src/core/memory.h
+++ b/src/core/memory.h
@@ -6,6 +6,7 @@
 
 #include <array>
 #include <cstddef>
+#include <map>
 #include <string>
 #include <vector>
 #include <boost/optional.hpp>
@@ -22,10 +23,10 @@ namespace Memory {
  * Page size used by the ARM architecture. This is the smallest granularity with which memory can
  * be mapped.
  */
-const u32 PAGE_SIZE = 0x1000;
-const u32 PAGE_MASK = PAGE_SIZE - 1;
 const int PAGE_BITS = 12;
-const size_t PAGE_TABLE_NUM_ENTRIES = 1 << (32 - PAGE_BITS);
+const u64 PAGE_SIZE = 1 << PAGE_BITS;
+const u64 PAGE_MASK = PAGE_SIZE - 1;
+const size_t PAGE_TABLE_NUM_ENTRIES = 1ULL << (32 - PAGE_BITS);
 
 enum class PageType {
     /// Page is unmapped and should cause an access error.
@@ -124,8 +125,8 @@ enum : PAddr {
 /// Virtual user-space memory regions
 enum : VAddr {
     /// Where the application text, data and bss reside.
-    PROCESS_IMAGE_VADDR = 0x00100000,
-    PROCESS_IMAGE_MAX_SIZE = 0x03F00000,
+    PROCESS_IMAGE_VADDR = 0x08000000,
+    PROCESS_IMAGE_MAX_SIZE = 0x08000000,
     PROCESS_IMAGE_VADDR_END = PROCESS_IMAGE_VADDR + PROCESS_IMAGE_MAX_SIZE,
 
     /// Area where IPC buffers are mapped onto.
diff --git a/src/tests/core/arm/arm_test_common.cpp b/src/tests/core/arm/arm_test_common.cpp
index 484713a92..2339bdfb8 100644
--- a/src/tests/core/arm/arm_test_common.cpp
+++ b/src/tests/core/arm/arm_test_common.cpp
@@ -15,7 +15,7 @@ static Memory::PageTable* page_table = nullptr;
 TestEnvironment::TestEnvironment(bool mutable_memory_)
     : mutable_memory(mutable_memory_), test_memory(std::make_shared<TestMemory>(this)) {
 
-    Kernel::g_current_process = Kernel::Process::Create(Kernel::CodeSet::Create("", 0));
+    Kernel::g_current_process = Kernel::Process::Create("");
     page_table = &Kernel::g_current_process->vm_manager.page_table;
 
     page_table->pointers.fill(nullptr);
diff --git a/src/tests/core/hle/kernel/hle_ipc.cpp b/src/tests/core/hle/kernel/hle_ipc.cpp
index 52336d027..4143a3ab8 100644
--- a/src/tests/core/hle/kernel/hle_ipc.cpp
+++ b/src/tests/core/hle/kernel/hle_ipc.cpp
@@ -22,7 +22,7 @@ TEST_CASE("HLERequestContext::PopulateFromIncomingCommandBuffer", "[core][kernel
     auto session = std::get<SharedPtr<ServerSession>>(ServerSession::CreateSessionPair());
     HLERequestContext context(std::move(session));
 
-    auto process = Process::Create(CodeSet::Create("", 0));
+    auto process = Process::Create("");
     HandleTable handle_table;
 
     SECTION("works with empty cmdbuf") {
@@ -142,7 +142,7 @@ TEST_CASE("HLERequestContext::WriteToOutgoingCommandBuffer", "[core][kernel]") {
     auto session = std::get<SharedPtr<ServerSession>>(ServerSession::CreateSessionPair());
     HLERequestContext context(std::move(session));
 
-    auto process = Process::Create(CodeSet::Create("", 0));
+    auto process = Process::Create("");
     HandleTable handle_table;
     auto* input = context.CommandBuffer();
     u32_le output[IPC::COMMAND_BUFFER_LENGTH];
diff --git a/src/tests/core/memory/memory.cpp b/src/tests/core/memory/memory.cpp
index a01b896f7..671afb702 100644
--- a/src/tests/core/memory/memory.cpp
+++ b/src/tests/core/memory/memory.cpp
@@ -9,7 +9,7 @@
 
 TEST_CASE("Memory::IsValidVirtualAddress", "[core][memory]") {
     SECTION("these regions should not be mapped on an empty process") {
-        auto process = Kernel::Process::Create(Kernel::CodeSet::Create("", 0));
+        auto process = Kernel::Process::Create("");
         CHECK(Memory::IsValidVirtualAddress(*process, Memory::PROCESS_IMAGE_VADDR) == false);
         CHECK(Memory::IsValidVirtualAddress(*process, Memory::HEAP_VADDR) == false);
         CHECK(Memory::IsValidVirtualAddress(*process, Memory::LINEAR_HEAP_VADDR) == false);
@@ -20,14 +20,14 @@ TEST_CASE("Memory::IsValidVirtualAddress", "[core][memory]") {
     }
 
     SECTION("CONFIG_MEMORY_VADDR and SHARED_PAGE_VADDR should be valid after mapping them") {
-        auto process = Kernel::Process::Create(Kernel::CodeSet::Create("", 0));
+        auto process = Kernel::Process::Create("");
         Kernel::MapSharedPages(process->vm_manager);
         CHECK(Memory::IsValidVirtualAddress(*process, Memory::CONFIG_MEMORY_VADDR) == true);
         CHECK(Memory::IsValidVirtualAddress(*process, Memory::SHARED_PAGE_VADDR) == true);
     }
 
     SECTION("special regions should be valid after mapping them") {
-        auto process = Kernel::Process::Create(Kernel::CodeSet::Create("", 0));
+        auto process = Kernel::Process::Create("");
         SECTION("VRAM") {
             Kernel::HandleSpecialMapping(process->vm_manager,
                                          {Memory::VRAM_VADDR, Memory::VRAM_SIZE, false, false});
@@ -48,7 +48,7 @@ TEST_CASE("Memory::IsValidVirtualAddress", "[core][memory]") {
     }
 
     SECTION("Unmapping a VAddr should make it invalid") {
-        auto process = Kernel::Process::Create(Kernel::CodeSet::Create("", 0));
+        auto process = Kernel::Process::Create("");
         Kernel::MapSharedPages(process->vm_manager);
         process->vm_manager.UnmapRange(Memory::CONFIG_MEMORY_VADDR, Memory::CONFIG_MEMORY_SIZE);
         CHECK(Memory::IsValidVirtualAddress(*process, Memory::CONFIG_MEMORY_VADDR) == false);