shader_bytecode: Add constexpr to default constructor of Attribute and Sampler

We already have a constexpr constructor that takes a paremeter, so the
other constructor should have it too.

src/common/file_util.cpp

@@ -792,93 +792,70 @@ void SplitFilename83(const std::string& filename, std::array<char, 9>& short_nam
     }
 }
 
-std::vector<std::string> SplitPathComponents(std::string_view filename) {
-    std::string copy(filename);
+std::vector<std::string> SplitPathComponents(const std::string& filename) {
+    auto copy(filename);
     std::replace(copy.begin(), copy.end(), '\\', '/');
     std::vector<std::string> out;
 
-    std::stringstream stream(copy);
+    std::stringstream stream(filename);
     std::string item;
-    while (std::getline(stream, item, '/')) {
+    while (std::getline(stream, item, '/'))
         out.push_back(std::move(item));
-    }
 
     return out;
 }
 
-std::string_view GetParentPath(std::string_view path) {
-    const auto name_bck_index = path.rfind('\\');
-    const auto name_fwd_index = path.rfind('/');
+std::string GetParentPath(const std::string& path) {
+    auto out = path;
+    const auto name_bck_index = out.find_last_of('\\');
+    const auto name_fwd_index = out.find_last_of('/');
     size_t name_index;
+    if (name_bck_index == std::string::npos || name_fwd_index == std::string::npos)
+        name_index = std::min<size_t>(name_bck_index, name_fwd_index);
+    else
+        name_index = std::max<size_t>(name_bck_index, name_fwd_index);
 
-    if (name_bck_index == std::string_view::npos || name_fwd_index == std::string_view::npos) {
-        name_index = std::min(name_bck_index, name_fwd_index);
-    } else {
-        name_index = std::max(name_bck_index, name_fwd_index);
-    }
-
-    return path.substr(0, name_index);
+    return out.erase(name_index);
 }
 
-std::string_view GetPathWithoutTop(std::string_view path) {
-    if (path.empty()) {
-        return path;
-    }
-
+std::string GetPathWithoutTop(std::string path) {
+    if (path.empty())
+        return "";
     while (path[0] == '\\' || path[0] == '/') {
-        path.remove_prefix(1);
-        if (path.empty()) {
-            return path;
-        }
+        path = path.substr(1);
+        if (path.empty())
+            return "";
     }
-
-    const auto name_bck_index = path.find('\\');
-    const auto name_fwd_index = path.find('/');
+    const auto name_bck_index = path.find_first_of('\\');
+    const auto name_fwd_index = path.find_first_of('/');
     return path.substr(std::min(name_bck_index, name_fwd_index) + 1);
 }
 
-std::string_view GetFilename(std::string_view path) {
-    const auto name_index = path.find_last_of("\\/");
-
-    if (name_index == std::string_view::npos) {
-        return {};
-    }
-
+std::string GetFilename(std::string path) {
+    std::replace(path.begin(), path.end(), '\\', '/');
+    auto name_index = path.find_last_of('/');
+    if (name_index == std::string::npos)
+        return "";
     return path.substr(name_index + 1);
 }
 
-std::string_view GetExtensionFromFilename(std::string_view name) {
-    const size_t index = name.rfind('.');
-
-    if (index == std::string_view::npos) {
-        return {};
-    }
+std::string GetExtensionFromFilename(const std::string& name) {
+    size_t index = name.find_last_of('.');
+    if (index == std::string::npos)
+        return "";
 
     return name.substr(index + 1);
 }
 
-std::string_view RemoveTrailingSlash(std::string_view path) {
-    if (path.empty()) {
+std::string RemoveTrailingSlash(const std::string& path) {
+    if (path.empty())
         return path;
-    }
-
-    if (path.back() == '\\' || path.back() == '/') {
-        path.remove_suffix(1);
-        return path;
-    }
+    if (path.back() == '\\' || path.back() == '/')
+        return path.substr(0, path.size() - 1);
 
     return path;
 }
 
-std::string SanitizePath(std::string_view path_) {
-    std::string path(path_);
-    std::replace(path.begin(), path.end(), '\\', '/');
-    path.erase(std::unique(path.begin(), path.end(),
-                           [](char c1, char c2) { return c1 == '/' && c2 == '/'; }),
-               path.end());
-    return std::string(RemoveTrailingSlash(path));
-}
-
 IOFile::IOFile() {}
 
 IOFile::IOFile(const std::string& filename, const char openmode[], int flags) {

src/common/file_util.h

@@ -9,7 +9,6 @@
 #include <fstream>
 #include <functional>
 #include <string>
-#include <string_view>
 #include <type_traits>
 #include <vector>
 #include "common/common_types.h"
@@ -152,22 +151,22 @@ void SplitFilename83(const std::string& filename, std::array<char, 9>& short_nam
 
 // Splits the path on '/' or '\' and put the components into a vector
 // i.e. "C:\Users\Yuzu\Documents\save.bin" becomes {"C:", "Users", "Yuzu", "Documents", "save.bin" }
-std::vector<std::string> SplitPathComponents(std::string_view filename);
+std::vector<std::string> SplitPathComponents(const std::string& filename);
 
 // Gets all of the text up to the last '/' or '\' in the path.
-std::string_view GetParentPath(std::string_view path);
+std::string GetParentPath(const std::string& path);
 
 // Gets all of the text after the first '/' or '\' in the path.
-std::string_view GetPathWithoutTop(std::string_view path);
+std::string GetPathWithoutTop(std::string path);
 
 // Gets the filename of the path
-std::string_view GetFilename(std::string_view path);
+std::string GetFilename(std::string path);
 
 // Gets the extension of the filename
-std::string_view GetExtensionFromFilename(std::string_view name);
+std::string GetExtensionFromFilename(const std::string& name);
 
 // Removes the final '/' or '\' if one exists
-std::string_view RemoveTrailingSlash(std::string_view path);
+std::string RemoveTrailingSlash(const std::string& path);
 
 // Creates a new vector containing indices [first, last) from the original.
 template <typename T>
@@ -178,9 +177,6 @@ std::vector<T> SliceVector(const std::vector<T>& vector, size_t first, size_t la
     return std::vector<T>(vector.begin() + first, vector.begin() + first + last);
 }
 
-// Removes trailing slash, makes all '\\' into '/', and removes duplicate '/'.
-std::string SanitizePath(std::string_view path);
-
 // simple wrapper for cstdlib file functions to
 // hopefully will make error checking easier
 // and make forgetting an fclose() harder

src/common/string_util.cpp

@@ -162,21 +162,21 @@ void SplitString(const std::string& str, const char delim, std::vector<std::stri
     std::istringstream iss(str);
     output.resize(1);
 
-    while (std::getline(iss, *output.rbegin(), delim)) {
-        output.emplace_back();
-    }
+    while (std::getline(iss, *output.rbegin(), delim))
+        output.push_back("");
 
     output.pop_back();
 }
 
-std::string TabsToSpaces(int tab_size, std::string in) {
+std::string TabsToSpaces(int tab_size, const std::string& in) {
+    const std::string spaces(tab_size, ' ');
+    std::string out(in);
+
     size_t i = 0;
+    while (out.npos != (i = out.find('\t')))
+        out.replace(i, 1, spaces);
 
-    while ((i = in.find('\t')) != std::string::npos) {
-        in.replace(i, 1, tab_size, ' ');
-    }
-
-    return in;
+    return out;
 }
 
 std::string ReplaceAll(std::string result, const std::string& src, const std::string& dest) {
@@ -220,37 +220,31 @@ std::u16string UTF8ToUTF16(const std::string& input) {
 }
 
 static std::wstring CPToUTF16(u32 code_page, const std::string& input) {
-    const auto size =
+    auto const size =
         MultiByteToWideChar(code_page, 0, input.data(), static_cast<int>(input.size()), nullptr, 0);
 
-    if (size == 0) {
-        return L"";
-    }
+    std::wstring output;
+    output.resize(size);
 
-    std::wstring output(size, L'\0');
-
-    if (size != MultiByteToWideChar(code_page, 0, input.data(), static_cast<int>(input.size()),
-                                    &output[0], static_cast<int>(output.size()))) {
+    if (size == 0 ||
+        size != MultiByteToWideChar(code_page, 0, input.data(), static_cast<int>(input.size()),
+                                    &output[0], static_cast<int>(output.size())))
         output.clear();
-    }
 
     return output;
 }
 
 std::string UTF16ToUTF8(const std::wstring& input) {
-    const auto size = WideCharToMultiByte(CP_UTF8, 0, input.data(), static_cast<int>(input.size()),
+    auto const size = WideCharToMultiByte(CP_UTF8, 0, input.data(), static_cast<int>(input.size()),
                                           nullptr, 0, nullptr, nullptr);
-    if (size == 0) {
-        return "";
-    }
 
-    std::string output(size, '\0');
+    std::string output;
+    output.resize(size);
 
-    if (size != WideCharToMultiByte(CP_UTF8, 0, input.data(), static_cast<int>(input.size()),
-                                    &output[0], static_cast<int>(output.size()), nullptr,
-                                    nullptr)) {
+    if (size == 0 ||
+        size != WideCharToMultiByte(CP_UTF8, 0, input.data(), static_cast<int>(input.size()),
+                                    &output[0], static_cast<int>(output.size()), nullptr, nullptr))
         output.clear();
-    }
 
     return output;
 }
@@ -271,6 +265,8 @@ std::string CP1252ToUTF8(const std::string& input) {
 
 template <typename T>
 static std::string CodeToUTF8(const char* fromcode, const std::basic_string<T>& input) {
+    std::string result;
+
     iconv_t const conv_desc = iconv_open("UTF-8", fromcode);
     if ((iconv_t)(-1) == conv_desc) {
         LOG_ERROR(Common, "Iconv initialization failure [{}]: {}", fromcode, strerror(errno));
@@ -282,7 +278,8 @@ static std::string CodeToUTF8(const char* fromcode, const std::basic_string<T>&
     // Multiply by 4, which is the max number of bytes to encode a codepoint
     const size_t out_buffer_size = 4 * in_bytes;
 
-    std::string out_buffer(out_buffer_size, '\0');
+    std::string out_buffer;
+    out_buffer.resize(out_buffer_size);
 
     auto src_buffer = &input[0];
     size_t src_bytes = in_bytes;
@@ -307,7 +304,6 @@ static std::string CodeToUTF8(const char* fromcode, const std::basic_string<T>&
         }
     }
 
-    std::string result;
     out_buffer.resize(out_buffer_size - dst_bytes);
     out_buffer.swap(result);
 
@@ -317,6 +313,8 @@ static std::string CodeToUTF8(const char* fromcode, const std::basic_string<T>&
 }
 
 std::u16string UTF8ToUTF16(const std::string& input) {
+    std::u16string result;
+
     iconv_t const conv_desc = iconv_open("UTF-16LE", "UTF-8");
     if ((iconv_t)(-1) == conv_desc) {
         LOG_ERROR(Common, "Iconv initialization failure [UTF-8]: {}", strerror(errno));
@@ -328,7 +326,8 @@ std::u16string UTF8ToUTF16(const std::string& input) {
     // Multiply by 4, which is the max number of bytes to encode a codepoint
     const size_t out_buffer_size = 4 * sizeof(char16_t) * in_bytes;
 
-    std::u16string out_buffer(out_buffer_size, char16_t{});
+    std::u16string out_buffer;
+    out_buffer.resize(out_buffer_size);
 
     char* src_buffer = const_cast<char*>(&input[0]);
     size_t src_bytes = in_bytes;
@@ -353,7 +352,6 @@ std::u16string UTF8ToUTF16(const std::string& input) {
         }
     }
 
-    std::u16string result;
     out_buffer.resize(out_buffer_size - dst_bytes);
     out_buffer.swap(result);
 

src/common/string_util.h

@@ -57,7 +57,7 @@ static bool TryParse(const std::string& str, N* const output) {
         return false;
 }
 
-std::string TabsToSpaces(int tab_size, std::string in);
+std::string TabsToSpaces(int tab_size, const std::string& in);
 
 void SplitString(const std::string& str, char delim, std::vector<std::string>& output);
 

src/core/CMakeLists.txt

@@ -1,7 +1,5 @@
 add_library(core STATIC
     arm/arm_interface.h
-    arm/exclusive_monitor.cpp
-    arm/exclusive_monitor.h
     arm/unicorn/arm_unicorn.cpp
     arm/unicorn/arm_unicorn.h
     core.cpp
@@ -12,8 +10,6 @@ add_library(core STATIC
     core_timing.h
     file_sys/content_archive.cpp
     file_sys/content_archive.h
-    file_sys/control_metadata.cpp
-    file_sys/control_metadata.h
     file_sys/directory.h
     file_sys/errors.h
     file_sys/mode.h
@@ -40,6 +36,8 @@ add_library(core STATIC
     frontend/input.h
     gdbstub/gdbstub.cpp
     gdbstub/gdbstub.h
+    hle/config_mem.cpp
+    hle/config_mem.h
     hle/ipc.h
     hle/ipc_helpers.h
     hle/kernel/address_arbiter.cpp
@@ -249,6 +247,8 @@ add_library(core STATIC
     hle/service/vi/vi_s.h
     hle/service/vi/vi_u.cpp
     hle/service/vi/vi_u.h
+    hle/shared_page.cpp
+    hle/shared_page.h
     hw/hw.cpp
     hw/hw.h
     hw/lcd.cpp

src/core/arm/dynarmic/arm_dynarmic.cpp

@@ -102,28 +102,18 @@ public:
     u64 tpidr_el0 = 0;
 };
 
-std::unique_ptr<Dynarmic::A64::Jit> ARM_Dynarmic::MakeJit() const {
-    auto** const page_table = Core::CurrentProcess()->vm_manager.page_table.pointers.data();
+std::unique_ptr<Dynarmic::A64::Jit> MakeJit(const std::unique_ptr<ARM_Dynarmic_Callbacks>& cb) {
+    const auto page_table = Core::CurrentProcess()->vm_manager.page_table.pointers.data();
 
     Dynarmic::A64::UserConfig config;
-
-    // Callbacks
     config.callbacks = cb.get();
-
-    // Memory
-    config.page_table = reinterpret_cast<void**>(page_table);
-    config.page_table_address_space_bits = Memory::ADDRESS_SPACE_BITS;
-    config.silently_mirror_page_table = false;
-
-    // Multi-process state
-    config.processor_id = core_index;
-    config.global_monitor = &exclusive_monitor->monitor;
-
-    // System registers
     config.tpidrro_el0 = &cb->tpidrro_el0;
     config.tpidr_el0 = &cb->tpidr_el0;
     config.dczid_el0 = 4;
     config.ctr_el0 = 0x8444c004;
+    config.page_table = reinterpret_cast<void**>(page_table);
+    config.page_table_address_space_bits = Memory::ADDRESS_SPACE_BITS;
+    config.silently_mirror_page_table = false;
 
     return std::make_unique<Dynarmic::A64::Jit>(config);
 }
@@ -138,11 +128,8 @@ void ARM_Dynarmic::Step() {
     cb->InterpreterFallback(jit->GetPC(), 1);
 }
 
-ARM_Dynarmic::ARM_Dynarmic(std::shared_ptr<ExclusiveMonitor> exclusive_monitor, size_t core_index)
-    : cb(std::make_unique<ARM_Dynarmic_Callbacks>(*this)),
-      jit(MakeJit()), exclusive_monitor{std::dynamic_pointer_cast<DynarmicExclusiveMonitor>(
-                          exclusive_monitor)},
-      core_index{core_index} {
+ARM_Dynarmic::ARM_Dynarmic()
+    : cb(std::make_unique<ARM_Dynarmic_Callbacks>(*this)), jit(MakeJit(cb)) {
     ARM_Interface::ThreadContext ctx;
     inner_unicorn.SaveContext(ctx);
     LoadContext(ctx);
@@ -250,45 +237,6 @@ void ARM_Dynarmic::ClearExclusiveState() {
 }
 
 void ARM_Dynarmic::PageTableChanged() {
-    jit = MakeJit();
+    jit = MakeJit(cb);
     current_page_table = Memory::GetCurrentPageTable();
 }
-
-DynarmicExclusiveMonitor::DynarmicExclusiveMonitor(size_t core_count) : monitor(core_count) {}
-DynarmicExclusiveMonitor::~DynarmicExclusiveMonitor() = default;
-
-void DynarmicExclusiveMonitor::SetExclusive(size_t core_index, VAddr addr) {
-    // Size doesn't actually matter.
-    monitor.Mark(core_index, addr, 16);
-}
-
-void DynarmicExclusiveMonitor::ClearExclusive() {
-    monitor.Clear();
-}
-
-bool DynarmicExclusiveMonitor::ExclusiveWrite8(size_t core_index, VAddr vaddr, u8 value) {
-    return monitor.DoExclusiveOperation(core_index, vaddr, 1,
-                                        [&] { Memory::Write8(vaddr, value); });
-}
-
-bool DynarmicExclusiveMonitor::ExclusiveWrite16(size_t core_index, VAddr vaddr, u16 value) {
-    return monitor.DoExclusiveOperation(core_index, vaddr, 2,
-                                        [&] { Memory::Write16(vaddr, value); });
-}
-
-bool DynarmicExclusiveMonitor::ExclusiveWrite32(size_t core_index, VAddr vaddr, u32 value) {
-    return monitor.DoExclusiveOperation(core_index, vaddr, 4,
-                                        [&] { Memory::Write32(vaddr, value); });
-}
-
-bool DynarmicExclusiveMonitor::ExclusiveWrite64(size_t core_index, VAddr vaddr, u64 value) {
-    return monitor.DoExclusiveOperation(core_index, vaddr, 8,
-                                        [&] { Memory::Write64(vaddr, value); });
-}
-
-bool DynarmicExclusiveMonitor::ExclusiveWrite128(size_t core_index, VAddr vaddr, u128 value) {
-    return monitor.DoExclusiveOperation(core_index, vaddr, 16, [&] {
-        Memory::Write64(vaddr, value[0]);
-        Memory::Write64(vaddr, value[1]);
-    });
-}

src/core/arm/dynarmic/arm_dynarmic.h

@@ -6,18 +6,15 @@
 
 #include <memory>
 #include <dynarmic/A64/a64.h>
-#include <dynarmic/A64/exclusive_monitor.h>
 #include "common/common_types.h"
 #include "core/arm/arm_interface.h"
-#include "core/arm/exclusive_monitor.h"
 #include "core/arm/unicorn/arm_unicorn.h"
 
 class ARM_Dynarmic_Callbacks;
-class DynarmicExclusiveMonitor;
 
 class ARM_Dynarmic final : public ARM_Interface {
 public:
-    ARM_Dynarmic(std::shared_ptr<ExclusiveMonitor> exclusive_monitor, size_t core_index);
+    ARM_Dynarmic();
     ~ARM_Dynarmic();
 
     void MapBackingMemory(VAddr address, size_t size, u8* memory,
@@ -50,34 +47,10 @@ public:
     void PageTableChanged() override;
 
 private:
-    std::unique_ptr<Dynarmic::A64::Jit> MakeJit() const;
-
     friend class ARM_Dynarmic_Callbacks;
     std::unique_ptr<ARM_Dynarmic_Callbacks> cb;
     std::unique_ptr<Dynarmic::A64::Jit> jit;
     ARM_Unicorn inner_unicorn;
 
-    size_t core_index;
-    std::shared_ptr<DynarmicExclusiveMonitor> exclusive_monitor;
-
     Memory::PageTable* current_page_table = nullptr;
 };
-
-class DynarmicExclusiveMonitor final : public ExclusiveMonitor {
-public:
-    explicit DynarmicExclusiveMonitor(size_t core_count);
-    ~DynarmicExclusiveMonitor();
-
-    void SetExclusive(size_t core_index, VAddr addr) override;
-    void ClearExclusive() override;
-
-    bool ExclusiveWrite8(size_t core_index, VAddr vaddr, u8 value) override;
-    bool ExclusiveWrite16(size_t core_index, VAddr vaddr, u16 value) override;
-    bool ExclusiveWrite32(size_t core_index, VAddr vaddr, u32 value) override;
-    bool ExclusiveWrite64(size_t core_index, VAddr vaddr, u64 value) override;
-    bool ExclusiveWrite128(size_t core_index, VAddr vaddr, u128 value) override;
-
-private:
-    friend class ARM_Dynarmic;
-    Dynarmic::A64::ExclusiveMonitor monitor;
-};

src/core/arm/exclusive_monitor.cpp

@@ -1,7 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/arm/exclusive_monitor.h"
-
-ExclusiveMonitor::~ExclusiveMonitor() = default;

src/core/arm/exclusive_monitor.h

@@ -1,21 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "common/common_types.h"
-
-class ExclusiveMonitor {
-public:
-    virtual ~ExclusiveMonitor();
-
-    virtual void SetExclusive(size_t core_index, VAddr addr) = 0;
-    virtual void ClearExclusive() = 0;
-
-    virtual bool ExclusiveWrite8(size_t core_index, VAddr vaddr, u8 value) = 0;
-    virtual bool ExclusiveWrite16(size_t core_index, VAddr vaddr, u16 value) = 0;
-    virtual bool ExclusiveWrite32(size_t core_index, VAddr vaddr, u32 value) = 0;
-    virtual bool ExclusiveWrite64(size_t core_index, VAddr vaddr, u64 value) = 0;
-    virtual bool ExclusiveWrite128(size_t core_index, VAddr vaddr, u128 value) = 0;
-};

src/core/core.cpp

@@ -171,9 +171,8 @@ System::ResultStatus System::Init(EmuWindow* emu_window, u32 system_mode) {
     current_process = Kernel::Process::Create("main");
 
     cpu_barrier = std::make_shared<CpuBarrier>();
-    cpu_exclusive_monitor = Cpu::MakeExclusiveMonitor(cpu_cores.size());
     for (size_t index = 0; index < cpu_cores.size(); ++index) {
-        cpu_cores[index] = std::make_shared<Cpu>(cpu_exclusive_monitor, cpu_barrier, index);
+        cpu_cores[index] = std::make_shared<Cpu>(cpu_barrier, index);
     }
 
     gpu_core = std::make_unique<Tegra::GPU>();

src/core/core.h

@@ -9,7 +9,6 @@
 #include <string>
 #include <thread>
 #include "common/common_types.h"
-#include "core/arm/exclusive_monitor.h"
 #include "core/core_cpu.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/scheduler.h"
@@ -115,11 +114,6 @@ public:
         return CurrentCpuCore().ArmInterface();
     }
 
-    /// Gets the index of the currently running CPU core
-    size_t CurrentCoreIndex() {
-        return CurrentCpuCore().CoreIndex();
-    }
-
     /// Gets an ARM interface to the CPU core with the specified index
     ARM_Interface& ArmInterface(size_t core_index);
 
@@ -136,11 +130,6 @@ public:
         return *CurrentCpuCore().Scheduler();
     }
 
-    /// Gets the exclusive monitor
-    ExclusiveMonitor& Monitor() {
-        return *cpu_exclusive_monitor;
-    }
-
     /// Gets the scheduler for the CPU core with the specified index
     const std::shared_ptr<Kernel::Scheduler>& Scheduler(size_t core_index);
 
@@ -197,7 +186,6 @@ private:
     std::unique_ptr<Tegra::GPU> gpu_core;
     std::shared_ptr<Tegra::DebugContext> debug_context;
     Kernel::SharedPtr<Kernel::Process> current_process;
-    std::shared_ptr<ExclusiveMonitor> cpu_exclusive_monitor;
     std::shared_ptr<CpuBarrier> cpu_barrier;
     std::array<std::shared_ptr<Cpu>, NUM_CPU_CORES> cpu_cores;
     std::array<std::unique_ptr<std::thread>, NUM_CPU_CORES - 1> cpu_core_threads;

src/core/core_cpu.cpp

@@ -48,15 +48,14 @@ bool CpuBarrier::Rendezvous() {
     return false;
 }
 
-Cpu::Cpu(std::shared_ptr<ExclusiveMonitor> exclusive_monitor,
-         std::shared_ptr<CpuBarrier> cpu_barrier, size_t core_index)
+Cpu::Cpu(std::shared_ptr<CpuBarrier> cpu_barrier, size_t core_index)
     : cpu_barrier{std::move(cpu_barrier)}, core_index{core_index} {
 
     if (Settings::values.use_cpu_jit) {
 #ifdef ARCHITECTURE_x86_64
-        arm_interface = std::make_shared<ARM_Dynarmic>(exclusive_monitor, core_index);
+        arm_interface = std::make_shared<ARM_Dynarmic>();
 #else
-        arm_interface = std::make_shared<ARM_Unicorn>();
+        cpu_core = std::make_shared<ARM_Unicorn>();
         LOG_WARNING(Core, "CPU JIT requested, but Dynarmic not available");
 #endif
     } else {
@@ -66,18 +65,6 @@ Cpu::Cpu(std::shared_ptr<ExclusiveMonitor> exclusive_monitor,
     scheduler = std::make_shared<Kernel::Scheduler>(arm_interface.get());
 }
 
-std::shared_ptr<ExclusiveMonitor> Cpu::MakeExclusiveMonitor(size_t num_cores) {
-    if (Settings::values.use_cpu_jit) {
-#ifdef ARCHITECTURE_x86_64
-        return std::make_shared<DynarmicExclusiveMonitor>(num_cores);
-#else
-        return nullptr; // TODO(merry): Passthrough exclusive monitor
-#endif
-    } else {
-        return nullptr; // TODO(merry): Passthrough exclusive monitor
-    }
-}
-
 void Cpu::RunLoop(bool tight_loop) {
     // Wait for all other CPU cores to complete the previous slice, such that they run in lock-step
     if (!cpu_barrier->Rendezvous()) {

src/core/core_cpu.h

@@ -10,7 +10,6 @@
 #include <mutex>
 #include <string>
 #include "common/common_types.h"
-#include "core/arm/exclusive_monitor.h"
 
 class ARM_Interface;
 
@@ -41,8 +40,7 @@ private:
 
 class Cpu {
 public:
-    Cpu(std::shared_ptr<ExclusiveMonitor> exclusive_monitor,
-        std::shared_ptr<CpuBarrier> cpu_barrier, size_t core_index);
+    Cpu(std::shared_ptr<CpuBarrier> cpu_barrier, size_t core_index);
 
     void RunLoop(bool tight_loop = true);
 
@@ -66,12 +64,6 @@ public:
         return core_index == 0;
     }
 
-    size_t CoreIndex() const {
-        return core_index;
-    }
-
-    static std::shared_ptr<ExclusiveMonitor> MakeExclusiveMonitor(size_t num_cores);
-
 private:
     void Reschedule();
 

src/core/file_sys/control_metadata.cpp

@@ -1,42 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/string_util.h"
-#include "common/swap.h"
-#include "core/file_sys/control_metadata.h"
-
-namespace FileSys {
-
-std::string LanguageEntry::GetApplicationName() const {
-    return Common::StringFromFixedZeroTerminatedBuffer(application_name.data(), 0x200);
-}
-
-std::string LanguageEntry::GetDeveloperName() const {
-    return Common::StringFromFixedZeroTerminatedBuffer(developer_name.data(), 0x100);
-}
-
-NACP::NACP(VirtualFile file_) : file(std::move(file_)), raw(std::make_unique<RawNACP>()) {
-    file->ReadObject(raw.get());
-}
-
-const LanguageEntry& NACP::GetLanguageEntry(Language language) const {
-    return raw->language_entries.at(static_cast<u8>(language));
-}
-
-std::string NACP::GetApplicationName(Language language) const {
-    return GetLanguageEntry(language).GetApplicationName();
-}
-
-std::string NACP::GetDeveloperName(Language language) const {
-    return GetLanguageEntry(language).GetDeveloperName();
-}
-
-u64 NACP::GetTitleId() const {
-    return raw->title_id;
-}
-
-std::string NACP::GetVersionString() const {
-    return Common::StringFromFixedZeroTerminatedBuffer(raw->version_string.data(), 0x10);
-}
-} // namespace FileSys

src/core/file_sys/control_metadata.h

@@ -1,81 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-#include <memory>
-#include <string>
-#include "common/common_funcs.h"
-#include "core/file_sys/vfs.h"
-
-namespace FileSys {
-
-// A localized entry containing strings within the NACP.
-// One for each language of type Language.
-struct LanguageEntry {
-    std::array<char, 0x200> application_name;
-    std::array<char, 0x100> developer_name;
-
-    std::string GetApplicationName() const;
-    std::string GetDeveloperName() const;
-};
-static_assert(sizeof(LanguageEntry) == 0x300, "LanguageEntry has incorrect size.");
-
-// The raw file format of a NACP file.
-struct RawNACP {
-    std::array<LanguageEntry, 16> language_entries;
-    INSERT_PADDING_BYTES(0x38);
-    u64_le title_id;
-    INSERT_PADDING_BYTES(0x20);
-    std::array<char, 0x10> version_string;
-    u64_le dlc_base_title_id;
-    u64_le title_id_2;
-    INSERT_PADDING_BYTES(0x28);
-    u64_le product_code;
-    u64_le title_id_3;
-    std::array<u64_le, 0x7> title_id_array;
-    INSERT_PADDING_BYTES(0x8);
-    u64_le title_id_update;
-    std::array<u8, 0x40> bcat_passphrase;
-    INSERT_PADDING_BYTES(0xEC0);
-};
-static_assert(sizeof(RawNACP) == 0x4000, "RawNACP has incorrect size.");
-
-// A language on the NX. These are for names and icons.
-enum class Language : u8 {
-    AmericanEnglish = 0,
-    BritishEnglish = 1,
-    Japanese = 2,
-    French = 3,
-    German = 4,
-    LatinAmericanSpanish = 5,
-    Spanish = 6,
-    Italian = 7,
-    Dutch = 8,
-    CanadianFrench = 9,
-    Portugese = 10,
-    Russian = 11,
-    Korean = 12,
-    Taiwanese = 13,
-    Chinese = 14,
-};
-
-// A class representing the format used by NX metadata files, typically named Control.nacp.
-// These store application name, dev name, title id, and other miscellaneous data.
-class NACP {
-public:
-    explicit NACP(VirtualFile file);
-    const LanguageEntry& GetLanguageEntry(Language language = Language::AmericanEnglish) const;
-    std::string GetApplicationName(Language language = Language::AmericanEnglish) const;
-    std::string GetDeveloperName(Language language = Language::AmericanEnglish) const;
-    u64 GetTitleId() const;
-    std::string GetVersionString() const;
-
-private:
-    VirtualFile file;
-    std::unique_ptr<RawNACP> raw;
-};
-
-} // namespace FileSys

src/core/file_sys/mode.h

@@ -11,13 +11,7 @@ namespace FileSys {
 enum class Mode : u32 {
     Read = 1,
     Write = 2,
-    ReadWrite = 3,
     Append = 4,
-    WriteAppend = 6,
 };
 
-inline u32 operator&(Mode lhs, Mode rhs) {
-    return static_cast<u32>(lhs) & static_cast<u32>(rhs);
-}
-
 } // namespace FileSys

src/core/file_sys/partition_filesystem.cpp

@@ -65,8 +65,8 @@ PartitionFilesystem::PartitionFilesystem(std::shared_ptr<VfsFile> file) {
         std::string name(
             reinterpret_cast<const char*>(&file_data[strtab_offset + entry.strtab_offset]));
 
-        pfs_files.emplace_back(std::make_shared<OffsetVfsFile>(
-            file, entry.size, content_offset + entry.offset, std::move(name)));
+        pfs_files.emplace_back(
+            std::make_shared<OffsetVfsFile>(file, entry.size, content_offset + entry.offset, name));
     }
 
     status = Loader::ResultStatus::Success;
@@ -109,7 +109,7 @@ bool PartitionFilesystem::ReplaceFileWithSubdirectory(VirtualFile file, VirtualD
         return false;
 
     const std::ptrdiff_t offset = std::distance(pfs_files.begin(), iter);
-    pfs_files[offset] = std::move(pfs_files.back());
+    pfs_files[offset] = pfs_files.back();
     pfs_files.pop_back();
 
     pfs_dirs.emplace_back(std::move(dir));

src/core/file_sys/vfs.cpp

@@ -13,7 +13,7 @@ namespace FileSys {
 VfsFile::~VfsFile() = default;
 
 std::string VfsFile::GetExtension() const {
-    return std::string(FileUtil::GetExtensionFromFilename(GetName()));
+    return FileUtil::GetExtensionFromFilename(GetName());
 }
 
 VfsDirectory::~VfsDirectory() = default;
@@ -46,80 +46,64 @@ size_t VfsFile::WriteBytes(const std::vector<u8>& data, size_t offset) {
     return Write(data.data(), data.size(), offset);
 }
 
-std::shared_ptr<VfsFile> VfsDirectory::GetFileRelative(std::string_view path) const {
+std::shared_ptr<VfsFile> VfsDirectory::GetFileRelative(const std::string& path) const {
     auto vec = FileUtil::SplitPathComponents(path);
     vec.erase(std::remove_if(vec.begin(), vec.end(), [](const auto& str) { return str.empty(); }),
               vec.end());
-    if (vec.empty()) {
+    if (vec.empty())
         return nullptr;
-    }
-
-    if (vec.size() == 1) {
+    if (vec.size() == 1)
         return GetFile(vec[0]);
-    }
-
     auto dir = GetSubdirectory(vec[0]);
     for (size_t component = 1; component < vec.size() - 1; ++component) {
-        if (dir == nullptr) {
+        if (dir == nullptr)
             return nullptr;
-        }
-
         dir = dir->GetSubdirectory(vec[component]);
     }
-
-    if (dir == nullptr) {
+    if (dir == nullptr)
         return nullptr;
-    }
-
     return dir->GetFile(vec.back());
 }
 
-std::shared_ptr<VfsFile> VfsDirectory::GetFileAbsolute(std::string_view path) const {
-    if (IsRoot()) {
+std::shared_ptr<VfsFile> VfsDirectory::GetFileAbsolute(const std::string& path) const {
+    if (IsRoot())
         return GetFileRelative(path);
-    }
 
     return GetParentDirectory()->GetFileAbsolute(path);
 }
 
-std::shared_ptr<VfsDirectory> VfsDirectory::GetDirectoryRelative(std::string_view path) const {
+std::shared_ptr<VfsDirectory> VfsDirectory::GetDirectoryRelative(const std::string& path) const {
     auto vec = FileUtil::SplitPathComponents(path);
     vec.erase(std::remove_if(vec.begin(), vec.end(), [](const auto& str) { return str.empty(); }),
               vec.end());
-    if (vec.empty()) {
+    if (vec.empty())
         // TODO(DarkLordZach): Return this directory if path is '/' or similar. Can't currently
         // because of const-ness
         return nullptr;
-    }
-
     auto dir = GetSubdirectory(vec[0]);
     for (size_t component = 1; component < vec.size(); ++component) {
-        if (dir == nullptr) {
+        if (dir == nullptr)
             return nullptr;
-        }
-
         dir = dir->GetSubdirectory(vec[component]);
     }
-
     return dir;
 }
 
-std::shared_ptr<VfsDirectory> VfsDirectory::GetDirectoryAbsolute(std::string_view path) const {
-    if (IsRoot()) {
+std::shared_ptr<VfsDirectory> VfsDirectory::GetDirectoryAbsolute(const std::string& path) const {
+    if (IsRoot())
         return GetDirectoryRelative(path);
-    }
 
     return GetParentDirectory()->GetDirectoryAbsolute(path);
 }
 
-std::shared_ptr<VfsFile> VfsDirectory::GetFile(std::string_view name) const {
+std::shared_ptr<VfsFile> VfsDirectory::GetFile(const std::string& name) const {
     const auto& files = GetFiles();
     const auto iter = std::find_if(files.begin(), files.end(),
                                    [&name](const auto& file1) { return name == file1->GetName(); });
     return iter == files.end() ? nullptr : *iter;
 }
 
-std::shared_ptr<VfsDirectory> VfsDirectory::GetSubdirectory(std::string_view name) const {
+std::shared_ptr<VfsDirectory> VfsDirectory::GetSubdirectory(const std::string& name) const {
     const auto& subs = GetSubdirectories();
     const auto iter = std::find_if(subs.begin(), subs.end(),
                                    [&name](const auto& file1) { return name == file1->GetName(); });
@@ -144,96 +128,77 @@ size_t VfsDirectory::GetSize() const {
     return file_total + subdir_total;
 }
 
-std::shared_ptr<VfsFile> VfsDirectory::CreateFileRelative(std::string_view path) {
+std::shared_ptr<VfsFile> VfsDirectory::CreateFileRelative(const std::string& path) {
     auto vec = FileUtil::SplitPathComponents(path);
     vec.erase(std::remove_if(vec.begin(), vec.end(), [](const auto& str) { return str.empty(); }),
               vec.end());
-    if (vec.empty()) {
+    if (vec.empty())
         return nullptr;
-    }
-
-    if (vec.size() == 1) {
+    if (vec.size() == 1)
         return CreateFile(vec[0]);
-    }
-
     auto dir = GetSubdirectory(vec[0]);
     if (dir == nullptr) {
         dir = CreateSubdirectory(vec[0]);
-        if (dir == nullptr) {
+        if (dir == nullptr)
             return nullptr;
-        }
     }
 
     return dir->CreateFileRelative(FileUtil::GetPathWithoutTop(path));
 }
 
-std::shared_ptr<VfsFile> VfsDirectory::CreateFileAbsolute(std::string_view path) {
-    if (IsRoot()) {
+std::shared_ptr<VfsFile> VfsDirectory::CreateFileAbsolute(const std::string& path) {
+    if (IsRoot())
         return CreateFileRelative(path);
-    }
-
     return GetParentDirectory()->CreateFileAbsolute(path);
 }
 
-std::shared_ptr<VfsDirectory> VfsDirectory::CreateDirectoryRelative(std::string_view path) {
+std::shared_ptr<VfsDirectory> VfsDirectory::CreateDirectoryRelative(const std::string& path) {
     auto vec = FileUtil::SplitPathComponents(path);
     vec.erase(std::remove_if(vec.begin(), vec.end(), [](const auto& str) { return str.empty(); }),
               vec.end());
-    if (vec.empty()) {
+    if (vec.empty())
         return nullptr;
-    }
-
-    if (vec.size() == 1) {
+    if (vec.size() == 1)
         return CreateSubdirectory(vec[0]);
-    }
-
     auto dir = GetSubdirectory(vec[0]);
     if (dir == nullptr) {
         dir = CreateSubdirectory(vec[0]);
-        if (dir == nullptr) {
+        if (dir == nullptr)
             return nullptr;
-        }
     }
-
     return dir->CreateDirectoryRelative(FileUtil::GetPathWithoutTop(path));
 }
 
-std::shared_ptr<VfsDirectory> VfsDirectory::CreateDirectoryAbsolute(std::string_view path) {
-    if (IsRoot()) {
+std::shared_ptr<VfsDirectory> VfsDirectory::CreateDirectoryAbsolute(const std::string& path) {
+    if (IsRoot())
         return CreateDirectoryRelative(path);
-    }
-
     return GetParentDirectory()->CreateDirectoryAbsolute(path);
 }
 
-bool VfsDirectory::DeleteSubdirectoryRecursive(std::string_view name) {
+bool VfsDirectory::DeleteSubdirectoryRecursive(const std::string& name) {
     auto dir = GetSubdirectory(name);
-    if (dir == nullptr) {
+    if (dir == nullptr)
         return false;
-    }
 
     bool success = true;
     for (const auto& file : dir->GetFiles()) {
-        if (!DeleteFile(file->GetName())) {
+        if (!DeleteFile(file->GetName()))
             success = false;
-        }
     }
 
     for (const auto& sdir : dir->GetSubdirectories()) {
-        if (!dir->DeleteSubdirectoryRecursive(sdir->GetName())) {
+        if (!dir->DeleteSubdirectoryRecursive(sdir->GetName()))
             success = false;
-        }
     }
 
     return success;
 }
 
-bool VfsDirectory::Copy(std::string_view src, std::string_view dest) {
+bool VfsDirectory::Copy(const std::string& src, const std::string& dest) {
     const auto f1 = GetFile(src);
     auto f2 = CreateFile(dest);
-    if (f1 == nullptr || f2 == nullptr) {
+    if (f1 == nullptr || f2 == nullptr)
         return false;
-    }
 
     if (!f2->Resize(f1->GetSize())) {
         DeleteFile(dest);
@@ -251,23 +216,23 @@ bool ReadOnlyVfsDirectory::IsReadable() const {
     return true;
 }
 
-std::shared_ptr<VfsDirectory> ReadOnlyVfsDirectory::CreateSubdirectory(std::string_view name) {
+std::shared_ptr<VfsDirectory> ReadOnlyVfsDirectory::CreateSubdirectory(const std::string& name) {
     return nullptr;
 }
 
-std::shared_ptr<VfsFile> ReadOnlyVfsDirectory::CreateFile(std::string_view name) {
+std::shared_ptr<VfsFile> ReadOnlyVfsDirectory::CreateFile(const std::string& name) {
     return nullptr;
 }
 
-bool ReadOnlyVfsDirectory::DeleteSubdirectory(std::string_view name) {
+bool ReadOnlyVfsDirectory::DeleteSubdirectory(const std::string& name) {
     return false;
 }
 
-bool ReadOnlyVfsDirectory::DeleteFile(std::string_view name) {
+bool ReadOnlyVfsDirectory::DeleteFile(const std::string& name) {
     return false;
 }
 
-bool ReadOnlyVfsDirectory::Rename(std::string_view name) {
+bool ReadOnlyVfsDirectory::Rename(const std::string& name) {
     return false;
 }
 } // namespace FileSys

src/core/file_sys/vfs.h

@@ -6,11 +6,11 @@
 
 #include <memory>
 #include <string>
-#include <string_view>
 #include <type_traits>
 #include <vector>
 #include "boost/optional.hpp"
 #include "common/common_types.h"
+#include "common/file_util.h"
 
 namespace FileSys {
 struct VfsFile;
@@ -112,7 +112,7 @@ struct VfsFile : NonCopyable {
     }
 
     // Renames the file to name. Returns whether or not the operation was successsful.
-    virtual bool Rename(std::string_view name) = 0;
+    virtual bool Rename(const std::string& name) = 0;
 };
 
 // A class representing a directory in an abstract filesystem.
@@ -121,27 +121,27 @@ struct VfsDirectory : NonCopyable {
 
     // Retrives the file located at path as if the current directory was root. Returns nullptr if
     // not found.
-    virtual std::shared_ptr<VfsFile> GetFileRelative(std::string_view path) const;
+    virtual std::shared_ptr<VfsFile> GetFileRelative(const std::string& path) const;
     // Calls GetFileRelative(path) on the root of the current directory.
-    virtual std::shared_ptr<VfsFile> GetFileAbsolute(std::string_view path) const;
+    virtual std::shared_ptr<VfsFile> GetFileAbsolute(const std::string& path) const;
 
     // Retrives the directory located at path as if the current directory was root. Returns nullptr
     // if not found.
-    virtual std::shared_ptr<VfsDirectory> GetDirectoryRelative(std::string_view path) const;
+    virtual std::shared_ptr<VfsDirectory> GetDirectoryRelative(const std::string& path) const;
     // Calls GetDirectoryRelative(path) on the root of the current directory.
-    virtual std::shared_ptr<VfsDirectory> GetDirectoryAbsolute(std::string_view path) const;
+    virtual std::shared_ptr<VfsDirectory> GetDirectoryAbsolute(const std::string& path) const;
 
     // Returns a vector containing all of the files in this directory.
     virtual std::vector<std::shared_ptr<VfsFile>> GetFiles() const = 0;
     // Returns the file with filename matching name. Returns nullptr if directory dosen't have a
     // file with name.
-    virtual std::shared_ptr<VfsFile> GetFile(std::string_view name) const;
+    virtual std::shared_ptr<VfsFile> GetFile(const std::string& name) const;
 
     // Returns a vector containing all of the subdirectories in this directory.
     virtual std::vector<std::shared_ptr<VfsDirectory>> GetSubdirectories() const = 0;
     // Returns the directory with name matching name. Returns nullptr if directory dosen't have a
     // directory with name.
-    virtual std::shared_ptr<VfsDirectory> GetSubdirectory(std::string_view name) const;
+    virtual std::shared_ptr<VfsDirectory> GetSubdirectory(const std::string& name) const;
 
     // Returns whether or not the directory can be written to.
     virtual bool IsWritable() const = 0;
@@ -161,56 +161,53 @@ struct VfsDirectory : NonCopyable {
 
     // Creates a new subdirectory with name name. Returns a pointer to the new directory or nullptr
     // if the operation failed.
-    virtual std::shared_ptr<VfsDirectory> CreateSubdirectory(std::string_view name) = 0;
+    virtual std::shared_ptr<VfsDirectory> CreateSubdirectory(const std::string& name) = 0;
     // Creates a new file with name name. Returns a pointer to the new file or nullptr if the
     // operation failed.
-    virtual std::shared_ptr<VfsFile> CreateFile(std::string_view name) = 0;
+    virtual std::shared_ptr<VfsFile> CreateFile(const std::string& name) = 0;
 
     // Creates a new file at the path relative to this directory. Also creates directories if
     // they do not exist and is supported by this implementation. Returns nullptr on any failure.
-    virtual std::shared_ptr<VfsFile> CreateFileRelative(std::string_view path);
+    virtual std::shared_ptr<VfsFile> CreateFileRelative(const std::string& path);
 
     // Creates a new file at the path relative to root of this directory. Also creates directories
     // if they do not exist and is supported by this implementation. Returns nullptr on any failure.
-    virtual std::shared_ptr<VfsFile> CreateFileAbsolute(std::string_view path);
+    virtual std::shared_ptr<VfsFile> CreateFileAbsolute(const std::string& path);
 
     // Creates a new directory at the path relative to this directory. Also creates directories if
     // they do not exist and is supported by this implementation. Returns nullptr on any failure.
-    virtual std::shared_ptr<VfsDirectory> CreateDirectoryRelative(std::string_view path);
+    virtual std::shared_ptr<VfsDirectory> CreateDirectoryRelative(const std::string& path);
 
     // Creates a new directory at the path relative to root of this directory. Also creates
     // directories if they do not exist and is supported by this implementation. Returns nullptr on
     // any failure.
-    virtual std::shared_ptr<VfsDirectory> CreateDirectoryAbsolute(std::string_view path);
+    virtual std::shared_ptr<VfsDirectory> CreateDirectoryAbsolute(const std::string& path);
 
     // Deletes the subdirectory with name and returns true on success.
-    virtual bool DeleteSubdirectory(std::string_view name) = 0;
+    virtual bool DeleteSubdirectory(const std::string& name) = 0;
     // Deletes all subdirectories and files of subdirectory with name recirsively and then deletes
     // the subdirectory. Returns true on success.
-    virtual bool DeleteSubdirectoryRecursive(std::string_view name);
+    virtual bool DeleteSubdirectoryRecursive(const std::string& name);
     // Returnes whether or not the file with name name was deleted successfully.
-    virtual bool DeleteFile(std::string_view name) = 0;
+    virtual bool DeleteFile(const std::string& name) = 0;
 
     // Returns whether or not this directory was renamed to name.
-    virtual bool Rename(std::string_view name) = 0;
+    virtual bool Rename(const std::string& name) = 0;
 
     // Returns whether or not the file with name src was successfully copied to a new file with name
     // dest.
-    virtual bool Copy(std::string_view src, std::string_view dest);
+    virtual bool Copy(const std::string& src, const std::string& dest);
 
     // Interprets the file with name file instead as a directory of type directory.
     // The directory must have a constructor that takes a single argument of type
     // std::shared_ptr<VfsFile>. Allows to reinterpret container files (i.e NCA, zip, XCI, etc) as a
     // subdirectory in one call.
     template <typename Directory>
-    bool InterpretAsDirectory(std::string_view file) {
+    bool InterpretAsDirectory(const std::string& file) {
         auto file_p = GetFile(file);
-
-        if (file_p == nullptr) {
+        if (file_p == nullptr)
             return false;
-        }
-
-        return ReplaceFileWithSubdirectory(file_p, std::make_shared<Directory>(file_p));
+        return ReplaceFileWithSubdirectory(file, std::make_shared<Directory>(file_p));
     }
 
 protected:
@@ -224,10 +221,10 @@ protected:
 struct ReadOnlyVfsDirectory : public VfsDirectory {
     bool IsWritable() const override;
     bool IsReadable() const override;
-    std::shared_ptr<VfsDirectory> CreateSubdirectory(std::string_view name) override;
-    std::shared_ptr<VfsFile> CreateFile(std::string_view name) override;
-    bool DeleteSubdirectory(std::string_view name) override;
-    bool DeleteFile(std::string_view name) override;
-    bool Rename(std::string_view name) override;
+    std::shared_ptr<VfsDirectory> CreateSubdirectory(const std::string& name) override;
+    std::shared_ptr<VfsFile> CreateFile(const std::string& name) override;
+    bool DeleteSubdirectory(const std::string& name) override;
+    bool DeleteFile(const std::string& name) override;
+    bool Rename(const std::string& name) override;
 };
 } // namespace FileSys

src/core/file_sys/vfs_offset.cpp

@@ -80,7 +80,7 @@ size_t OffsetVfsFile::WriteBytes(const std::vector<u8>& data, size_t r_offset) {
     return file->Write(data.data(), TrimToFit(data.size(), r_offset), offset + r_offset);
 }
 
-bool OffsetVfsFile::Rename(std::string_view name) {
+bool OffsetVfsFile::Rename(const std::string& name) {
     return file->Rename(name);
 }
 

src/core/file_sys/vfs_offset.h

@@ -4,9 +4,6 @@
 
 #pragma once
 
-#include <memory>
-#include <string_view>
-
 #include "core/file_sys/vfs.h"
 
 namespace FileSys {
@@ -33,7 +30,7 @@ struct OffsetVfsFile : public VfsFile {
     bool WriteByte(u8 data, size_t offset) override;
     size_t WriteBytes(const std::vector<u8>& data, size_t offset) override;
 
-    bool Rename(std::string_view name) override;
+    bool Rename(const std::string& name) override;
 
     size_t GetOffset() const;
 

src/core/file_sys/vfs_real.cpp

@@ -13,31 +13,24 @@
 
 namespace FileSys {
 
-static std::string ModeFlagsToString(Mode mode) {
-    std::string mode_str;
-
-    // Calculate the correct open mode for the file.
-    if (mode & Mode::Read && mode & Mode::Write) {
-        if (mode & Mode::Append)
-            mode_str = "a+";
-        else
-            mode_str = "r+";
-    } else {
-        if (mode & Mode::Read)
-            mode_str = "r";
-        else if (mode & Mode::Append)
-            mode_str = "a";
-        else if (mode & Mode::Write)
-            mode_str = "w";
+static std::string PermissionsToCharArray(Mode perms) {
+    std::string out;
+    switch (perms) {
+    case Mode::Read:
+        out += "r";
+        break;
+    case Mode::Write:
+        out += "r+";
+        break;
+    case Mode::Append:
+        out += "a";
+        break;
     }
-
-    mode_str += "b";
-
-    return mode_str;
+    return out + "b";
 }
 
 RealVfsFile::RealVfsFile(const std::string& path_, Mode perms_)
-    : backing(path_, ModeFlagsToString(perms_).c_str()), path(path_),
+    : backing(path_, PermissionsToCharArray(perms_).c_str()), path(path_),
       parent_path(FileUtil::GetParentPath(path_)),
       path_components(FileUtil::SplitPathComponents(path_)),
       parent_components(FileUtil::SliceVector(path_components, 0, path_components.size() - 1)),
@@ -60,11 +53,11 @@ std::shared_ptr<VfsDirectory> RealVfsFile::GetContainingDirectory() const {
 }
 
 bool RealVfsFile::IsWritable() const {
-    return (perms & Mode::WriteAppend) != 0;
+    return perms == Mode::Append || perms == Mode::Write;
 }
 
 bool RealVfsFile::IsReadable() const {
-    return (perms & Mode::ReadWrite) != 0;
+    return perms == Mode::Read || perms == Mode::Write;
 }
 
 size_t RealVfsFile::Read(u8* data, size_t length, size_t offset) const {
@@ -79,15 +72,12 @@ size_t RealVfsFile::Write(const u8* data, size_t length, size_t offset) {
     return backing.WriteBytes(data, length);
 }
 
-bool RealVfsFile::Rename(std::string_view name) {
-    std::string name_str(name.begin(), name.end());
-    const auto out = FileUtil::Rename(GetName(), name_str);
-
-    path = (parent_path + DIR_SEP).append(name);
+bool RealVfsFile::Rename(const std::string& name) {
+    const auto out = FileUtil::Rename(GetName(), name);
+    path = parent_path + DIR_SEP + name;
     path_components = parent_components;
-    path_components.push_back(std::move(name_str));
-    backing = FileUtil::IOFile(path, ModeFlagsToString(perms).c_str());
-
+    path_components.push_back(name);
+    backing = FileUtil::IOFile(path, PermissionsToCharArray(perms).c_str());
     return out;
 }
 
@@ -100,7 +90,7 @@ RealVfsDirectory::RealVfsDirectory(const std::string& path_, Mode perms_)
       path_components(FileUtil::SplitPathComponents(path)),
       parent_components(FileUtil::SliceVector(path_components, 0, path_components.size() - 1)),
       perms(perms_) {
-    if (!FileUtil::Exists(path) && perms & Mode::WriteAppend)
+    if (!FileUtil::Exists(path) && (perms == Mode::Write || perms == Mode::Append))
         FileUtil::CreateDir(path);
 
     if (perms == Mode::Append)
@@ -127,11 +117,11 @@ std::vector<std::shared_ptr<VfsDirectory>> RealVfsDirectory::GetSubdirectories()
 }
 
 bool RealVfsDirectory::IsWritable() const {
-    return (perms & Mode::WriteAppend) != 0;
+    return perms == Mode::Write || perms == Mode::Append;
 }
 
 bool RealVfsDirectory::IsReadable() const {
-    return (perms & Mode::ReadWrite) != 0;
+    return perms == Mode::Read || perms == Mode::Write;
 }
 
 std::string RealVfsDirectory::GetName() const {
@@ -145,54 +135,36 @@ std::shared_ptr<VfsDirectory> RealVfsDirectory::GetParentDirectory() const {
     return std::make_shared<RealVfsDirectory>(parent_path, perms);
 }
 
-std::shared_ptr<VfsDirectory> RealVfsDirectory::CreateSubdirectory(std::string_view name) {
-    const std::string subdir_path = (path + DIR_SEP).append(name);
-
-    if (!FileUtil::CreateDir(subdir_path)) {
+std::shared_ptr<VfsDirectory> RealVfsDirectory::CreateSubdirectory(const std::string& name) {
+    if (!FileUtil::CreateDir(path + DIR_SEP + name))
         return nullptr;
-    }
-
-    subdirectories.emplace_back(std::make_shared<RealVfsDirectory>(subdir_path, perms));
+    subdirectories.emplace_back(std::make_shared<RealVfsDirectory>(path + DIR_SEP + name, perms));
     return subdirectories.back();
 }
 
-std::shared_ptr<VfsFile> RealVfsDirectory::CreateFile(std::string_view name) {
-    const std::string file_path = (path + DIR_SEP).append(name);
-
-    if (!FileUtil::CreateEmptyFile(file_path)) {
+std::shared_ptr<VfsFile> RealVfsDirectory::CreateFile(const std::string& name) {
+    if (!FileUtil::CreateEmptyFile(path + DIR_SEP + name))
         return nullptr;
-    }
-
-    files.emplace_back(std::make_shared<RealVfsFile>(file_path, perms));
+    files.emplace_back(std::make_shared<RealVfsFile>(path + DIR_SEP + name, perms));
     return files.back();
 }
 
-bool RealVfsDirectory::DeleteSubdirectory(std::string_view name) {
-    const std::string subdir_path = (path + DIR_SEP).append(name);
-
-    return FileUtil::DeleteDirRecursively(subdir_path);
+bool RealVfsDirectory::DeleteSubdirectory(const std::string& name) {
+    return FileUtil::DeleteDirRecursively(path + DIR_SEP + name);
 }
 
-bool RealVfsDirectory::DeleteFile(std::string_view name) {
-    const auto file = GetFile(name);
-
-    if (file == nullptr) {
+bool RealVfsDirectory::DeleteFile(const std::string& name) {
+    auto file = GetFile(name);
+    if (file == nullptr)
         return false;
-    }
-
     files.erase(std::find(files.begin(), files.end(), file));
-
     auto real_file = std::static_pointer_cast<RealVfsFile>(file);
     real_file->Close();
-
-    const std::string file_path = (path + DIR_SEP).append(name);
-    return FileUtil::Delete(file_path);
+    return FileUtil::Delete(path + DIR_SEP + name);
 }
 
-bool RealVfsDirectory::Rename(std::string_view name) {
-    const std::string new_name = (parent_path + DIR_SEP).append(name);
-
-    return FileUtil::Rename(path, new_name);
+bool RealVfsDirectory::Rename(const std::string& name) {
+    return FileUtil::Rename(path, parent_path + DIR_SEP + name);
 }
 
 bool RealVfsDirectory::ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) {

src/core/file_sys/vfs_real.h

@@ -4,8 +4,6 @@
 
 #pragma once
 
-#include <string_view>
-
 #include "common/file_util.h"
 #include "core/file_sys/mode.h"
 #include "core/file_sys/vfs.h"
@@ -26,7 +24,7 @@ struct RealVfsFile : public VfsFile {
     bool IsReadable() const override;
     size_t Read(u8* data, size_t length, size_t offset) const override;
     size_t Write(const u8* data, size_t length, size_t offset) override;
-    bool Rename(std::string_view name) override;
+    bool Rename(const std::string& name) override;
 
 private:
     bool Close();
@@ -49,11 +47,11 @@ struct RealVfsDirectory : public VfsDirectory {
     bool IsReadable() const override;
     std::string GetName() const override;
     std::shared_ptr<VfsDirectory> GetParentDirectory() const override;
-    std::shared_ptr<VfsDirectory> CreateSubdirectory(std::string_view name) override;
-    std::shared_ptr<VfsFile> CreateFile(std::string_view name) override;
-    bool DeleteSubdirectory(std::string_view name) override;
-    bool DeleteFile(std::string_view name) override;
-    bool Rename(std::string_view name) override;
+    std::shared_ptr<VfsDirectory> CreateSubdirectory(const std::string& name) override;
+    std::shared_ptr<VfsFile> CreateFile(const std::string& name) override;
+    bool DeleteSubdirectory(const std::string& name) override;
+    bool DeleteFile(const std::string& name) override;
+    bool Rename(const std::string& name) override;
 
 protected:
     bool ReplaceFileWithSubdirectory(VirtualFile file, VirtualDir dir) override;

src/core/hle/config_mem.cpp

@@ -0,0 +1,31 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <cstring>
+#include "core/hle/config_mem.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace ConfigMem {
+
+ConfigMemDef config_mem;
+
+void Init() {
+    std::memset(&config_mem, 0, sizeof(config_mem));
+
+    // Values extracted from firmware 11.2.0-35E
+    config_mem.kernel_version_min = 0x34;
+    config_mem.kernel_version_maj = 0x2;
+    config_mem.ns_tid = 0x0004013000008002;
+    config_mem.sys_core_ver = 0x2;
+    config_mem.unit_info = 0x1; // Bit 0 set for Retail
+    config_mem.prev_firm = 0x1;
+    config_mem.ctr_sdk_ver = 0x0000F297;
+    config_mem.firm_version_min = 0x34;
+    config_mem.firm_version_maj = 0x2;
+    config_mem.firm_sys_core_ver = 0x2;
+    config_mem.firm_ctr_sdk_ver = 0x0000F297;
+}
+
+} // namespace ConfigMem

src/core/hle/config_mem.h

@@ -0,0 +1,56 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+// Configuration memory stores various hardware/kernel configuration settings. This memory page is
+// read-only for ARM11 processes. I'm guessing this would normally be written to by the firmware/
+// bootrom. Because we're not emulating this, and essentially just "stubbing" the functionality, I'm
+// putting this as a subset of HLE for now.
+
+#include "common/common_funcs.h"
+#include "common/common_types.h"
+#include "common/swap.h"
+#include "core/memory.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace ConfigMem {
+
+struct ConfigMemDef {
+    u8 kernel_unk;                       // 0
+    u8 kernel_version_rev;               // 1
+    u8 kernel_version_min;               // 2
+    u8 kernel_version_maj;               // 3
+    u32_le update_flag;                  // 4
+    u64_le ns_tid;                       // 8
+    u32_le sys_core_ver;                 // 10
+    u8 unit_info;                        // 14
+    u8 boot_firm;                        // 15
+    u8 prev_firm;                        // 16
+    INSERT_PADDING_BYTES(0x1);           // 17
+    u32_le ctr_sdk_ver;                  // 18
+    INSERT_PADDING_BYTES(0x30 - 0x1C);   // 1C
+    u32_le app_mem_type;                 // 30
+    INSERT_PADDING_BYTES(0x40 - 0x34);   // 34
+    u32_le app_mem_alloc;                // 40
+    u32_le sys_mem_alloc;                // 44
+    u32_le base_mem_alloc;               // 48
+    INSERT_PADDING_BYTES(0x60 - 0x4C);   // 4C
+    u8 firm_unk;                         // 60
+    u8 firm_version_rev;                 // 61
+    u8 firm_version_min;                 // 62
+    u8 firm_version_maj;                 // 63
+    u32_le firm_sys_core_ver;            // 64
+    u32_le firm_ctr_sdk_ver;             // 68
+    INSERT_PADDING_BYTES(0x1000 - 0x6C); // 6C
+};
+static_assert(sizeof(ConfigMemDef) == Memory::CONFIG_MEMORY_SIZE,
+              "Config Memory structure size is wrong");
+
+extern ConfigMemDef config_mem;
+
+void Init();
+
+} // namespace ConfigMem

src/core/hle/ipc_helpers.h

@@ -25,9 +25,9 @@ protected:
     ptrdiff_t index = 0;
 
 public:
-    explicit RequestHelperBase(u32* command_buffer) : cmdbuf(command_buffer) {}
+    RequestHelperBase(u32* command_buffer) : cmdbuf(command_buffer) {}
 
-    explicit RequestHelperBase(Kernel::HLERequestContext& context)
+    RequestHelperBase(Kernel::HLERequestContext& context)
         : context(&context), cmdbuf(context.CommandBuffer()) {}
 
     void Skip(unsigned size_in_words, bool set_to_null) {
@@ -56,6 +56,13 @@ public:
 
 class ResponseBuilder : public RequestHelperBase {
 public:
+    ResponseBuilder(u32* command_buffer) : RequestHelperBase(command_buffer) {}
+
+    u32 normal_params_size{};
+    u32 num_handles_to_copy{};
+    u32 num_objects_to_move{}; ///< Domain objects or move handles, context dependent
+    std::ptrdiff_t datapayload_index{};
+
     /// Flags used for customizing the behavior of ResponseBuilder
     enum class Flags : u32 {
         None = 0,
@@ -64,11 +71,9 @@ public:
         AlwaysMoveHandles = 1,
     };
 
-    explicit ResponseBuilder(u32* command_buffer) : RequestHelperBase(command_buffer) {}
-
-    explicit ResponseBuilder(Kernel::HLERequestContext& context, u32 normal_params_size,
-                             u32 num_handles_to_copy = 0, u32 num_objects_to_move = 0,
-                             Flags flags = Flags::None)
+    ResponseBuilder(Kernel::HLERequestContext& context, u32 normal_params_size,
+                    u32 num_handles_to_copy = 0, u32 num_objects_to_move = 0,
+                    Flags flags = Flags::None)
 
         : RequestHelperBase(context), normal_params_size(normal_params_size),
           num_handles_to_copy(num_handles_to_copy), num_objects_to_move(num_objects_to_move) {
@@ -201,12 +206,6 @@ public:
 
     template <typename... O>
     void PushCopyObjects(Kernel::SharedPtr<O>... pointers);
-
-private:
-    u32 normal_params_size{};
-    u32 num_handles_to_copy{};
-    u32 num_objects_to_move{}; ///< Domain objects or move handles, context dependent
-    std::ptrdiff_t datapayload_index{};
 };
 
 /// Push ///
@@ -274,9 +273,9 @@ inline void ResponseBuilder::PushMoveObjects(Kernel::SharedPtr<O>... pointers) {
 
 class RequestParser : public RequestHelperBase {
 public:
-    explicit RequestParser(u32* command_buffer) : RequestHelperBase(command_buffer) {}
+    RequestParser(u32* command_buffer) : RequestHelperBase(command_buffer) {}
 
-    explicit RequestParser(Kernel::HLERequestContext& context) : RequestHelperBase(context) {
+    RequestParser(Kernel::HLERequestContext& context) : RequestHelperBase(context) {
         ASSERT_MSG(context.GetDataPayloadOffset(), "context is incomplete");
         Skip(context.GetDataPayloadOffset(), false);
         // Skip the u64 command id, it's already stored in the context
@@ -286,9 +285,8 @@ public:
 
     ResponseBuilder MakeBuilder(u32 normal_params_size, u32 num_handles_to_copy,
                                 u32 num_handles_to_move,
-                                ResponseBuilder::Flags flags = ResponseBuilder::Flags::None) const {
-        return ResponseBuilder{*context, normal_params_size, num_handles_to_copy,
-                               num_handles_to_move, flags};
+                                ResponseBuilder::Flags flags = ResponseBuilder::Flags::None) {
+        return {*context, normal_params_size, num_handles_to_copy, num_handles_to_move, flags};
     }
 
     template <typename T>

src/core/hle/kernel/hle_ipc.h

@@ -91,7 +91,7 @@ protected:
  */
 class HLERequestContext {
 public:
-    explicit HLERequestContext(SharedPtr<ServerSession> session);
+    HLERequestContext(SharedPtr<Kernel::ServerSession> session);
     ~HLERequestContext();
 
     /// Returns a pointer to the IPC command buffer for this request.

src/core/hle/kernel/kernel.cpp

@@ -2,6 +2,7 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include "core/hle/config_mem.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/memory.h"
@@ -10,6 +11,7 @@
 #include "core/hle/kernel/resource_limit.h"
 #include "core/hle/kernel/thread.h"
 #include "core/hle/kernel/timer.h"
+#include "core/hle/shared_page.h"
 
 namespace Kernel {
 
@@ -17,6 +19,9 @@ unsigned int Object::next_object_id;
 
 /// Initialize the kernel
 void Init(u32 system_mode) {
+    ConfigMem::Init();
+    SharedPage::Init();
+
     Kernel::MemoryInit(system_mode);
 
     Kernel::ResourceLimitsInit();

src/core/hle/kernel/memory.cpp

@@ -11,9 +11,11 @@
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
+#include "core/hle/config_mem.h"
 #include "core/hle/kernel/memory.h"
 #include "core/hle/kernel/vm_manager.h"
 #include "core/hle/result.h"
+#include "core/hle/shared_page.h"
 #include "core/memory.h"
 #include "core/memory_setup.h"
 
@@ -61,6 +63,14 @@ void MemoryInit(u32 mem_type) {
 
     // We must've allocated the entire FCRAM by the end
     ASSERT(base == Memory::FCRAM_SIZE);
+
+    using ConfigMem::config_mem;
+    config_mem.app_mem_type = mem_type;
+    // app_mem_malloc does not always match the configured size for memory_region[0]: in case the
+    // n3DS type override is in effect it reports the size the game expects, not the real one.
+    config_mem.app_mem_alloc = memory_region_sizes[mem_type][0];
+    config_mem.sys_mem_alloc = static_cast<u32_le>(memory_regions[1].size);
+    config_mem.base_mem_alloc = static_cast<u32_le>(memory_regions[2].size);
 }
 
 void MemoryShutdown() {

src/core/hle/kernel/mutex.cpp

@@ -19,7 +19,7 @@ namespace Kernel {
 /// Returns the number of threads that are waiting for a mutex, and the highest priority one among
 /// those.
 static std::pair<SharedPtr<Thread>, u32> GetHighestPriorityMutexWaitingThread(
-    const SharedPtr<Thread>& current_thread, VAddr mutex_addr) {
+    SharedPtr<Thread> current_thread, VAddr mutex_addr) {
 
     SharedPtr<Thread> highest_priority_thread;
     u32 num_waiters = 0;

src/core/hle/kernel/svc.cpp

@@ -650,27 +650,12 @@ static ResultCode SignalProcessWideKey(VAddr condition_variable_addr, s32 target
 
         ASSERT(thread->condvar_wait_address == condition_variable_addr);
 
-        size_t current_core = Core::System::GetInstance().CurrentCoreIndex();
-
-        auto& monitor = Core::System::GetInstance().Monitor();
-
-        // Atomically read the value of the mutex.
-        u32 mutex_val = 0;
-        do {
-            monitor.SetExclusive(current_core, thread->mutex_wait_address);
-
-            // If the mutex is not yet acquired, acquire it.
-            mutex_val = Memory::Read32(thread->mutex_wait_address);
-
-            if (mutex_val != 0) {
-                monitor.ClearExclusive();
-                break;
-            }
-        } while (!monitor.ExclusiveWrite32(current_core, thread->mutex_wait_address,
-                                           thread->wait_handle));
+        // If the mutex is not yet acquired, acquire it.
+        u32 mutex_val = Memory::Read32(thread->mutex_wait_address);
 
         if (mutex_val == 0) {
             // We were able to acquire the mutex, resume this thread.
+            Memory::Write32(thread->mutex_wait_address, thread->wait_handle);
             ASSERT(thread->status == ThreadStatus::WaitMutex);
             thread->ResumeFromWait();
 
@@ -683,19 +668,7 @@ static ResultCode SignalProcessWideKey(VAddr condition_variable_addr, s32 target
             thread->condvar_wait_address = 0;
             thread->wait_handle = 0;
         } else {
-            // Atomically signal that the mutex now has a waiting thread.
-            do {
-                monitor.SetExclusive(current_core, thread->mutex_wait_address);
-
-                // Ensure that the mutex value is still what we expect.
-                u32 value = Memory::Read32(thread->mutex_wait_address);
-                // TODO(Subv): When this happens, the kernel just clears the exclusive state and
-                // retries the initial read for this thread.
-                ASSERT_MSG(mutex_val == value, "Unhandled synchronization primitive case");
-            } while (!monitor.ExclusiveWrite32(current_core, thread->mutex_wait_address,
-                                               mutex_val | Mutex::MutexHasWaitersFlag));
-
-            // The mutex is already owned by some other thread, make this thread wait on it.
+            // Couldn't acquire the mutex, block the thread.
             Handle owner_handle = static_cast<Handle>(mutex_val & Mutex::MutexOwnerMask);
             auto owner = g_handle_table.Get<Thread>(owner_handle);
             ASSERT(owner);
@@ -703,6 +676,9 @@ static ResultCode SignalProcessWideKey(VAddr condition_variable_addr, s32 target
             thread->status = ThreadStatus::WaitMutex;
             thread->wakeup_callback = nullptr;
 
+            // Signal that the mutex now has a waiting thread.
+            Memory::Write32(thread->mutex_wait_address, mutex_val | Mutex::MutexHasWaitersFlag);
+
             owner->AddMutexWaiter(thread);
 
             Core::System::GetInstance().CpuCore(thread->processor_id).PrepareReschedule();

src/core/hle/kernel/wait_object.cpp

@@ -5,6 +5,7 @@
 #include <algorithm>
 #include "common/assert.h"
 #include "common/logging/log.h"
+#include "core/hle/config_mem.h"
 #include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/memory.h"
@@ -12,6 +13,7 @@
 #include "core/hle/kernel/resource_limit.h"
 #include "core/hle/kernel/thread.h"
 #include "core/hle/kernel/timer.h"
+#include "core/hle/shared_page.h"
 
 namespace Kernel {
 

src/core/hle/service/acc/acc.cpp

@@ -35,7 +35,7 @@ static constexpr u128 DEFAULT_USER_ID{1ull, 0ull};
 
 class IProfile final : public ServiceFramework<IProfile> {
 public:
-    explicit IProfile(u128 user_id) : ServiceFramework("IProfile"), user_id(user_id) {
+    IProfile(u128 user_id) : ServiceFramework("IProfile"), user_id(user_id) {
         static const FunctionInfo functions[] = {
             {0, nullptr, "Get"},
             {1, &IProfile::GetBase, "GetBase"},

src/core/hle/service/apm/interface.h

@@ -19,4 +19,7 @@ private:
     std::shared_ptr<Module> apm;
 };
 
+/// Registers all AM services with the specified service manager.
+void InstallInterfaces(SM::ServiceManager& service_manager);
+
 } // namespace Service::APM

src/core/hle/service/filesystem/filesystem.cpp

@@ -24,8 +24,7 @@ namespace Service::FileSystem {
 constexpr u64 EMULATED_SD_REPORTED_SIZE = 32000000000;
 
 static FileSys::VirtualDir GetDirectoryRelativeWrapped(FileSys::VirtualDir base,
-                                                       std::string_view dir_name_) {
-    std::string dir_name(FileUtil::SanitizePath(dir_name_));
+                                                       const std::string& dir_name) {
     if (dir_name.empty() || dir_name == "." || dir_name == "/" || dir_name == "\\")
         return base;
 
@@ -39,8 +38,7 @@ std::string VfsDirectoryServiceWrapper::GetName() const {
     return backing->GetName();
 }
 
-ResultCode VfsDirectoryServiceWrapper::CreateFile(const std::string& path_, u64 size) const {
-    std::string path(FileUtil::SanitizePath(path_));
+ResultCode VfsDirectoryServiceWrapper::CreateFile(const std::string& path, u64 size) const {
     auto dir = GetDirectoryRelativeWrapped(backing, FileUtil::GetParentPath(path));
     auto file = dir->CreateFile(FileUtil::GetFilename(path));
     if (file == nullptr) {
@@ -54,8 +52,7 @@ ResultCode VfsDirectoryServiceWrapper::CreateFile(const std::string& path_, u64
     return RESULT_SUCCESS;
 }
 
-ResultCode VfsDirectoryServiceWrapper::DeleteFile(const std::string& path_) const {
-    std::string path(FileUtil::SanitizePath(path_));
+ResultCode VfsDirectoryServiceWrapper::DeleteFile(const std::string& path) const {
     auto dir = GetDirectoryRelativeWrapped(backing, FileUtil::GetParentPath(path));
     if (path == "/" || path == "\\") {
         // TODO(DarkLordZach): Why do games call this and what should it do? Works as is but...
@@ -63,15 +60,14 @@ ResultCode VfsDirectoryServiceWrapper::DeleteFile(const std::string& path_) cons
     }
     if (dir->GetFile(FileUtil::GetFilename(path)) == nullptr)
         return FileSys::ERROR_PATH_NOT_FOUND;
-    if (!dir->DeleteFile(FileUtil::GetFilename(path))) {
+    if (!backing->DeleteFile(FileUtil::GetFilename(path))) {
         // TODO(DarkLordZach): Find a better error code for this
         return ResultCode(-1);
     }
     return RESULT_SUCCESS;
 }
 
-ResultCode VfsDirectoryServiceWrapper::CreateDirectory(const std::string& path_) const {
-    std::string path(FileUtil::SanitizePath(path_));
+ResultCode VfsDirectoryServiceWrapper::CreateDirectory(const std::string& path) const {
     auto dir = GetDirectoryRelativeWrapped(backing, FileUtil::GetParentPath(path));
     if (dir == nullptr && FileUtil::GetFilename(FileUtil::GetParentPath(path)).empty())
         dir = backing;
@@ -83,8 +79,7 @@ ResultCode VfsDirectoryServiceWrapper::CreateDirectory(const std::string& path_)
     return RESULT_SUCCESS;
 }
 
-ResultCode VfsDirectoryServiceWrapper::DeleteDirectory(const std::string& path_) const {
-    std::string path(FileUtil::SanitizePath(path_));
+ResultCode VfsDirectoryServiceWrapper::DeleteDirectory(const std::string& path) const {
     auto dir = GetDirectoryRelativeWrapped(backing, FileUtil::GetParentPath(path));
     if (!dir->DeleteSubdirectory(FileUtil::GetFilename(path))) {
         // TODO(DarkLordZach): Find a better error code for this
@@ -93,8 +88,7 @@ ResultCode VfsDirectoryServiceWrapper::DeleteDirectory(const std::string& path_)
     return RESULT_SUCCESS;
 }
 
-ResultCode VfsDirectoryServiceWrapper::DeleteDirectoryRecursively(const std::string& path_) const {
-    std::string path(FileUtil::SanitizePath(path_));
+ResultCode VfsDirectoryServiceWrapper::DeleteDirectoryRecursively(const std::string& path) const {
     auto dir = GetDirectoryRelativeWrapped(backing, FileUtil::GetParentPath(path));
     if (!dir->DeleteSubdirectoryRecursive(FileUtil::GetFilename(path))) {
         // TODO(DarkLordZach): Find a better error code for this
@@ -103,10 +97,8 @@ ResultCode VfsDirectoryServiceWrapper::DeleteDirectoryRecursively(const std::str
     return RESULT_SUCCESS;
 }
 
-ResultCode VfsDirectoryServiceWrapper::RenameFile(const std::string& src_path_,
-                                                  const std::string& dest_path_) const {
-    std::string src_path(FileUtil::SanitizePath(src_path_));
-    std::string dest_path(FileUtil::SanitizePath(dest_path_));
+ResultCode VfsDirectoryServiceWrapper::RenameFile(const std::string& src_path,
+                                                  const std::string& dest_path) const {
     auto src = backing->GetFileRelative(src_path);
     if (FileUtil::GetParentPath(src_path) == FileUtil::GetParentPath(dest_path)) {
         // Use more-optimized vfs implementation rename.
@@ -138,10 +130,8 @@ ResultCode VfsDirectoryServiceWrapper::RenameFile(const std::string& src_path_,
     return RESULT_SUCCESS;
 }
 
-ResultCode VfsDirectoryServiceWrapper::RenameDirectory(const std::string& src_path_,
-                                                       const std::string& dest_path_) const {
-    std::string src_path(FileUtil::SanitizePath(src_path_));
-    std::string dest_path(FileUtil::SanitizePath(dest_path_));
+ResultCode VfsDirectoryServiceWrapper::RenameDirectory(const std::string& src_path,
+                                                       const std::string& dest_path) const {
     auto src = GetDirectoryRelativeWrapped(backing, src_path);
     if (FileUtil::GetParentPath(src_path) == FileUtil::GetParentPath(dest_path)) {
         // Use more-optimized vfs implementation rename.
@@ -164,9 +154,8 @@ ResultCode VfsDirectoryServiceWrapper::RenameDirectory(const std::string& src_pa
     return ResultCode(-1);
 }
 
-ResultVal<FileSys::VirtualFile> VfsDirectoryServiceWrapper::OpenFile(const std::string& path_,
+ResultVal<FileSys::VirtualFile> VfsDirectoryServiceWrapper::OpenFile(const std::string& path,
                                                                      FileSys::Mode mode) const {
-    std::string path(FileUtil::SanitizePath(path_));
     auto npath = path;
     while (npath.size() > 0 && (npath[0] == '/' || npath[0] == '\\'))
         npath = npath.substr(1);
@@ -182,8 +171,7 @@ ResultVal<FileSys::VirtualFile> VfsDirectoryServiceWrapper::OpenFile(const std::
     return MakeResult<FileSys::VirtualFile>(file);
 }
 
-ResultVal<FileSys::VirtualDir> VfsDirectoryServiceWrapper::OpenDirectory(const std::string& path_) {
-    std::string path(FileUtil::SanitizePath(path_));
+ResultVal<FileSys::VirtualDir> VfsDirectoryServiceWrapper::OpenDirectory(const std::string& path) {
     auto dir = GetDirectoryRelativeWrapped(backing, path);
     if (dir == nullptr) {
         // TODO(DarkLordZach): Find a better error code for this
@@ -200,8 +188,7 @@ u64 VfsDirectoryServiceWrapper::GetFreeSpaceSize() const {
 }
 
 ResultVal<FileSys::EntryType> VfsDirectoryServiceWrapper::GetEntryType(
-    const std::string& path_) const {
-    std::string path(FileUtil::SanitizePath(path_));
+    const std::string& path) const {
     auto dir = GetDirectoryRelativeWrapped(backing, FileUtil::GetParentPath(path));
     if (dir == nullptr)
         return FileSys::ERROR_PATH_NOT_FOUND;
@@ -285,9 +272,9 @@ void RegisterFileSystems() {
     sdmc_factory = nullptr;
 
     auto nand_directory = std::make_shared<FileSys::RealVfsDirectory>(
-        FileUtil::GetUserPath(FileUtil::UserPath::NANDDir), FileSys::Mode::ReadWrite);
+        FileUtil::GetUserPath(FileUtil::UserPath::NANDDir), FileSys::Mode::Write);
     auto sd_directory = std::make_shared<FileSys::RealVfsDirectory>(
-        FileUtil::GetUserPath(FileUtil::UserPath::SDMCDir), FileSys::Mode::ReadWrite);
+        FileUtil::GetUserPath(FileUtil::UserPath::SDMCDir), FileSys::Mode::Write);
 
     auto savedata = std::make_unique<FileSys::SaveDataFactory>(std::move(nand_directory));
     save_data_factory = std::move(savedata);

src/core/hle/service/service.h

@@ -146,7 +146,7 @@ protected:
      * @param max_sessions Maximum number of sessions that can be
      * connected to this service at the same time.
      */
-    explicit ServiceFramework(const char* service_name, u32 max_sessions = DefaultMaxSessions)
+    ServiceFramework(const char* service_name, u32 max_sessions = DefaultMaxSessions)
         : ServiceFrameworkBase(service_name, max_sessions, Invoker) {}
 
     /// Registers handlers in the service.

src/core/hle/service/set/set.cpp

@@ -11,40 +11,31 @@
 
 namespace Service::Set {
 
-constexpr std::array<LanguageCode, 17> available_language_codes = {{
-    LanguageCode::JA,
-    LanguageCode::EN_US,
-    LanguageCode::FR,
-    LanguageCode::DE,
-    LanguageCode::IT,
-    LanguageCode::ES,
-    LanguageCode::ZH_CN,
-    LanguageCode::KO,
-    LanguageCode::NL,
-    LanguageCode::PT,
-    LanguageCode::RU,
-    LanguageCode::ZH_TW,
-    LanguageCode::EN_GB,
-    LanguageCode::FR_CA,
-    LanguageCode::ES_419,
-    LanguageCode::ZH_HANS,
-    LanguageCode::ZH_HANT,
-}};
-
 void SET::GetAvailableLanguageCodes(Kernel::HLERequestContext& ctx) {
+    static constexpr std::array<LanguageCode, 17> available_language_codes = {{
+        LanguageCode::JA,
+        LanguageCode::EN_US,
+        LanguageCode::FR,
+        LanguageCode::DE,
+        LanguageCode::IT,
+        LanguageCode::ES,
+        LanguageCode::ZH_CN,
+        LanguageCode::KO,
+        LanguageCode::NL,
+        LanguageCode::PT,
+        LanguageCode::RU,
+        LanguageCode::ZH_TW,
+        LanguageCode::EN_GB,
+        LanguageCode::FR_CA,
+        LanguageCode::ES_419,
+        LanguageCode::ZH_HANS,
+        LanguageCode::ZH_HANT,
+    }};
     ctx.WriteBuffer(available_language_codes);
 
-    IPC::ResponseBuilder rb{ctx, 3};
+    IPC::ResponseBuilder rb{ctx, 4};
     rb.Push(RESULT_SUCCESS);
-    rb.Push(static_cast<u32>(available_language_codes.size()));
-
-    LOG_DEBUG(Service_SET, "called");
-}
-
-void SET::GetAvailableLanguageCodeCount(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(RESULT_SUCCESS);
-    rb.Push(static_cast<u32>(available_language_codes.size()));
+    rb.Push(static_cast<u64>(available_language_codes.size()));
 
     LOG_DEBUG(Service_SET, "called");
 }
@@ -54,10 +45,10 @@ SET::SET() : ServiceFramework("set") {
         {0, nullptr, "GetLanguageCode"},
         {1, &SET::GetAvailableLanguageCodes, "GetAvailableLanguageCodes"},
         {2, nullptr, "MakeLanguageCode"},
-        {3, &SET::GetAvailableLanguageCodeCount, "GetAvailableLanguageCodeCount"},
+        {3, nullptr, "GetAvailableLanguageCodeCount"},
         {4, nullptr, "GetRegionCode"},
         {5, &SET::GetAvailableLanguageCodes, "GetAvailableLanguageCodes2"},
-        {6, &SET::GetAvailableLanguageCodeCount, "GetAvailableLanguageCodeCount2"},
+        {6, nullptr, "GetAvailableLanguageCodeCount2"},
         {7, nullptr, "GetKeyCodeMap"},
         {8, nullptr, "GetQuestFlag"},
     };

src/core/hle/service/set/set.h

@@ -36,7 +36,6 @@ public:
 
 private:
     void GetAvailableLanguageCodes(Kernel::HLERequestContext& ctx);
-    void GetAvailableLanguageCodeCount(Kernel::HLERequestContext& ctx);
 };
 
 } // namespace Service::Set

src/core/hle/service/vi/vi.cpp

@@ -5,8 +5,6 @@
 #include <algorithm>
 #include <array>
 #include <memory>
-#include <type_traits>
-#include <utility>
 #include <boost/optional.hpp>
 #include "common/alignment.h"
 #include "common/math_util.h"
@@ -45,9 +43,7 @@ public:
 
     template <typename T>
     T Read() {
-        static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable.");
         ASSERT(read_index + sizeof(T) <= buffer.size());
-
         T val;
         std::memcpy(&val, buffer.data() + read_index, sizeof(T));
         read_index += sizeof(T);
@@ -57,9 +53,7 @@ public:
 
     template <typename T>
     T ReadUnaligned() {
-        static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable.");
         ASSERT(read_index + sizeof(T) <= buffer.size());
-
         T val;
         std::memcpy(&val, buffer.data() + read_index, sizeof(T));
         read_index += sizeof(T);
@@ -93,12 +87,8 @@ public:
 
     template <typename T>
     void Write(const T& val) {
-        static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable.");
-
-        if (buffer.size() < write_index + sizeof(T)) {
+        if (buffer.size() < write_index + sizeof(T))
             buffer.resize(buffer.size() + sizeof(T) + DefaultBufferSize);
-        }
-
         std::memcpy(buffer.data() + write_index, &val, sizeof(T));
         write_index += sizeof(T);
         write_index = Common::AlignUp(write_index, 4);
@@ -106,9 +96,7 @@ public:
 
     template <typename T>
     void WriteObject(const T& val) {
-        static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable.");
-
-        const u32_le size = static_cast<u32>(sizeof(val));
+        u32_le size = static_cast<u32>(sizeof(val));
         Write(size);
         // TODO(Subv): Support file descriptors.
         Write<u32_le>(0); // Fd count.
@@ -188,7 +176,7 @@ private:
 
 class IGBPConnectRequestParcel : public Parcel {
 public:
-    explicit IGBPConnectRequestParcel(std::vector<u8> buffer) : Parcel(std::move(buffer)) {
+    explicit IGBPConnectRequestParcel(const std::vector<u8>& buffer) : Parcel(buffer) {
         Deserialize();
     }
     ~IGBPConnectRequestParcel() override = default;
@@ -235,8 +223,8 @@ private:
 
 class IGBPSetPreallocatedBufferRequestParcel : public Parcel {
 public:
-    explicit IGBPSetPreallocatedBufferRequestParcel(std::vector<u8> buffer)
-        : Parcel(std::move(buffer)) {
+    explicit IGBPSetPreallocatedBufferRequestParcel(const std::vector<u8>& buffer)
+        : Parcel(buffer) {
         Deserialize();
     }
     ~IGBPSetPreallocatedBufferRequestParcel() override = default;
@@ -268,7 +256,7 @@ protected:
 
 class IGBPDequeueBufferRequestParcel : public Parcel {
 public:
-    explicit IGBPDequeueBufferRequestParcel(std::vector<u8> buffer) : Parcel(std::move(buffer)) {
+    explicit IGBPDequeueBufferRequestParcel(const std::vector<u8>& buffer) : Parcel(buffer) {
         Deserialize();
     }
     ~IGBPDequeueBufferRequestParcel() override = default;
@@ -319,7 +307,7 @@ protected:
 
 class IGBPRequestBufferRequestParcel : public Parcel {
 public:
-    explicit IGBPRequestBufferRequestParcel(std::vector<u8> buffer) : Parcel(std::move(buffer)) {
+    explicit IGBPRequestBufferRequestParcel(const std::vector<u8>& buffer) : Parcel(buffer) {
         Deserialize();
     }
     ~IGBPRequestBufferRequestParcel() override = default;
@@ -334,7 +322,8 @@ public:
 
 class IGBPRequestBufferResponseParcel : public Parcel {
 public:
-    explicit IGBPRequestBufferResponseParcel(NVFlinger::IGBPBuffer buffer) : buffer(buffer) {}
+    explicit IGBPRequestBufferResponseParcel(NVFlinger::IGBPBuffer buffer)
+        : Parcel(), buffer(buffer) {}
     ~IGBPRequestBufferResponseParcel() override = default;
 
 protected:
@@ -351,7 +340,7 @@ protected:
 
 class IGBPQueueBufferRequestParcel : public Parcel {
 public:
-    explicit IGBPQueueBufferRequestParcel(std::vector<u8> buffer) : Parcel(std::move(buffer)) {
+    explicit IGBPQueueBufferRequestParcel(const std::vector<u8>& buffer) : Parcel(buffer) {
         Deserialize();
     }
     ~IGBPQueueBufferRequestParcel() override = default;
@@ -420,7 +409,7 @@ private:
 
 class IGBPQueryRequestParcel : public Parcel {
 public:
-    explicit IGBPQueryRequestParcel(std::vector<u8> buffer) : Parcel(std::move(buffer)) {
+    explicit IGBPQueryRequestParcel(const std::vector<u8>& buffer) : Parcel(buffer) {
         Deserialize();
     }
     ~IGBPQueryRequestParcel() override = default;

src/core/hle/shared_page.cpp

@@ -0,0 +1,86 @@
+// Copyright 2015 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <chrono>
+#include <cstring>
+#include <ctime>
+#include "core/core_timing.h"
+#include "core/hle/shared_page.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace SharedPage {
+
+SharedPageDef shared_page;
+
+static CoreTiming::EventType* update_time_event;
+
+/// Gets system time in 3DS format. The epoch is Jan 1900, and the unit is millisecond.
+static u64 GetSystemTime() {
+    auto now = std::chrono::system_clock::now();
+
+    // 3DS system does't allow user to set a time before Jan 1 2000,
+    // so we use it as an auxiliary epoch to calculate the console time.
+    std::tm epoch_tm;
+    epoch_tm.tm_sec = 0;
+    epoch_tm.tm_min = 0;
+    epoch_tm.tm_hour = 0;
+    epoch_tm.tm_mday = 1;
+    epoch_tm.tm_mon = 0;
+    epoch_tm.tm_year = 100;
+    epoch_tm.tm_isdst = 0;
+    auto epoch = std::chrono::system_clock::from_time_t(std::mktime(&epoch_tm));
+
+    // 3DS console time uses Jan 1 1900 as internal epoch,
+    // so we use the milliseconds between 1900 and 2000 as base console time
+    u64 console_time = 3155673600000ULL;
+
+    // Only when system time is after 2000, we set it as 3DS system time
+    if (now > epoch) {
+        console_time += std::chrono::duration_cast<std::chrono::milliseconds>(now - epoch).count();
+    }
+
+    // If the system time is in daylight saving, we give an additional hour to console time
+    std::time_t now_time_t = std::chrono::system_clock::to_time_t(now);
+    std::tm* now_tm = std::localtime(&now_time_t);
+    if (now_tm && now_tm->tm_isdst > 0)
+        console_time += 60 * 60 * 1000;
+
+    return console_time;
+}
+
+static void UpdateTimeCallback(u64 userdata, int cycles_late) {
+    DateTime& date_time =
+        shared_page.date_time_counter % 2 ? shared_page.date_time_0 : shared_page.date_time_1;
+
+    date_time.date_time = GetSystemTime();
+    date_time.update_tick = CoreTiming::GetTicks();
+    date_time.tick_to_second_coefficient = CoreTiming::BASE_CLOCK_RATE;
+    date_time.tick_offset = 0;
+
+    ++shared_page.date_time_counter;
+
+    // system time is updated hourly
+    CoreTiming::ScheduleEvent(CoreTiming::msToCycles(60 * 60 * 1000) - cycles_late,
+                              update_time_event);
+}
+
+void Init() {
+    std::memset(&shared_page, 0, sizeof(shared_page));
+
+    shared_page.running_hw = 0x1; // product
+
+    // Some games wait until this value becomes 0x1, before asking running_hw
+    shared_page.unknown_value = 0x1;
+
+    // Set to a completely full battery
+    shared_page.battery_state.is_adapter_connected.Assign(1);
+    shared_page.battery_state.is_charging.Assign(1);
+
+    update_time_event =
+        CoreTiming::RegisterEvent("SharedPage::UpdateTimeCallback", UpdateTimeCallback);
+    CoreTiming::ScheduleEvent(0, update_time_event);
+}
+
+} // namespace SharedPage

src/core/hle/shared_page.h

@@ -0,0 +1,69 @@
+// Copyright 2015 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+/**
+ * The shared page stores various runtime configuration settings. This memory page is
+ * read-only for user processes (there is a bit in the header that grants the process
+ * write access, according to 3dbrew; this is not emulated)
+ */
+
+#include "common/bit_field.h"
+#include "common/common_funcs.h"
+#include "common/common_types.h"
+#include "common/swap.h"
+#include "core/memory.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace SharedPage {
+
+// See http://3dbrew.org/wiki/Configuration_Memory#Shared_Memory_Page_For_ARM11_Processes
+
+struct DateTime {
+    u64_le date_time;                  // 0
+    u64_le update_tick;                // 8
+    u64_le tick_to_second_coefficient; // 10
+    u64_le tick_offset;                // 18
+};
+static_assert(sizeof(DateTime) == 0x20, "Datetime size is wrong");
+
+union BatteryState {
+    u8 raw;
+    BitField<0, 1, u8> is_adapter_connected;
+    BitField<1, 1, u8> is_charging;
+    BitField<2, 3, u8> charge_level;
+};
+
+struct SharedPageDef {
+    // Most of these names are taken from the 3dbrew page linked above.
+    u32_le date_time_counter; // 0
+    u8 running_hw;            // 4
+    /// "Microcontroller hardware info"
+    u8 mcu_hw_info;                      // 5
+    INSERT_PADDING_BYTES(0x20 - 0x6);    // 6
+    DateTime date_time_0;                // 20
+    DateTime date_time_1;                // 40
+    u8 wifi_macaddr[6];                  // 60
+    u8 wifi_link_level;                  // 66
+    u8 wifi_unknown2;                    // 67
+    INSERT_PADDING_BYTES(0x80 - 0x68);   // 68
+    float_le sliderstate_3d;             // 80
+    u8 ledstate_3d;                      // 84
+    BatteryState battery_state;          // 85
+    u8 unknown_value;                    // 86
+    INSERT_PADDING_BYTES(0xA0 - 0x87);   // 87
+    u64_le menu_title_id;                // A0
+    u64_le active_menu_title_id;         // A8
+    INSERT_PADDING_BYTES(0x1000 - 0xB0); // B0
+};
+static_assert(sizeof(SharedPageDef) == Memory::SHARED_PAGE_SIZE,
+              "Shared page structure size is wrong");
+
+extern SharedPageDef shared_page;
+
+void Init();
+
+} // namespace SharedPage

src/core/loader/elf.cpp

@@ -190,7 +190,7 @@ private:
     u32 entryPoint;
 
 public:
-    explicit ElfReader(void* ptr);
+    ElfReader(void* ptr);
 
     u32 Read32(int off) const {
         return base32[off >> 2];

src/core/loader/linker.cpp

@@ -49,7 +49,8 @@ struct Elf64_Sym {
 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, VAddr load_base) {
+                              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));
@@ -123,11 +124,12 @@ void Linker::Relocate(std::vector<u8>& program_image, u32 dynamic_section_offset
     }
 
     if (dynamic.find(DT_RELA) != dynamic.end()) {
-        WriteRelocations(program_image, symbols, dynamic[DT_RELA], dynamic[DT_RELASZ], load_base);
+        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],
+        WriteRelocations(program_image, symbols, dynamic[DT_JMPREL], dynamic[DT_PLTRELSZ], true,
                          load_base);
     }
 }

src/core/loader/linker.h

@@ -24,7 +24,8 @@ protected:
     };
 
     void WriteRelocations(std::vector<u8>& program_image, const std::vector<Symbol>& symbols,
-                          u64 relocation_offset, u64 size, VAddr load_base);
+                          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();

src/core/loader/loader.cpp

@@ -42,15 +42,14 @@ FileType IdentifyFile(FileSys::VirtualFile file) {
 }
 
 FileType IdentifyFile(const std::string& file_name) {
-    return IdentifyFile(std::make_shared<FileSys::RealVfsFile>(file_name));
+    return IdentifyFile(FileSys::VirtualFile(std::make_shared<FileSys::RealVfsFile>(file_name)));
 }
 
 FileType GuessFromFilename(const std::string& name) {
     if (name == "main")
         return FileType::DeconstructedRomDirectory;
 
-    const std::string extension =
-        Common::ToLower(std::string(FileUtil::GetExtensionFromFilename(name)));
+    const std::string extension = Common::ToLower(FileUtil::GetExtensionFromFilename(name));
 
     if (extension == "elf")
         return FileType::ELF;

src/core/loader/loader.h

@@ -79,7 +79,7 @@ enum class ResultStatus {
 /// Interface for loading an application
 class AppLoader : NonCopyable {
 public:
-    explicit AppLoader(FileSys::VirtualFile file) : file(std::move(file)) {}
+    AppLoader(FileSys::VirtualFile file) : file(std::move(file)) {}
     virtual ~AppLoader() {}
 
     /**

src/core/loader/nro.cpp

@@ -6,13 +6,10 @@
 #include <vector>
 
 #include "common/common_funcs.h"
-#include "common/common_types.h"
 #include "common/file_util.h"
 #include "common/logging/log.h"
 #include "common/swap.h"
 #include "core/core.h"
-#include "core/file_sys/control_metadata.h"
-#include "core/file_sys/vfs_offset.h"
 #include "core/gdbstub/gdbstub.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/resource_limit.h"
@@ -52,62 +49,7 @@ struct ModHeader {
 };
 static_assert(sizeof(ModHeader) == 0x1c, "ModHeader has incorrect size.");
 
-struct AssetSection {
-    u64_le offset;
-    u64_le size;
-};
-static_assert(sizeof(AssetSection) == 0x10, "AssetSection has incorrect size.");
-
-struct AssetHeader {
-    u32_le magic;
-    u32_le format_version;
-    AssetSection icon;
-    AssetSection nacp;
-    AssetSection romfs;
-};
-static_assert(sizeof(AssetHeader) == 0x38, "AssetHeader has incorrect size.");
-
-AppLoader_NRO::AppLoader_NRO(FileSys::VirtualFile file) : AppLoader(file) {
-    NroHeader nro_header{};
-    if (file->ReadObject(&nro_header) != sizeof(NroHeader)) {
-        return;
-    }
-
-    if (file->GetSize() >= nro_header.file_size + sizeof(AssetHeader)) {
-        const u64 offset = nro_header.file_size;
-        AssetHeader asset_header{};
-        if (file->ReadObject(&asset_header, offset) != sizeof(AssetHeader)) {
-            return;
-        }
-
-        if (asset_header.format_version != 0) {
-            LOG_WARNING(Loader,
-                        "NRO Asset Header has format {}, currently supported format is 0. If "
-                        "strange glitches occur with metadata, check NRO assets.",
-                        asset_header.format_version);
-        }
-
-        if (asset_header.magic != Common::MakeMagic('A', 'S', 'E', 'T')) {
-            return;
-        }
-
-        if (asset_header.nacp.size > 0) {
-            nacp = std::make_unique<FileSys::NACP>(std::make_shared<FileSys::OffsetVfsFile>(
-                file, asset_header.nacp.size, offset + asset_header.nacp.offset, "Control.nacp"));
-        }
-
-        if (asset_header.romfs.size > 0) {
-            romfs = std::make_shared<FileSys::OffsetVfsFile>(
-                file, asset_header.romfs.size, offset + asset_header.romfs.offset, "game.romfs");
-        }
-
-        if (asset_header.icon.size > 0) {
-            icon_data = file->ReadBytes(asset_header.icon.size, offset + asset_header.icon.offset);
-        }
-    }
-}
-
-AppLoader_NRO::~AppLoader_NRO() = default;
+AppLoader_NRO::AppLoader_NRO(FileSys::VirtualFile file) : AppLoader(std::move(file)) {}
 
 FileType AppLoader_NRO::IdentifyType(const FileSys::VirtualFile& file) {
     // Read NSO header
@@ -138,9 +80,8 @@ bool AppLoader_NRO::LoadNro(FileSys::VirtualFile file, VAddr load_base) {
     // Build program image
     Kernel::SharedPtr<Kernel::CodeSet> codeset = Kernel::CodeSet::Create("");
     std::vector<u8> program_image = file->ReadBytes(PageAlignSize(nro_header.file_size));
-    if (program_image.size() != PageAlignSize(nro_header.file_size)) {
+    if (program_image.size() != PageAlignSize(nro_header.file_size))
         return {};
-    }
 
     for (std::size_t i = 0; i < nro_header.segments.size(); ++i) {
         codeset->segments[i].addr = nro_header.segments[i].offset;
@@ -195,39 +136,4 @@ ResultStatus AppLoader_NRO::Load(Kernel::SharedPtr<Kernel::Process>& process) {
     return ResultStatus::Success;
 }
 
-ResultStatus AppLoader_NRO::ReadIcon(std::vector<u8>& buffer) {
-    if (icon_data.empty()) {
-        return ResultStatus::ErrorNotUsed;
-    }
-
-    buffer = icon_data;
-    return ResultStatus::Success;
-}
-
-ResultStatus AppLoader_NRO::ReadProgramId(u64& out_program_id) {
-    if (nacp == nullptr) {
-        return ResultStatus::ErrorNotUsed;
-    }
-
-    out_program_id = nacp->GetTitleId();
-    return ResultStatus::Success;
-}
-
-ResultStatus AppLoader_NRO::ReadRomFS(FileSys::VirtualFile& dir) {
-    if (romfs == nullptr) {
-        return ResultStatus::ErrorNotUsed;
-    }
-
-    dir = romfs;
-    return ResultStatus::Success;
-}
-
-ResultStatus AppLoader_NRO::ReadTitle(std::string& title) {
-    if (nacp == nullptr) {
-        return ResultStatus::ErrorNotUsed;
-    }
-
-    title = nacp->GetApplicationName();
-    return ResultStatus::Success;
-}
 } // namespace Loader

src/core/loader/nro.h

@@ -10,17 +10,12 @@
 #include "core/loader/linker.h"
 #include "core/loader/loader.h"
 
-namespace FileSys {
-class NACP;
-}
-
 namespace Loader {
 
 /// Loads an NRO file
 class AppLoader_NRO final : public AppLoader, Linker {
 public:
-    explicit AppLoader_NRO(FileSys::VirtualFile file);
-    ~AppLoader_NRO() override;
+    AppLoader_NRO(FileSys::VirtualFile file);
 
     /**
      * Returns the type of the file
@@ -35,17 +30,8 @@ public:
 
     ResultStatus Load(Kernel::SharedPtr<Kernel::Process>& process) override;
 
-    ResultStatus ReadIcon(std::vector<u8>& buffer) override;
-    ResultStatus ReadProgramId(u64& out_program_id) override;
-    ResultStatus ReadRomFS(FileSys::VirtualFile& dir) override;
-    ResultStatus ReadTitle(std::string& title) override;
-
 private:
     bool LoadNro(FileSys::VirtualFile file, VAddr load_base);
-
-    std::vector<u8> icon_data;
-    std::unique_ptr<FileSys::NACP> nacp;
-    FileSys::VirtualFile romfs;
 };
 
 } // namespace Loader

src/core/tracer/recorder.h

@@ -32,7 +32,7 @@ public:
      * Recorder constructor
      * @param initial_state Initial recorder state
      */
-    explicit Recorder(const InitialState& initial_state);
+    Recorder(const InitialState& initial_state);
 
     /// Finish recording of this Citrace and save it using the given filename.
     void Finish(const std::string& filename);

src/video_core/engines/shader_bytecode.h

@@ -67,7 +67,7 @@ private:
 };
 
 union Attribute {
-    Attribute() = default;
+    constexpr Attribute() = default;
 
     constexpr explicit Attribute(u64 value) : value(value) {}
 
@@ -96,7 +96,7 @@ union Attribute {
 };
 
 union Sampler {
-    Sampler() = default;
+    constexpr Sampler() = default;
 
     constexpr explicit Sampler(u64 value) : value(value) {}
 
@@ -425,7 +425,6 @@ union Instruction {
 
     union {
         BitField<50, 3, u64> component_mask_selector;
-        BitField<0, 8, Register> gpr0;
         BitField<28, 8, Register> gpr28;
 
         bool HasTwoDestinations() const {
@@ -433,16 +432,13 @@ union Instruction {
         }
 
         bool IsComponentEnabled(size_t component) const {
-            static constexpr std::array<std::array<u32, 8>, 4> mask_lut{
-                {{},
-                 {0x1, 0x2, 0x4, 0x8, 0x3},
-                 {0x1, 0x2, 0x4, 0x8, 0x3, 0x9, 0xa, 0xc},
-                 {0x7, 0xb, 0xd, 0xe, 0xf}}};
+            static constexpr std::array<size_t, 5> one_dest_mask{0x1, 0x2, 0x4, 0x8, 0x3};
+            static constexpr std::array<size_t, 5> two_dest_mask{0x7, 0xb, 0xd, 0xe, 0xf};
+            const auto& mask{HasTwoDestinations() ? two_dest_mask : one_dest_mask};
 
-            size_t index{gpr0.Value() != Register::ZeroIndex ? 1U : 0U};
-            index |= gpr28.Value() != Register::ZeroIndex ? 2 : 0;
+            ASSERT(component_mask_selector < mask.size());
 
-            return ((1ull << component) & mask_lut[index][component_mask_selector]) != 0;
+            return ((1ull << component) & mask[component_mask_selector]) != 0;
         }
     } texs;
 

src/video_core/gpu.cpp

@@ -35,11 +35,9 @@ u32 RenderTargetBytesPerPixel(RenderTargetFormat format) {
     case RenderTargetFormat::RGBA32_FLOAT:
         return 16;
     case RenderTargetFormat::RGBA16_FLOAT:
-    case RenderTargetFormat::RG32_FLOAT:
         return 8;
     case RenderTargetFormat::RGBA8_UNORM:
     case RenderTargetFormat::RGB10_A2_UNORM:
-    case RenderTargetFormat::BGRA8_UNORM:
         return 4;
     default:
         UNIMPLEMENTED_MSG("Unimplemented render target format {}", static_cast<u32>(format));

src/video_core/gpu.h

@@ -18,8 +18,6 @@ enum class RenderTargetFormat : u32 {
     RGBA32_FLOAT = 0xC0,
     RGBA32_UINT = 0xC2,
     RGBA16_FLOAT = 0xCA,
-    RG32_FLOAT = 0xCB,
-    BGRA8_UNORM = 0xCF,
     RGB10_A2_UNORM = 0xD1,
     RGBA8_UNORM = 0xD5,
     RGBA8_SRGB = 0xD6,

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -5,7 +5,6 @@
 #include <algorithm>
 #include <memory>
 #include <string>
-#include <string_view>
 #include <tuple>
 #include <utility>
 #include <glad/glad.h>
@@ -38,6 +37,11 @@ MICROPROFILE_DEFINE(OpenGL_Blits, "OpenGL", "Blits", MP_RGB(100, 100, 255));
 MICROPROFILE_DEFINE(OpenGL_CacheManagement, "OpenGL", "Cache Mgmt", MP_RGB(100, 255, 100));
 
 RasterizerOpenGL::RasterizerOpenGL() {
+    has_ARB_buffer_storage = false;
+    has_ARB_direct_state_access = false;
+    has_ARB_separate_shader_objects = false;
+    has_ARB_vertex_attrib_binding = false;
+
     // Create sampler objects
     for (size_t i = 0; i < texture_samplers.size(); ++i) {
         texture_samplers[i].Create();
@@ -55,8 +59,7 @@ RasterizerOpenGL::RasterizerOpenGL() {
     GLint ext_num;
     glGetIntegerv(GL_NUM_EXTENSIONS, &ext_num);
     for (GLint i = 0; i < ext_num; i++) {
-        const std::string_view extension{
-            reinterpret_cast<const char*>(glGetStringi(GL_EXTENSIONS, i))};
+        std::string extension{reinterpret_cast<const char*>(glGetStringi(GL_EXTENSIONS, i))};
 
         if (extension == "GL_ARB_buffer_storage") {
             has_ARB_buffer_storage = true;
@@ -107,6 +110,8 @@ RasterizerOpenGL::RasterizerOpenGL() {
         glBindBufferBase(GL_UNIFORM_BUFFER, index, buffer.handle);
     }
 
+    accelerate_draw = AccelDraw::Disabled;
+
     glEnable(GL_BLEND);
 
     LOG_CRITICAL(Render_OpenGL, "Sync fixed function OpenGL state here!");
@@ -596,6 +601,7 @@ void RasterizerOpenGL::SamplerInfo::Create() {
     sampler.Create();
     mag_filter = min_filter = Tegra::Texture::TextureFilter::Linear;
     wrap_u = wrap_v = Tegra::Texture::WrapMode::Wrap;
+    border_color_r = border_color_g = border_color_b = border_color_a = 0;
 
     // default is GL_LINEAR_MIPMAP_LINEAR
     glSamplerParameteri(sampler.handle, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
@@ -624,12 +630,8 @@ void RasterizerOpenGL::SamplerInfo::SyncWithConfig(const Tegra::Texture::TSCEntr
     }
 
     if (wrap_u == Tegra::Texture::WrapMode::Border || wrap_v == Tegra::Texture::WrapMode::Border) {
-        const GLvec4 new_border_color = {{config.border_color_r, config.border_color_g,
-                                          config.border_color_b, config.border_color_a}};
-        if (border_color != new_border_color) {
-            border_color = new_border_color;
-            glSamplerParameterfv(s, GL_TEXTURE_BORDER_COLOR, border_color.data());
-        }
+        // TODO(Subv): Implement border color
+        ASSERT(false);
     }
 }
 
@@ -689,12 +691,10 @@ u32 RasterizerOpenGL::SetupConstBuffers(Maxwell::ShaderStage stage, GLuint progr
         glBindBuffer(GL_UNIFORM_BUFFER, 0);
 
         // Now configure the bindpoint of the buffer inside the shader
-        const std::string buffer_name = used_buffer.GetName();
-        const GLuint index =
-            glGetProgramResourceIndex(program, GL_UNIFORM_BLOCK, buffer_name.c_str());
-        if (index != GL_INVALID_INDEX) {
+        std::string buffer_name = used_buffer.GetName();
+        GLuint index = glGetProgramResourceIndex(program, GL_UNIFORM_BLOCK, buffer_name.c_str());
+        if (index != -1)
             glUniformBlockBinding(program, index, buffer_draw_state.bindpoint);
-        }
     }
 
     state.Apply();

src/video_core/renderer_opengl/gl_rasterizer.h

@@ -77,7 +77,10 @@ private:
         Tegra::Texture::TextureFilter min_filter;
         Tegra::Texture::WrapMode wrap_u;
         Tegra::Texture::WrapMode wrap_v;
-        GLvec4 border_color;
+        u32 border_color_r;
+        u32 border_color_g;
+        u32 border_color_b;
+        u32 border_color_a;
     };
 
     /// Configures the color and depth framebuffer states and returns the dirty <Color, Depth>
@@ -135,10 +138,10 @@ private:
     /// Syncs the blend state to match the guest state
     void SyncBlendState();
 
-    bool has_ARB_buffer_storage = false;
-    bool has_ARB_direct_state_access = false;
-    bool has_ARB_separate_shader_objects = false;
-    bool has_ARB_vertex_attrib_binding = false;
+    bool has_ARB_buffer_storage;
+    bool has_ARB_direct_state_access;
+    bool has_ARB_separate_shader_objects;
+    bool has_ARB_vertex_attrib_binding;
 
     OpenGLState state;
 
@@ -167,5 +170,5 @@ private:
     void SetupShaders(u8* buffer_ptr, GLintptr buffer_offset);
 
     enum class AccelDraw { Disabled, Arrays, Indexed };
-    AccelDraw accelerate_draw = AccelDraw::Disabled;
+    AccelDraw accelerate_draw;
 };

src/video_core/renderer_opengl/gl_rasterizer_cache.cpp

@@ -38,8 +38,7 @@ struct FormatTuple {
     params.addr = config.tic.Address();
     params.is_tiled = config.tic.IsTiled();
     params.block_height = params.is_tiled ? config.tic.BlockHeight() : 0,
-    params.pixel_format =
-        PixelFormatFromTextureFormat(config.tic.format, config.tic.r_type.Value());
+    params.pixel_format = PixelFormatFromTextureFormat(config.tic.format);
     params.component_type = ComponentTypeFromTexture(config.tic.r_type.Value());
     params.type = GetFormatType(params.pixel_format);
     params.width = Common::AlignUp(config.tic.Width(), GetCompressionFactor(params.pixel_format));
@@ -107,10 +106,6 @@ static constexpr std::array<FormatTuple, SurfaceParams::MaxPixelFormat> tex_form
      true},                                                             // BC7U
     {GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // ASTC_2D_4X4
     {GL_RG8, GL_RG, GL_UNSIGNED_BYTE, ComponentType::UNorm, false},     // G8R8
-    {GL_RGBA8, GL_BGRA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // BGRA8
-    {GL_RGBA32F, GL_RGBA, GL_FLOAT, ComponentType::Float, false},       // RGBA32F
-    {GL_RG32F, GL_RG, GL_FLOAT, ComponentType::Float, false},           // RG32F
-    {GL_R32F, GL_RED, GL_FLOAT, ComponentType::Float, false},           // R32F
 
     // DepthStencil formats
     {GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, ComponentType::UNorm,
@@ -202,9 +197,7 @@ static constexpr std::array<void (*)(u32, u32, u32, u8*, Tegra::GPUVAddr),
         MortonCopy<true, PixelFormat::DXT1>,         MortonCopy<true, PixelFormat::DXT23>,
         MortonCopy<true, PixelFormat::DXT45>,        MortonCopy<true, PixelFormat::DXN1>,
         MortonCopy<true, PixelFormat::BC7U>,         MortonCopy<true, PixelFormat::ASTC_2D_4X4>,
-        MortonCopy<true, PixelFormat::G8R8>,         MortonCopy<true, PixelFormat::BGRA8>,
-        MortonCopy<true, PixelFormat::RGBA32F>,      MortonCopy<true, PixelFormat::RG32F>,
-        MortonCopy<true, PixelFormat::R32F>,         MortonCopy<true, PixelFormat::Z24S8>,
+        MortonCopy<true, PixelFormat::G8R8>,         MortonCopy<true, PixelFormat::Z24S8>,
         MortonCopy<true, PixelFormat::S8Z24>,        MortonCopy<true, PixelFormat::Z32F>,
         MortonCopy<true, PixelFormat::Z16>,
 };
@@ -220,7 +213,7 @@ static constexpr std::array<void (*)(u32, u32, u32, u8*, Tegra::GPUVAddr),
         MortonCopy<false, PixelFormat::RGBA16F>,
         MortonCopy<false, PixelFormat::R11FG11FB10F>,
         MortonCopy<false, PixelFormat::RGBA32UI>,
-        // TODO(Subv): Swizzling DXT1/DXT23/DXT45/DXN1/BC7U/ASTC_2D_4X4 formats is not supported
+        // TODO(Subv): Swizzling the DXT1/DXT23/DXT45/DXN1/BC7U formats is not yet supported
         nullptr,
         nullptr,
         nullptr,
@@ -228,10 +221,6 @@ static constexpr std::array<void (*)(u32, u32, u32, u8*, Tegra::GPUVAddr),
         nullptr,
         nullptr,
         MortonCopy<false, PixelFormat::G8R8>,
-        MortonCopy<false, PixelFormat::BGRA8>,
-        MortonCopy<false, PixelFormat::RGBA32F>,
-        MortonCopy<false, PixelFormat::RG32F>,
-        MortonCopy<false, PixelFormat::R32F>,
         MortonCopy<false, PixelFormat::Z24S8>,
         MortonCopy<false, PixelFormat::S8Z24>,
         MortonCopy<false, PixelFormat::Z32F>,

src/video_core/renderer_opengl/gl_rasterizer_cache.h

@@ -37,18 +37,14 @@ struct SurfaceParams {
         BC7U = 12,
         ASTC_2D_4X4 = 13,
         G8R8 = 14,
-        BGRA8 = 15,
-        RGBA32F = 16,
-        RG32F = 17,
-        R32F = 18,
 
         MaxColorFormat,
 
         // DepthStencil formats
-        Z24S8 = 19,
-        S8Z24 = 20,
-        Z32F = 21,
-        Z16 = 22,
+        Z24S8 = 15,
+        S8Z24 = 16,
+        Z32F = 17,
+        Z16 = 18,
 
         MaxDepthStencilFormat,
 
@@ -101,10 +97,6 @@ struct SurfaceParams {
             4, // BC7U
             4, // ASTC_2D_4X4
             1, // G8R8
-            1, // BGRA8
-            1, // RGBA32F
-            1, // RG32F
-            1, // R32F
             1, // Z24S8
             1, // S8Z24
             1, // Z32F
@@ -135,10 +127,6 @@ struct SurfaceParams {
             128, // BC7U
             32,  // ASTC_2D_4X4
             16,  // G8R8
-            32,  // BGRA8
-            128, // RGBA32F
-            64,  // RG32F
-            32,  // R32F
             32,  // Z24S8
             32,  // S8Z24
             32,  // Z32F
@@ -174,16 +162,10 @@ struct SurfaceParams {
         case Tegra::RenderTargetFormat::RGBA8_UNORM:
         case Tegra::RenderTargetFormat::RGBA8_SRGB:
             return PixelFormat::ABGR8;
-        case Tegra::RenderTargetFormat::BGRA8_UNORM:
-            return PixelFormat::BGRA8;
         case Tegra::RenderTargetFormat::RGB10_A2_UNORM:
             return PixelFormat::A2B10G10R10;
         case Tegra::RenderTargetFormat::RGBA16_FLOAT:
             return PixelFormat::RGBA16F;
-        case Tegra::RenderTargetFormat::RGBA32_FLOAT:
-            return PixelFormat::RGBA32F;
-        case Tegra::RenderTargetFormat::RG32_FLOAT:
-            return PixelFormat::RG32F;
         case Tegra::RenderTargetFormat::R11G11B10_FLOAT:
             return PixelFormat::R11FG11FB10F;
         case Tegra::RenderTargetFormat::RGBA32_UINT:
@@ -194,8 +176,7 @@ struct SurfaceParams {
         }
     }
 
-    static PixelFormat PixelFormatFromTextureFormat(Tegra::Texture::TextureFormat format,
-                                                    Tegra::Texture::ComponentType component_type) {
+    static PixelFormat PixelFormatFromTextureFormat(Tegra::Texture::TextureFormat format) {
         // TODO(Subv): Properly implement this
         switch (format) {
         case Tegra::Texture::TextureFormat::A8R8G8B8:
@@ -215,19 +196,7 @@ struct SurfaceParams {
         case Tegra::Texture::TextureFormat::BF10GF11RF11:
             return PixelFormat::R11FG11FB10F;
         case Tegra::Texture::TextureFormat::R32_G32_B32_A32:
-            switch (component_type) {
-            case Tegra::Texture::ComponentType::FLOAT:
-                return PixelFormat::RGBA32F;
-            case Tegra::Texture::ComponentType::UINT:
-                return PixelFormat::RGBA32UI;
-            }
-            LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}",
-                         static_cast<u32>(component_type));
-            UNREACHABLE();
-        case Tegra::Texture::TextureFormat::R32_G32:
-            return PixelFormat::RG32F;
-        case Tegra::Texture::TextureFormat::R32:
-            return PixelFormat::R32F;
+            return PixelFormat::RGBA32UI;
         case Tegra::Texture::TextureFormat::DXT1:
             return PixelFormat::DXT1;
         case Tegra::Texture::TextureFormat::DXT23:
@@ -241,8 +210,7 @@ struct SurfaceParams {
         case Tegra::Texture::TextureFormat::ASTC_2D_4X4:
             return PixelFormat::ASTC_2D_4X4;
         default:
-            LOG_CRITICAL(HW_GPU, "Unimplemented format={}, component_type={}",
-                         static_cast<u32>(format), static_cast<u32>(component_type));
+            LOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format));
             UNREACHABLE();
         }
     }
@@ -280,18 +248,7 @@ struct SurfaceParams {
             return Tegra::Texture::TextureFormat::BC7U;
         case PixelFormat::ASTC_2D_4X4:
             return Tegra::Texture::TextureFormat::ASTC_2D_4X4;
-        case PixelFormat::BGRA8:
-            // TODO(bunnei): This is fine for unswizzling (since we just need the right component
-            // sizes), but could be a bug if we used this function in different ways.
-            return Tegra::Texture::TextureFormat::A8R8G8B8;
-        case PixelFormat::RGBA32F:
-            return Tegra::Texture::TextureFormat::R32_G32_B32_A32;
-        case PixelFormat::RG32F:
-            return Tegra::Texture::TextureFormat::R32_G32;
-        case PixelFormat::R32F:
-            return Tegra::Texture::TextureFormat::R32;
         default:
-            LOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format));
             UNREACHABLE();
         }
     }
@@ -307,7 +264,6 @@ struct SurfaceParams {
         case PixelFormat::Z16:
             return Tegra::DepthFormat::Z16_UNORM;
         default:
-            LOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format));
             UNREACHABLE();
         }
     }
@@ -317,8 +273,6 @@ struct SurfaceParams {
         switch (type) {
         case Tegra::Texture::ComponentType::UNORM:
             return ComponentType::UNorm;
-        case Tegra::Texture::ComponentType::FLOAT:
-            return ComponentType::Float;
         default:
             LOG_CRITICAL(HW_GPU, "Unimplemented component type={}", static_cast<u32>(type));
             UNREACHABLE();
@@ -330,13 +284,10 @@ struct SurfaceParams {
         switch (format) {
         case Tegra::RenderTargetFormat::RGBA8_UNORM:
         case Tegra::RenderTargetFormat::RGBA8_SRGB:
-        case Tegra::RenderTargetFormat::BGRA8_UNORM:
         case Tegra::RenderTargetFormat::RGB10_A2_UNORM:
             return ComponentType::UNorm;
         case Tegra::RenderTargetFormat::RGBA16_FLOAT:
         case Tegra::RenderTargetFormat::R11G11B10_FLOAT:
-        case Tegra::RenderTargetFormat::RGBA32_FLOAT:
-        case Tegra::RenderTargetFormat::RG32_FLOAT:
             return ComponentType::Float;
         case Tegra::RenderTargetFormat::RGBA32_UINT:
             return ComponentType::UInt;

src/video_core/renderer_opengl/gl_shader_decompiler.cpp

@@ -6,9 +6,6 @@
 #include <set>
 #include <string>
 #include <string_view>
-
-#include <fmt/format.h>
-
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "video_core/engines/shader_bytecode.h"
@@ -81,18 +78,14 @@ private:
 
     /// Adds and analyzes a new subroutine if it is not added yet.
     const Subroutine& AddSubroutine(u32 begin, u32 end, const std::string& suffix) {
-        Subroutine subroutine{begin, end, suffix, ExitMethod::Undetermined, {}};
-
-        const auto iter = subroutines.find(subroutine);
-        if (iter != subroutines.end()) {
+        auto iter = subroutines.find(Subroutine{begin, end, suffix});
+        if (iter != subroutines.end())
             return *iter;
-        }
 
+        Subroutine subroutine{begin, end, suffix};
         subroutine.exit_method = Scan(begin, end, subroutine.labels);
-        if (subroutine.exit_method == ExitMethod::Undetermined) {
+        if (subroutine.exit_method == ExitMethod::Undetermined)
             throw DecompileFail("Recursive function detected");
-        }
-
         return *subroutines.insert(std::move(subroutine)).first;
     }
 
@@ -488,12 +481,6 @@ private:
      */
     void SetRegister(const Register& reg, u64 elem, const std::string& value,
                      u64 dest_num_components, u64 value_num_components, u64 dest_elem) {
-        if (reg == Register::ZeroIndex) {
-            LOG_CRITICAL(HW_GPU, "Cannot set Register::ZeroIndex");
-            UNREACHABLE();
-            return;
-        }
-
         std::string dest = GetRegister(reg, static_cast<u32>(dest_elem));
         if (dest_num_components > 1) {
             dest += GetSwizzle(elem);
@@ -756,38 +743,6 @@ private:
         }
     }
 
-    void WriteTexsInstruction(const Instruction& instr, const std::string& coord,
-                              const std::string& texture) {
-        // Add an extra scope and declare the texture coords inside to prevent
-        // overwriting them in case they are used as outputs of the texs instruction.
-        shader.AddLine('{');
-        ++shader.scope;
-        shader.AddLine(coord);
-
-        // TEXS has two destination registers. RG goes into gpr0+0 and gpr0+1, and BA
-        // goes into gpr28+0 and gpr28+1
-        size_t texs_offset{};
-
-        for (const auto& dest : {instr.gpr0.Value(), instr.gpr28.Value()}) {
-            for (unsigned elem = 0; elem < 2; ++elem) {
-                if (!instr.texs.IsComponentEnabled(elem)) {
-                    // Skip disabled components
-                    continue;
-                }
-                regs.SetRegisterToFloat(dest, elem + texs_offset, texture, 1, 4, false, elem);
-            }
-
-            if (!instr.texs.HasTwoDestinations()) {
-                // Skip the second destination
-                break;
-            }
-
-            texs_offset += 2;
-        }
-        --shader.scope;
-        shader.AddLine('}');
-    }
-
     /**
      * Compiles a single instruction from Tegra to GLSL.
      * @param offset the offset of the Tegra shader instruction.
@@ -810,8 +765,7 @@ private:
             return offset + 1;
         }
 
-        shader.AddLine("// " + std::to_string(offset) + ": " + opcode->GetName() + " (" +
-                       std::to_string(instr.value) + ')');
+        shader.AddLine("// " + std::to_string(offset) + ": " + opcode->GetName());
 
         using Tegra::Shader::Pred;
         ASSERT_MSG(instr.pred.full_pred != Pred::NeverExecute,
@@ -1387,18 +1341,36 @@ private:
                 const std::string op_b = regs.GetRegisterAsFloat(instr.gpr20);
                 const std::string sampler = GetSampler(instr.sampler);
                 const std::string coord = "vec2 coords = vec2(" + op_a + ", " + op_b + ");";
-
+                // Add an extra scope and declare the texture coords inside to prevent
+                // overwriting them in case they are used as outputs of the texs instruction.
+                shader.AddLine("{");
+                ++shader.scope;
+                shader.AddLine(coord);
                 const std::string texture = "texture(" + sampler + ", coords)";
-                WriteTexsInstruction(instr, coord, texture);
-                break;
-            }
-            case OpCode::Id::TLDS: {
-                const std::string op_a = regs.GetRegisterAsInteger(instr.gpr8);
-                const std::string op_b = regs.GetRegisterAsInteger(instr.gpr20);
-                const std::string sampler = GetSampler(instr.sampler);
-                const std::string coord = "ivec2 coords = ivec2(" + op_a + ", " + op_b + ");";
-                const std::string texture = "texelFetch(" + sampler + ", coords, 0)";
-                WriteTexsInstruction(instr, coord, texture);
+
+                // TEXS has two destination registers. RG goes into gpr0+0 and gpr0+1, and BA
+                // goes into gpr28+0 and gpr28+1
+                size_t texs_offset{};
+
+                for (const auto& dest : {instr.gpr0.Value(), instr.gpr28.Value()}) {
+                    for (unsigned elem = 0; elem < 2; ++elem) {
+                        if (!instr.texs.IsComponentEnabled(elem)) {
+                            // Skip disabled components
+                            continue;
+                        }
+                        regs.SetRegisterToFloat(dest, elem + texs_offset, texture, 1, 4, false,
+                                                elem);
+                    }
+
+                    if (!instr.texs.HasTwoDestinations()) {
+                        // Skip the second destination
+                        break;
+                    }
+
+                    texs_offset += 2;
+                }
+                --shader.scope;
+                shader.AddLine("}");
                 break;
             }
             default: {
@@ -1798,8 +1770,11 @@ private:
 }; // namespace Decompiler
 
 std::string GetCommonDeclarations() {
-    return fmt::format("#define MAX_CONSTBUFFER_ELEMENTS {}\n",
-                       RasterizerOpenGL::MaxConstbufferSize / sizeof(GLvec4));
+    std::string declarations;
+    declarations += "#define MAX_CONSTBUFFER_ELEMENTS " +
+                    std::to_string(RasterizerOpenGL::MaxConstbufferSize / (sizeof(GLvec4)));
+    declarations += '\n';
+    return declarations;
 }
 
 boost::optional<ProgramResult> DecompileProgram(const ProgramCode& program_code, u32 main_offset,

src/video_core/renderer_opengl/maxwell_to_gl.h

@@ -56,9 +56,6 @@ inline GLenum VertexType(Maxwell::VertexAttribute attrib) {
         return {};
     }
 
-    case Maxwell::VertexAttribute::Type::UnsignedInt:
-        return GL_UNSIGNED_INT;
-
     case Maxwell::VertexAttribute::Type::Float:
         return GL_FLOAT;
     }
@@ -115,8 +112,6 @@ inline GLenum WrapMode(Tegra::Texture::WrapMode wrap_mode) {
         return GL_MIRRORED_REPEAT;
     case Tegra::Texture::WrapMode::ClampToEdge:
         return GL_CLAMP_TO_EDGE;
-    case Tegra::Texture::WrapMode::Border:
-        return GL_CLAMP_TO_BORDER;
     case Tegra::Texture::WrapMode::ClampOGL:
         // TODO(Subv): GL_CLAMP was removed as of OpenGL 3.1, to implement GL_CLAMP, we can use
         // GL_CLAMP_TO_BORDER to get the border color of the texture, and then sample the edge to

src/video_core/textures/decoders.cpp

@@ -61,7 +61,6 @@ u32 BytesPerPixel(TextureFormat format) {
     case TextureFormat::A8R8G8B8:
     case TextureFormat::A2B10G10R10:
     case TextureFormat::BF10GF11RF11:
-    case TextureFormat::R32:
         return 4;
     case TextureFormat::A1B5G5R5:
     case TextureFormat::B5G6R5:
@@ -73,8 +72,6 @@ u32 BytesPerPixel(TextureFormat format) {
         return 8;
     case TextureFormat::R32_G32_B32_A32:
         return 16;
-    case TextureFormat::R32_G32:
-        return 8;
     default:
         UNIMPLEMENTED_MSG("Format not implemented");
         break;
@@ -121,8 +118,6 @@ std::vector<u8> UnswizzleTexture(VAddr address, TextureFormat format, u32 width,
     case TextureFormat::G8R8:
     case TextureFormat::R16_G16_B16_A16:
     case TextureFormat::R32_G32_B32_A32:
-    case TextureFormat::R32_G32:
-    case TextureFormat::R32:
     case TextureFormat::BF10GF11RF11:
     case TextureFormat::ASTC_2D_4X4:
         CopySwizzledData(width, height, bytes_per_pixel, bytes_per_pixel, data,
@@ -179,8 +174,6 @@ std::vector<u8> DecodeTexture(const std::vector<u8>& texture_data, TextureFormat
     case TextureFormat::G8R8:
     case TextureFormat::BF10GF11RF11:
     case TextureFormat::R32_G32_B32_A32:
-    case TextureFormat::R32_G32:
-    case TextureFormat::R32:
         // TODO(Subv): For the time being just forward the same data without any decoding.
         rgba_data = texture_data;
         break;

src/video_core/textures/texture.h

@@ -242,10 +242,10 @@ struct TSCEntry {
         BitField<6, 2, TextureMipmapFilter> mip_filter;
     };
     INSERT_PADDING_BYTES(8);
-    float border_color_r;
-    float border_color_g;
-    float border_color_b;
-    float border_color_a;
+    u32 border_color_r;
+    u32 border_color_g;
+    u32 border_color_b;
+    u32 border_color_a;
 };
 static_assert(sizeof(TSCEntry) == 0x20, "TSCEntry has wrong size");
 

src/yuzu/main.cpp

@@ -338,18 +338,6 @@ bool GMainWindow::SupportsRequiredGLExtensions() {
         unsupported_ext.append("ARB_separate_shader_objects");
     if (!GLAD_GL_ARB_vertex_attrib_binding)
         unsupported_ext.append("ARB_vertex_attrib_binding");
-    if (!GLAD_GL_ARB_vertex_type_10f_11f_11f_rev)
-        unsupported_ext.append("ARB_vertex_type_10f_11f_11f_rev");
-
-    // Extensions required to support some texture formats.
-    if (!GLAD_GL_EXT_texture_compression_s3tc)
-        unsupported_ext.append("EXT_texture_compression_s3tc");
-    if (!GLAD_GL_ARB_texture_compression_rgtc)
-        unsupported_ext.append("ARB_texture_compression_rgtc");
-    if (!GLAD_GL_ARB_texture_compression_bptc)
-        unsupported_ext.append("ARB_texture_compression_bptc");
-    if (!GLAD_GL_ARB_depth_buffer_float)
-        unsupported_ext.append("ARB_depth_buffer_float");
 
     for (const QString& ext : unsupported_ext)
         LOG_CRITICAL(Frontend, "Unsupported GL extension: {}", ext.toStdString());

src/yuzu_cmd/emu_window/emu_window_sdl2.cpp

@@ -85,20 +85,10 @@ bool EmuWindow_SDL2::SupportsRequiredGLExtensions() {
         unsupported_ext.push_back("ARB_program_interface_query");
     if (!GLAD_GL_ARB_separate_shader_objects)
         unsupported_ext.push_back("ARB_separate_shader_objects");
+    if (!GLAD_GL_ARB_shader_storage_buffer_object)
+        unsupported_ext.push_back("ARB_shader_storage_buffer_object");
     if (!GLAD_GL_ARB_vertex_attrib_binding)
         unsupported_ext.push_back("ARB_vertex_attrib_binding");
-    if (!GLAD_GL_ARB_vertex_type_10f_11f_11f_rev)
-        unsupported_ext.push_back("ARB_vertex_type_10f_11f_11f_rev");
-
-    // Extensions required to support some texture formats.
-    if (!GLAD_GL_EXT_texture_compression_s3tc)
-        unsupported_ext.push_back("EXT_texture_compression_s3tc");
-    if (!GLAD_GL_ARB_texture_compression_rgtc)
-        unsupported_ext.push_back("ARB_texture_compression_rgtc");
-    if (!GLAD_GL_ARB_texture_compression_bptc)
-        unsupported_ext.push_back("ARB_texture_compression_bptc");
-    if (!GLAD_GL_ARB_depth_buffer_float)
-        unsupported_ext.push_back("ARB_depth_buffer_float");
 
     for (const std::string& ext : unsupported_ext)
         LOG_CRITICAL(Frontend, "Unsupported GL extension: {}", ext);