NRO Assets and NACP file format

Cleanup

Review fixes

src/common/file_util.cpp

@@ -2,6 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <array>
+#include <memory>
 #include <sstream>
 #include <unordered_map>
 #include "common/assert.h"
@@ -275,14 +277,10 @@ bool Copy(const std::string& srcFilename, const std::string& destFilename) {
               GetLastErrorMsg());
     return false;
 #else
-
-// buffer size
-#define BSIZE 1024
-
-    char buffer[BSIZE];
+    using CFilePointer = std::unique_ptr<FILE, decltype(&std::fclose)>;
 
     // Open input file
-    FILE* input = fopen(srcFilename.c_str(), "rb");
+    CFilePointer input{fopen(srcFilename.c_str(), "rb"), std::fclose};
     if (!input) {
         LOG_ERROR(Common_Filesystem, "opening input failed {} --> {}: {}", srcFilename,
                   destFilename, GetLastErrorMsg());
@@ -290,44 +288,36 @@ bool Copy(const std::string& srcFilename, const std::string& destFilename) {
     }
 
     // open output file
-    FILE* output = fopen(destFilename.c_str(), "wb");
+    CFilePointer output{fopen(destFilename.c_str(), "wb"), std::fclose};
     if (!output) {
-        fclose(input);
         LOG_ERROR(Common_Filesystem, "opening output failed {} --> {}: {}", srcFilename,
                   destFilename, GetLastErrorMsg());
         return false;
     }
 
     // copy loop
-    while (!feof(input)) {
+    std::array<char, 1024> buffer;
+    while (!feof(input.get())) {
         // read input
-        size_t rnum = fread(buffer, sizeof(char), BSIZE, input);
-        if (rnum != BSIZE) {
-            if (ferror(input) != 0) {
+        size_t rnum = fread(buffer.data(), sizeof(char), buffer.size(), input.get());
+        if (rnum != buffer.size()) {
+            if (ferror(input.get()) != 0) {
                 LOG_ERROR(Common_Filesystem, "failed reading from source, {} --> {}: {}",
                           srcFilename, destFilename, GetLastErrorMsg());
-                goto bail;
+                return false;
             }
         }
 
         // write output
-        size_t wnum = fwrite(buffer, sizeof(char), rnum, output);
+        size_t wnum = fwrite(buffer.data(), sizeof(char), rnum, output.get());
         if (wnum != rnum) {
             LOG_ERROR(Common_Filesystem, "failed writing to output, {} --> {}: {}", srcFilename,
                       destFilename, GetLastErrorMsg());
-            goto bail;
+            return false;
         }
     }
-    // close files
-    fclose(input);
-    fclose(output);
+
     return true;
-bail:
-    if (input)
-        fclose(input);
-    if (output)
-        fclose(output);
-    return false;
 #endif
 }
 

src/core/CMakeLists.txt

@@ -1,5 +1,7 @@
 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
@@ -10,6 +12,8 @@ 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

src/core/arm/dynarmic/arm_dynarmic.cpp

@@ -102,18 +102,28 @@ public:
     u64 tpidr_el0 = 0;
 };
 
-std::unique_ptr<Dynarmic::A64::Jit> MakeJit(const std::unique_ptr<ARM_Dynarmic_Callbacks>& cb) {
+std::unique_ptr<Dynarmic::A64::Jit> ARM_Dynarmic::MakeJit() {
     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);
 }
@@ -128,8 +138,11 @@ void ARM_Dynarmic::Step() {
     cb->InterpreterFallback(jit->GetPC(), 1);
 }
 
-ARM_Dynarmic::ARM_Dynarmic()
-    : cb(std::make_unique<ARM_Dynarmic_Callbacks>(*this)), jit(MakeJit(cb)) {
+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_Interface::ThreadContext ctx;
     inner_unicorn.SaveContext(ctx);
     LoadContext(ctx);
@@ -237,6 +250,46 @@ void ARM_Dynarmic::ClearExclusiveState() {
 }
 
 void ARM_Dynarmic::PageTableChanged() {
-    jit = MakeJit(cb);
+    jit = MakeJit();
     current_page_table = Memory::GetCurrentPageTable();
 }
+
+DynarmicExclusiveMonitor::DynarmicExclusiveMonitor(size_t core_count) : monitor(core_count) {}
+DynarmicExclusiveMonitor::~DynarmicExclusiveMonitor() = default;
+
+void DynarmicExclusiveMonitor::SetExclusive(size_t core_index, u64 addr) {
+    // Size doesn't actually matter.
+    monitor.Mark(core_index, addr, 16);
+}
+
+void DynarmicExclusiveMonitor::ClearExclusive() {
+    monitor.Clear();
+}
+
+bool DynarmicExclusiveMonitor::ExclusiveWrite8(size_t core_index, u64 vaddr, u8 value) {
+    return monitor.DoExclusiveOperation(core_index, vaddr, 1,
+                                        [&] { Memory::Write8(vaddr, value); });
+}
+
+bool DynarmicExclusiveMonitor::ExclusiveWrite16(size_t core_index, u64 vaddr, u16 value) {
+    return monitor.DoExclusiveOperation(core_index, vaddr, 2,
+                                        [&] { Memory::Write16(vaddr, value); });
+}
+
+bool DynarmicExclusiveMonitor::ExclusiveWrite32(size_t core_index, u64 vaddr, u32 value) {
+    return monitor.DoExclusiveOperation(core_index, vaddr, 4,
+                                        [&] { Memory::Write32(vaddr, value); });
+}
+
+bool DynarmicExclusiveMonitor::ExclusiveWrite64(size_t core_index, u64 vaddr, u64 value) {
+    return monitor.DoExclusiveOperation(core_index, vaddr, 8,
+                                        [&] { Memory::Write64(vaddr, value); });
+}
+
+bool DynarmicExclusiveMonitor::ExclusiveWrite128(size_t core_index, u64 vaddr,
+                                                 std::array<std::uint64_t, 2> 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,15 +6,18 @@
 
 #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();
+    ARM_Dynarmic(std::shared_ptr<ExclusiveMonitor> exclusive_monitor, size_t core_index);
     ~ARM_Dynarmic();
 
     void MapBackingMemory(VAddr address, size_t size, u8* memory,
@@ -47,10 +50,35 @@ public:
     void PageTableChanged() override;
 
 private:
+    std::unique_ptr<Dynarmic::A64::Jit> MakeJit();
+
     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, u64 addr) override;
+    void ClearExclusive() override;
+
+    bool ExclusiveWrite8(size_t core_index, u64 vaddr, u8 value) override;
+    bool ExclusiveWrite16(size_t core_index, u64 vaddr, u16 value) override;
+    bool ExclusiveWrite32(size_t core_index, u64 vaddr, u32 value) override;
+    bool ExclusiveWrite64(size_t core_index, u64 vaddr, u64 value) override;
+    bool ExclusiveWrite128(size_t core_index, u64 vaddr,
+                           std::array<std::uint64_t, 2> value) override;
+
+private:
+    friend class ARM_Dynarmic;
+    Dynarmic::A64::ExclusiveMonitor monitor;
+};

src/core/arm/exclusive_monitor.cpp

@@ -0,0 +1,7 @@
+// 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

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

src/core/core.cpp

@@ -171,8 +171,9 @@ 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_barrier, index);
+        cpu_cores[index] = std::make_shared<Cpu>(cpu_exclusive_monitor, cpu_barrier, index);
     }
 
     gpu_core = std::make_unique<Tegra::GPU>();

src/core/core.h

@@ -9,6 +9,7 @@
 #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"
@@ -114,6 +115,11 @@ 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);
 
@@ -130,6 +136,11 @@ 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);
 
@@ -186,6 +197,7 @@ 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,14 +48,15 @@ bool CpuBarrier::Rendezvous() {
     return false;
 }
 
-Cpu::Cpu(std::shared_ptr<CpuBarrier> cpu_barrier, size_t core_index)
+Cpu::Cpu(std::shared_ptr<ExclusiveMonitor> exclusive_monitor,
+         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>();
+        arm_interface = std::make_shared<ARM_Dynarmic>(exclusive_monitor, core_index);
 #else
-        cpu_core = std::make_shared<ARM_Unicorn>();
+        arm_interface = std::make_shared<ARM_Unicorn>();
         LOG_WARNING(Core, "CPU JIT requested, but Dynarmic not available");
 #endif
     } else {
@@ -65,6 +66,18 @@ Cpu::Cpu(std::shared_ptr<CpuBarrier> cpu_barrier, size_t core_index)
     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,6 +10,7 @@
 #include <mutex>
 #include <string>
 #include "common/common_types.h"
+#include "core/arm/exclusive_monitor.h"
 
 class ARM_Interface;
 
@@ -40,7 +41,8 @@ private:
 
 class Cpu {
 public:
-    Cpu(std::shared_ptr<CpuBarrier> cpu_barrier, size_t core_index);
+    Cpu(std::shared_ptr<ExclusiveMonitor> exclusive_monitor,
+        std::shared_ptr<CpuBarrier> cpu_barrier, size_t core_index);
 
     void RunLoop(bool tight_loop = true);
 
@@ -64,6 +66,12 @@ 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

@@ -0,0 +1,42 @@
+// 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

@@ -0,0 +1,81 @@
+// 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/hle/kernel/svc.cpp

@@ -650,12 +650,27 @@ static ResultCode SignalProcessWideKey(VAddr condition_variable_addr, s32 target
 
         ASSERT(thread->condvar_wait_address == condition_variable_addr);
 
-        // If the mutex is not yet acquired, acquire it.
-        u32 mutex_val = Memory::Read32(thread->mutex_wait_address);
+        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 (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();
 
@@ -668,7 +683,19 @@ static ResultCode SignalProcessWideKey(VAddr condition_variable_addr, s32 target
             thread->condvar_wait_address = 0;
             thread->wait_handle = 0;
         } else {
-            // Couldn't acquire the mutex, block the thread.
+            // 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.
             Handle owner_handle = static_cast<Handle>(mutex_val & Mutex::MutexOwnerMask);
             auto owner = g_handle_table.Get<Thread>(owner_handle);
             ASSERT(owner);
@@ -676,9 +703,6 @@ 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/loader/nro.cpp

@@ -10,6 +10,8 @@
 #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"
@@ -49,7 +51,55 @@ struct ModHeader {
 };
 static_assert(sizeof(ModHeader) == 0x1c, "ModHeader has incorrect size.");
 
-AppLoader_NRO::AppLoader_NRO(FileSys::VirtualFile file) : AppLoader(std::move(file)) {}
+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)) {
+        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);
+        }
+    }
+}
 
 FileType AppLoader_NRO::IdentifyType(const FileSys::VirtualFile& file) {
     // Read NSO header
@@ -136,4 +186,31 @@ 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

@@ -6,12 +6,15 @@
 
 #include <string>
 #include "common/common_types.h"
+#include "core/file_sys/control_metadata.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/loader/linker.h"
 #include "core/loader/loader.h"
 
 namespace Loader {
 
+struct AssetHeader;
+
 /// Loads an NRO file
 class AppLoader_NRO final : public AppLoader, Linker {
 public:
@@ -30,8 +33,17 @@ 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/video_core/engines/shader_bytecode.h

@@ -288,6 +288,11 @@ union Instruction {
         BitField<49, 1, u64> negate_a;
     } alu_integer;
 
+    union {
+        BitField<39, 3, u64> pred;
+        BitField<42, 1, u64> neg_pred;
+    } sel;
+
     union {
         BitField<39, 3, u64> pred;
         BitField<42, 1, u64> negate_pred;
@@ -420,6 +425,7 @@ union Instruction {
 
     union {
         BitField<50, 3, u64> component_mask_selector;
+        BitField<0, 8, Register> gpr0;
         BitField<28, 8, Register> gpr28;
 
         bool HasTwoDestinations() const {
@@ -427,13 +433,16 @@ union Instruction {
         }
 
         bool IsComponentEnabled(size_t component) const {
-            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};
+            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}}};
 
-            ASSERT(component_mask_selector < mask.size());
+            size_t index{gpr0.Value() != Register::ZeroIndex ? 1U : 0U};
+            index |= gpr28.Value() != Register::ZeroIndex ? 2 : 0;
 
-            return ((1ull << component) & mask[component_mask_selector]) != 0;
+            return ((1ull << component) & mask_lut[index][component_mask_selector]) != 0;
         }
     } texs;
 
@@ -513,6 +522,9 @@ public:
         ISCADD_C, // Scale and Add
         ISCADD_R,
         ISCADD_IMM,
+        SEL_C,
+        SEL_R,
+        SEL_IMM,
         MUFU,  // Multi-Function Operator
         RRO_C, // Range Reduction Operator
         RRO_R,
@@ -713,6 +725,9 @@ private:
             INST("0100110000011---", Id::ISCADD_C, Type::ArithmeticInteger, "ISCADD_C"),
             INST("0101110000011---", Id::ISCADD_R, Type::ArithmeticInteger, "ISCADD_R"),
             INST("0011100-00011---", Id::ISCADD_IMM, Type::ArithmeticInteger, "ISCADD_IMM"),
+            INST("0100110010100---", Id::SEL_C, Type::ArithmeticInteger, "SEL_C"),
+            INST("0101110010100---", Id::SEL_R, Type::ArithmeticInteger, "SEL_R"),
+            INST("0011100010100---", Id::SEL_IMM, Type::ArithmeticInteger, "SEL_IMM"),
             INST("0101000010000---", Id::MUFU, Type::Arithmetic, "MUFU"),
             INST("0100110010010---", Id::RRO_C, Type::Arithmetic, "RRO_C"),
             INST("0101110010010---", Id::RRO_R, Type::Arithmetic, "RRO_R"),

src/video_core/renderer_opengl/gl_shader_decompiler.cpp

@@ -78,14 +78,18 @@ private:
 
     /// Adds and analyzes a new subroutine if it is not added yet.
     const Subroutine& AddSubroutine(u32 begin, u32 end, const std::string& suffix) {
-        auto iter = subroutines.find(Subroutine{begin, end, suffix});
-        if (iter != subroutines.end())
-            return *iter;
+        Subroutine subroutine{begin, end, suffix, ExitMethod::Undetermined, {}};
+
+        const auto iter = subroutines.find(subroutine);
+        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;
     }
 
@@ -191,48 +195,21 @@ public:
         UnsignedInteger,
     };
 
-    GLSLRegister(size_t index, ShaderWriter& shader, const std::string& suffix)
-        : index{index}, shader{shader}, suffix{suffix} {}
+    GLSLRegister(size_t index, const std::string& suffix) : index{index}, suffix{suffix} {}
 
     /// Gets the GLSL type string for a register
-    static std::string GetTypeString(Type type) {
-        switch (type) {
-        case Type::Float:
-            return "float";
-        case Type::Integer:
-            return "int";
-        case Type::UnsignedInteger:
-            return "uint";
-        }
-
-        UNREACHABLE();
-        return {};
+    static std::string GetTypeString() {
+        return "float";
     }
 
     /// Gets the GLSL register prefix string, used for declarations and referencing
-    static std::string GetPrefixString(Type type) {
-        return "reg_" + GetTypeString(type) + '_';
+    static std::string GetPrefixString() {
+        return "reg_";
     }
 
     /// Returns a GLSL string representing the current state of the register
-    std::string GetActiveString() {
-        declr_type.insert(active_type);
-        return GetPrefixString(active_type) + std::to_string(index) + '_' + suffix;
-    }
-
-    /// Returns true if the active type is a float
-    bool IsFloat() const {
-        return active_type == Type::Float;
-    }
-
-    /// Returns true if the active type is an integer
-    bool IsInteger() const {
-        return active_type == Type::Integer;
-    }
-
-    /// Returns the current active type of the register
-    Type GetActiveType() const {
-        return active_type;
+    std::string GetString() const {
+        return GetPrefixString() + std::to_string(index) + '_' + suffix;
     }
 
     /// Returns the index of the register
@@ -240,18 +217,8 @@ public:
         return index;
     }
 
-    /// Returns a set of the declared types of the register
-    const std::set<Type>& DeclaredTypes() const {
-        return declr_type;
-    }
-
 private:
     const size_t index;
-    const std::string float_str;
-    const std::string integer_str;
-    ShaderWriter& shader;
-    Type active_type{Type::Float};
-    std::set<Type> declr_type;
     const std::string& suffix;
 };
 
@@ -297,7 +264,6 @@ public:
      * @returns GLSL string corresponding to the register as a float.
      */
     std::string GetRegisterAsFloat(const Register& reg, unsigned elem = 0) {
-        ASSERT(regs[reg].IsFloat());
         return GetRegister(reg, elem);
     }
 
@@ -311,12 +277,8 @@ public:
      */
     std::string GetRegisterAsInteger(const Register& reg, unsigned elem = 0, bool is_signed = true,
                                      Register::Size size = Register::Size::Word) {
-        const std::string func = GetGLSLConversionFunc(
-            GLSLRegister::Type::Float,
-            is_signed ? GLSLRegister::Type::Integer : GLSLRegister::Type::UnsignedInteger);
-
-        std::string value = func + '(' + GetRegister(reg, elem) + ')';
-
+        const std::string func{is_signed ? "floatBitsToInt" : "floatBitsToUint"};
+        const std::string value{func + '(' + GetRegister(reg, elem) + ')'};
         return ConvertIntegerSize(value, size);
     }
 
@@ -355,9 +317,7 @@ public:
                               u64 dest_elem = 0, Register::Size size = Register::Size::Word) {
         ASSERT_MSG(!is_saturated, "Unimplemented");
 
-        const std::string func = GetGLSLConversionFunc(
-            is_signed ? GLSLRegister::Type::Integer : GLSLRegister::Type::UnsignedInteger,
-            GLSLRegister::Type::Float);
+        const std::string func{is_signed ? "intBitsToFloat" : "uintBitsToFloat"};
 
         SetRegister(reg, elem, func + '(' + ConvertIntegerSize(value, size) + ')',
                     dest_num_components, value_num_components, dest_elem);
@@ -373,14 +333,7 @@ public:
     void SetRegisterToInputAttibute(const Register& reg, u64 elem, Attribute::Index attribute) {
         std::string dest = GetRegisterAsFloat(reg);
         std::string src = GetInputAttribute(attribute) + GetSwizzle(elem);
-
-        if (regs[reg].IsFloat()) {
-            shader.AddLine(dest + " = " + src + ';');
-        } else if (regs[reg].IsInteger()) {
-            shader.AddLine(dest + " = floatBitsToInt(" + src + ");");
-        } else {
-            UNREACHABLE();
-        }
+        shader.AddLine(dest + " = " + src + ';');
     }
 
     /**
@@ -393,7 +346,6 @@ public:
     void SetOutputAttributeToRegister(Attribute::Index attribute, u64 elem, const Register& reg) {
         std::string dest = GetOutputAttribute(attribute) + GetSwizzle(elem);
         std::string src = GetRegisterAsFloat(reg);
-        ASSERT_MSG(regs[reg].IsFloat(), "Output attributes must be set to a float");
         shader.AddLine(dest + " = " + src + ';');
     }
 
@@ -434,11 +386,8 @@ public:
     /// Add declarations for registers
     void GenerateDeclarations(const std::string& suffix) {
         for (const auto& reg : regs) {
-            for (const auto& type : reg.DeclaredTypes()) {
-                declarations.AddLine(GLSLRegister::GetTypeString(type) + ' ' +
-                                     reg.GetPrefixString(type) + std::to_string(reg.GetIndex()) +
-                                     '_' + suffix + " = 0;");
-            }
+            declarations.AddLine(GLSLRegister::GetTypeString() + ' ' + reg.GetPrefixString() +
+                                 std::to_string(reg.GetIndex()) + '_' + suffix + " = 0;");
         }
         declarations.AddNewLine();
 
@@ -516,21 +465,13 @@ public:
     }
 
 private:
-    /// Build GLSL conversion function, e.g. floatBitsToInt, intBitsToFloat, etc.
-    std::string GetGLSLConversionFunc(GLSLRegister::Type src, GLSLRegister::Type dest) const {
-        const std::string src_type = GLSLRegister::GetTypeString(src);
-        std::string dest_type = GLSLRegister::GetTypeString(dest);
-        dest_type[0] = toupper(dest_type[0]);
-        return src_type + "BitsTo" + dest_type;
-    }
-
     /// Generates code representing a temporary (GPR) register.
     std::string GetRegister(const Register& reg, unsigned elem) {
         if (reg == Register::ZeroIndex) {
             return "0";
         }
 
-        return regs[reg.GetSwizzledIndex(elem)].GetActiveString();
+        return regs[reg.GetSwizzledIndex(elem)].GetString();
     }
 
     /**
@@ -560,7 +501,7 @@ private:
     /// Build the GLSL register list.
     void BuildRegisterList() {
         for (size_t index = 0; index < Register::NumRegisters; ++index) {
-            regs.emplace_back(index, shader, suffix);
+            regs.emplace_back(index, suffix);
         }
     }
 
@@ -1139,6 +1080,15 @@ private:
                                           "((" + op_a + " << " + shift + ") + " + op_b + ')', 1, 1);
                 break;
             }
+            case OpCode::Id::SEL_C:
+            case OpCode::Id::SEL_R:
+            case OpCode::Id::SEL_IMM: {
+                std::string condition =
+                    GetPredicateCondition(instr.sel.pred, instr.sel.neg_pred != 0);
+                regs.SetRegisterToInteger(instr.gpr0, true, 0,
+                                          '(' + condition + ") ? " + op_a + " : " + op_b, 1, 1);
+                break;
+            }
             case OpCode::Id::LOP_C:
             case OpCode::Id::LOP_R:
             case OpCode::Id::LOP_IMM: {

src/yuzu/main.cpp

@@ -338,6 +338,18 @@ 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,10 +85,20 @@ 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);