Ignore asserts - DO NOT CHECK IN

2018-07-03 01:11:48 -04:00
49 changed files with 292 additions and 1029 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -11,7 +11,6 @@ src/common/scm_rev.cpp
 .idea/
 .vs/
 .vscode/
-CMakeLists.txt.user

 # *nix related
 # Common convention for backup or temporary files
--- a/CMakeModules/CopyYuzuQt5Deps.cmake
+++ b/CMakeModules/CopyYuzuQt5Deps.cmake
@@ -3,9 +3,7 @@ function(copy_yuzu_Qt5_deps target_dir)
    set(DLL_DEST "${CMAKE_BINARY_DIR}/bin/$<CONFIG>/")
    set(Qt5_DLL_DIR "${Qt5_DIR}/../../../bin")
    set(Qt5_PLATFORMS_DIR "${Qt5_DIR}/../../../plugins/platforms/")
-    set(Qt5_STYLES_DIR "${Qt5_DIR}/../../../plugins/styles/")
    set(PLATFORMS ${DLL_DEST}platforms/)
-    set(STYLES ${DLL_DEST}styles/)
    windows_copy_files(${target_dir} ${Qt5_DLL_DIR} ${DLL_DEST}
        icudt*.dll
        icuin*.dll
@@ -16,5 +14,4 @@ function(copy_yuzu_Qt5_deps target_dir)
        Qt5Widgets$<$<CONFIG:Debug>:d>.*
    )
    windows_copy_files(yuzu ${Qt5_PLATFORMS_DIR} ${PLATFORMS} qwindows$<$<CONFIG:Debug>:d>.*)
-    windows_copy_files(yuzu ${Qt5_STYLES_DIR} ${STYLES} qwindowsvistastyle$<$<CONFIG:Debug>:d>.*)
 endfunction(copy_yuzu_Qt5_deps)
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,6 +1,6 @@
 # Reporting Issues

-**The issue tracker is not a support forum.** Unless you can provide precise *technical information* regarding an issue, you *should not post in it*. If you need support, first read the [FAQ](https://github.com/yuzu-emu/yuzu/wiki/FAQ) and then either visit our [Discord server](https://discordapp.com/invite/u77vRWY), [our forum](https://community.citra-emu.org) or ask in a general emulation forum such as [/r/emulation](https://www.reddit.com/r/emulation/). If you post support questions, generic messages to the developers or vague reports without technical details, they will be closed and locked.
+**The issue tracker is not a support forum.** Unless you can provide precise *technical information* regarding an issue, you *should not post in it*. If you need support, first read the [FAQ](https://github.com/yuzu-emu/yuzu/wiki/FAQ) and then either visit our Discord server, [our forum](https://community.citra-emu.org) or ask in a general emulation forum such as [/r/emulation](https://www.reddit.com/r/emulation/). If you post support questions, generic messages to the developers or vague reports without technical details, they will be closed and locked.

 If you believe you have a valid issue report, please post text or a screenshot from the log (the console window that opens alongside yuzu) and build version (hex string visible in the titlebar and zip filename), as well as your hardware and software information if applicable.

--- a/appveyor.yml
+++ b/appveyor.yml
@@ -116,7 +116,6 @@ after_build:

          mkdir $RELEASE_DIST
          mkdir $RELEASE_DIST/platforms
-          mkdir $RELEASE_DIST/styles

          # copy the compiled binaries and other release files to the release folder
          Get-ChildItem "$CMAKE_BINARY_DIR" -Filter "yuzu*.exe" | Copy-Item -destination $RELEASE_DIST
@@ -137,9 +136,6 @@ after_build:
          # copy the qt windows plugin dll to platforms
          Copy-Item -path "C:/msys64/mingw64/share/qt5/plugins/platforms/qwindows.dll" -force -destination "$RELEASE_DIST/platforms"

-          # copy the qt windows vista style dll to platforms
-          Copy-Item -path "C:/msys64/mingw64/share/qt5/plugins/styles/qwindowsvistastyle.dll" -force -destination "$RELEASE_DIST/styles"
-
          7z a -tzip $MINGW_BUILD_ZIP $RELEASE_DIST\*
          7z a $MINGW_SEVENZIP $RELEASE_DIST
        }
--- a/externals/cmake-modules/WindowsCopyFiles.cmake
+++ b/externals/cmake-modules/WindowsCopyFiles.cmake
@@ -1,4 +1,4 @@
-# Copyright 2018 Yuzu Emulator Project
+# Copyright 2016 Citra Emulator Project
 # Licensed under GPLv2 or any later version
 # Refer to the license.txt file included.

@@ -22,7 +22,7 @@ function(windows_copy_files TARGET SOURCE_DIR DEST_DIR)
    # cmake adds an extra check for command success which doesn't work too well with robocopy
    # so trick it into thinking the command was successful with the || cmd /c "exit /b 0"
    add_custom_command(TARGET ${TARGET} POST_BUILD
-        COMMAND ${CMAKE_COMMAND} -E make_directory ${DEST_DIR}
+        COMMAND if not exist ${DEST_DIR} mkdir ${DEST_DIR} 2> nul
        COMMAND robocopy ${SOURCE_DIR} ${DEST_DIR} ${ARGN} /NJH /NJS /NDL /NFL /NC /NS /NP || cmd /c "exit /b 0"
    )
-endfunction()
+endfunction()
--- a/externals/dynarmic
+++ b/externals/dynarmic
--- a/src/common/assert.h
+++ b/src/common/assert.h
@@ -28,18 +28,12 @@ __declspec(noinline, noreturn)
 }

 #define ASSERT(_a_)                                                                                \
-    do                                                                                             \
-        if (!(_a_)) {                                                                              \
-            assert_noinline_call([] { LOG_CRITICAL(Debug, "Assertion Failed!"); });                \
-        }                                                                                          \
-    while (0)
+    if (!(_a_)) {                                                                                  \
+    }

 #define ASSERT_MSG(_a_, ...)                                                                       \
-    do                                                                                             \
-        if (!(_a_)) {                                                                              \
-            assert_noinline_call([&] { LOG_CRITICAL(Debug, "Assertion Failed!\n" __VA_ARGS__); }); \
-        }                                                                                          \
-    while (0)
+    if (!(_a_)) {                                                                                  \
+    }

 #define UNREACHABLE() ASSERT_MSG(false, "Unreachable code!")
 #define UNREACHABLE_MSG(...) ASSERT_MSG(false, __VA_ARGS__)
@@ -52,5 +46,5 @@ __declspec(noinline, noreturn)
 #define DEBUG_ASSERT_MSG(_a_, _desc_, ...)
 #endif

-#define UNIMPLEMENTED() LOG_CRITICAL(Debug, "Unimplemented code!")
+#define UNIMPLEMENTED() DEBUG_ASSERT_MSG(false, "Unimplemented code!")
 #define UNIMPLEMENTED_MSG(...) ASSERT_MSG(false, __VA_ARGS__)
--- a/src/common/common_funcs.h
+++ b/src/common/common_funcs.h
@@ -4,7 +4,7 @@

 #pragma once

-#if !defined(ARCHITECTURE_x86_64) && !defined(ARCHITECTURE_ARM)
+#if !defined(ARCHITECTURE_x86_64) && !defined(_M_ARM)
 #include <cstdlib> // for exit
 #endif
 #include "common/common_types.h"
@@ -30,7 +30,7 @@

 #ifdef ARCHITECTURE_x86_64
 #define Crash() __asm__ __volatile__("int $3")
-#elif defined(ARCHITECTURE_ARM)
+#elif defined(_M_ARM)
 #define Crash() __asm__ __volatile__("trap")
 #else
 #define Crash() exit(1)
--- a/src/common/common_paths.h
+++ b/src/common/common_paths.h
@@ -40,7 +40,7 @@
 #define DEBUGGER_CONFIG "debugger.ini"
 #define LOGGER_CONFIG "logger.ini"
 // Files in the directory returned by GetUserPath(D_LOGS_IDX)
-#define LOG_FILE "yuzu_log.txt"
+#define LOG_FILE "citra_log.txt"

 // Sys files
 #define SHARED_FONT "shared_font.bin"
--- a/src/common/file_util.cpp
+++ b/src/common/file_util.cpp
@@ -678,7 +678,7 @@ std::string GetSysDirectory() {
    return sysDir;
 }

-// Returns a string with a yuzu data dir or file in the user's home
+// Returns a string with a Citra data dir or file in the user's home
 // directory. To be used in "multi-user" mode (that is, installed).
 const std::string& GetUserPath(const unsigned int DirIDX, const std::string& newPath) {
    static std::string paths[NUM_PATH_INDICES];
--- a/src/common/memory_util.cpp
+++ b/src/common/memory_util.cpp
@@ -16,7 +16,7 @@
 #include <sys/mman.h>
 #endif

-#if !defined(_WIN32) && defined(ARCHITECTURE_x86_64) && !defined(MAP_32BIT)
+#if !defined(_WIN32) && defined(ARCHITECTURE_X64) && !defined(MAP_32BIT)
 #include <unistd.h>
 #define PAGE_MASK (getpagesize() - 1)
 #define round_page(x) ((((unsigned long)(x)) + PAGE_MASK) & ~(PAGE_MASK))
@@ -30,7 +30,7 @@ void* AllocateExecutableMemory(size_t size, bool low) {
    void* ptr = VirtualAlloc(nullptr, size, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
 #else
    static char* map_hint = nullptr;
-#if defined(ARCHITECTURE_x86_64) && !defined(MAP_32BIT)
+#if defined(ARCHITECTURE_X64) && !defined(MAP_32BIT)
    // This OS has no flag to enforce allocation below the 4 GB boundary,
    // but if we hint that we want a low address it is very likely we will
    // get one.
@@ -42,7 +42,7 @@ void* AllocateExecutableMemory(size_t size, bool low) {
 #endif
    void* ptr = mmap(map_hint, size, PROT_READ | PROT_WRITE | PROT_EXEC,
                     MAP_ANON | MAP_PRIVATE
-#if defined(ARCHITECTURE_x86_64) && defined(MAP_32BIT)
+#if defined(ARCHITECTURE_X64) && defined(MAP_32BIT)
                         | (low ? MAP_32BIT : 0)
 #endif
                         ,
@@ -57,7 +57,7 @@ void* AllocateExecutableMemory(size_t size, bool low) {
 #endif
        LOG_ERROR(Common_Memory, "Failed to allocate executable memory");
    }
-#if !defined(_WIN32) && defined(ARCHITECTURE_x86_64) && !defined(MAP_32BIT)
+#if !defined(_WIN32) && defined(ARCHITECTURE_X64) && !defined(MAP_32BIT)
    else {
        if (low) {
            map_hint += size;
--- a/src/common/string_util.cpp
+++ b/src/common/string_util.cpp
@@ -134,7 +134,7 @@ bool SplitPath(const std::string& full_path, std::string* _pPath, std::string* _
    size_t dir_end = full_path.find_last_of("/"
 // windows needs the : included for something like just "C:" to be considered a directory
 #ifdef _WIN32
-                                            "\\:"
+                                            ":"
 #endif
    );
    if (std::string::npos == dir_end)
--- a/src/common/swap.h
+++ b/src/common/swap.h
@@ -69,7 +69,7 @@ inline u32 swap32(u32 _data) {
 inline u64 swap64(u64 _data) {
    return _byteswap_uint64(_data);
 }
-#elif ARCHITECTURE_ARM
+#elif _M_ARM
 inline u16 swap16(u16 _data) {
    u32 data = _data;
    __asm__("rev16 %0, %1\n" : "=l"(data) : "l"(data));
--- a/src/core/arm/unicorn/arm_unicorn.cpp
+++ b/src/core/arm/unicorn/arm_unicorn.cpp
@@ -193,11 +193,11 @@ void ARM_Unicorn::ExecuteInstructions(int num_instructions) {
        }
        Kernel::Thread* thread = Kernel::GetCurrentThread();
        SaveContext(thread->context);
-        if (last_bkpt_hit || (num_instructions == 1)) {
+        if (last_bkpt_hit) {
            last_bkpt_hit = false;
            GDBStub::Break();
-            GDBStub::SendTrap(thread, 5);
        }
+        GDBStub::SendTrap(thread, 5);
    }
 }

--- a/src/core/file_sys/errors.h
+++ b/src/core/file_sys/errors.h
@@ -11,7 +11,6 @@ namespace FileSys {
 namespace ErrCodes {
 enum {
    NotFound = 1,
-    SaveDataNotFound = 1002,
 };
 }

--- a/src/core/file_sys/savedata_factory.cpp
+++ b/src/core/file_sys/savedata_factory.cpp
@@ -17,15 +17,6 @@ SaveData_Factory::SaveData_Factory(std::string nand_directory)

 ResultVal<std::unique_ptr<FileSystemBackend>> SaveData_Factory::Open(const Path& path) {
    std::string save_directory = GetFullPath();
-
-    if (!FileUtil::Exists(save_directory)) {
-        // TODO(bunnei): This is a work-around to always create a save data directory if it does not
-        // already exist. This is a hack, as we do not understand yet how this works on hardware.
-        // Without a save data directory, many games will assert on boot. This should not have any
-        // bad side-effects.
-        FileUtil::CreateFullPath(save_directory);
-    }
-
    // Return an error if the save data doesn't actually exist.
    if (!FileUtil::IsDirectory(save_directory)) {
        // TODO(Subv): Find out correct error code.
--- a/src/core/gdbstub/gdbstub.cpp
+++ b/src/core/gdbstub/gdbstub.cpp
@@ -61,16 +61,10 @@ const u32 SIGTERM = 15;
 const u32 MSG_WAITALL = 8;
 #endif

-const u32 LR_REGISTER = 30;
+const u32 X30_REGISTER = 30;
 const u32 SP_REGISTER = 31;
 const u32 PC_REGISTER = 32;
 const u32 CPSR_REGISTER = 33;
-const u32 UC_ARM64_REG_Q0 = 34;
-const u32 FPSCR_REGISTER = 66;
-
-// TODO/WiP - Used while working on support for FPU
-const u32 TODO_DUMMY_REG_997 = 997;
-const u32 TODO_DUMMY_REG_998 = 998;

 // For sample XML files see the GDB source /gdb/features
 // GDB also wants the l character at the start
@@ -136,8 +130,6 @@ static const char* target_xml =
    </flags>
    <reg name="cpsr" bitsize="32" type="cpsr_flags"/>
  </feature>
-  <feature name="org.gnu.gdb.aarch64.fpu">
-  </feature>
 </target>
 )";

@@ -152,7 +144,6 @@ static u32 latest_signal = 0;
 static bool memory_break = false;

 static Kernel::Thread* current_thread = nullptr;
-static u32 current_core = 0;

 // Binding to a port within the reserved ports range (0-1023) requires root permissions,
 // so default to a port outside of that range.
@@ -180,34 +171,13 @@ static std::map<u64, Breakpoint> breakpoints_execute;
 static std::map<u64, Breakpoint> breakpoints_read;
 static std::map<u64, Breakpoint> breakpoints_write;

-struct Module {
-    std::string name;
-    PAddr beg;
-    PAddr end;
-};
-
-static std::vector<Module> modules;
-
-void RegisterModule(std::string name, PAddr beg, PAddr end, bool add_elf_ext) {
-    Module module;
-    if (add_elf_ext) {
-        Common::SplitPath(name, nullptr, &module.name, nullptr);
-        module.name += ".elf";
-    } else {
-        module.name = std::move(name);
-    }
-    module.beg = beg;
-    module.end = end;
-    modules.push_back(std::move(module));
-}
-
 static Kernel::Thread* FindThreadById(int id) {
-    for (u32 core = 0; core < Core::NUM_CPU_CORES; core++) {
-        const auto& threads = Core::System::GetInstance().Scheduler(core)->GetThreadList();
-        for (auto& thread : threads) {
+    for (int core = 0; core < Core::NUM_CPU_CORES; core++) {
+        auto threads = Core::System::GetInstance().Scheduler(core)->GetThreadList();
+        for (auto thread : threads) {
            if (thread->GetThreadId() == id) {
-                current_core = core;
-                return thread.get();
+                current_thread = thread.get();
+                return current_thread;
            }
        }
    }
@@ -227,8 +197,6 @@ static u64 RegRead(int id, Kernel::Thread* thread = nullptr) {
        return thread->context.pc;
    } else if (id == CPSR_REGISTER) {
        return thread->context.cpsr;
-    } else if (id > CPSR_REGISTER && id < FPSCR_REGISTER) {
-        return thread->context.fpu_registers[id - UC_ARM64_REG_Q0][0];
    } else {
        return 0;
    }
@@ -247,8 +215,6 @@ static void RegWrite(int id, u64 val, Kernel::Thread* thread = nullptr) {
        thread->context.pc = val;
    } else if (id == CPSR_REGISTER) {
        thread->context.cpsr = val;
-    } else if (id > CPSR_REGISTER && id < FPSCR_REGISTER) {
-        thread->context.fpu_registers[id - (CPSR_REGISTER + 1)][0] = val;
    }
 }

@@ -568,11 +534,7 @@ static void HandleQuery() {
        SendReply("T0");
    } else if (strncmp(query, "Supported", strlen("Supported")) == 0) {
        // PacketSize needs to be large enough for target xml
-        std::string buffer = "PacketSize=2000;qXfer:features:read+;qXfer:threads:read+";
-        if (!modules.empty()) {
-            buffer += ";qXfer:libraries:read+";
-        }
-        SendReply(buffer.c_str());
+        SendReply("PacketSize=2000;qXfer:features:read+");
    } else if (strncmp(query, "Xfer:features:read:target.xml:",
                       strlen("Xfer:features:read:target.xml:")) == 0) {
        SendReply(target_xml);
@@ -581,9 +543,9 @@ static void HandleQuery() {
        SendReply(buffer.c_str());
    } else if (strncmp(query, "fThreadInfo", strlen("fThreadInfo")) == 0) {
        std::string val = "m";
-        for (u32 core = 0; core < Core::NUM_CPU_CORES; core++) {
-            const auto& threads = Core::System::GetInstance().Scheduler(core)->GetThreadList();
-            for (const auto& thread : threads) {
+        for (int core = 0; core < Core::NUM_CPU_CORES; core++) {
+            auto threads = Core::System::GetInstance().Scheduler(core)->GetThreadList();
+            for (auto thread : threads) {
                val += fmt::format("{:x}", thread->GetThreadId());
                val += ",";
            }
@@ -592,31 +554,6 @@ static void HandleQuery() {
        SendReply(val.c_str());
    } else if (strncmp(query, "sThreadInfo", strlen("sThreadInfo")) == 0) {
        SendReply("l");
-    } else if (strncmp(query, "Xfer:threads:read", strlen("Xfer:threads:read")) == 0) {
-        std::string buffer;
-        buffer += "l<?xml version=\"1.0\"?>";
-        buffer += "<threads>";
-        for (u32 core = 0; core < Core::NUM_CPU_CORES; core++) {
-            const auto& threads = Core::System::GetInstance().Scheduler(core)->GetThreadList();
-            for (const auto& thread : threads) {
-                buffer +=
-                    fmt::format(R"*(<thread id="{:x}" core="{:d}" name="Thread {:x}"></thread>)*",
-                                thread->GetThreadId(), core, thread->GetThreadId());
-            }
-        }
-        buffer += "</threads>";
-        SendReply(buffer.c_str());
-    } else if (strncmp(query, "Xfer:libraries:read", strlen("Xfer:libraries:read")) == 0) {
-        std::string buffer;
-        buffer += "l<?xml version=\"1.0\"?>";
-        buffer += "<library-list>";
-        for (const auto& module : modules) {
-            buffer +=
-                fmt::format(R"*("<library name = "{}"><segment address = "0x{:x}"/></library>)*",
-                            module.name, module.beg);
-        }
-        buffer += "</library-list>";
-        SendReply(buffer.c_str());
    } else {
        SendReply("");
    }
@@ -624,27 +561,33 @@ static void HandleQuery() {

 /// Handle set thread command from gdb client.
 static void HandleSetThread() {
-    int thread_id = -1;
-    if (command_buffer[2] != '-') {
-        thread_id = static_cast<int>(HexToInt(command_buffer + 2, command_length - 2));
-    }
-    if (thread_id >= 1) {
-        current_thread = FindThreadById(thread_id);
-    }
-    if (!current_thread) {
-        thread_id = 1;
-        current_thread = FindThreadById(thread_id);
-    }
-    if (current_thread) {
-        SendReply("OK");
-        return;
+    if (memcmp(command_buffer, "Hc", 2) == 0 || memcmp(command_buffer, "Hg", 2) == 0) {
+        int thread_id = -1;
+        if (command_buffer[2] != '-') {
+            thread_id = static_cast<int>(HexToInt(
+                command_buffer + 2,
+                command_length - 2 /*strlen(reinterpret_cast<char*>(command_buffer) + 2)*/));
+        }
+        if (thread_id >= 1) {
+            current_thread = FindThreadById(thread_id);
+        }
+        if (!current_thread) {
+            thread_id = 1;
+            current_thread = FindThreadById(thread_id);
+        }
+        if (current_thread) {
+            SendReply("OK");
+            return;
+        }
    }
    SendReply("E01");
 }

 /// Handle thread alive command from gdb client.
 static void HandleThreadAlive() {
-    int thread_id = static_cast<int>(HexToInt(command_buffer + 1, command_length - 1));
+    int thread_id = static_cast<int>(
+        HexToInt(command_buffer + 1,
+                 command_length - 1 /*strlen(reinterpret_cast<char*>(command_buffer) + 1)*/));
    if (thread_id == 0) {
        thread_id = 1;
    }
@@ -667,23 +610,16 @@ static void SendSignal(Kernel::Thread* thread, u32 signal, bool full = true) {

    latest_signal = signal;

-    if (!thread) {
-        full = false;
-    }
-
    std::string buffer;
    if (full) {
-        buffer = fmt::format("T{:02x}{:02x}:{:016x};{:02x}:{:016x};{:02x}:{:016x}", latest_signal,
-                             PC_REGISTER, Common::swap64(RegRead(PC_REGISTER, thread)), SP_REGISTER,
-                             Common::swap64(RegRead(SP_REGISTER, thread)), LR_REGISTER,
-                             Common::swap64(RegRead(LR_REGISTER, thread)));
+        buffer = fmt::format("T{:02x}{:02x}:{:016x};{:02x}:{:016x};", latest_signal, PC_REGISTER,
+                             Common::swap64(RegRead(PC_REGISTER, thread)), SP_REGISTER,
+                             Common::swap64(RegRead(SP_REGISTER, thread)));
    } else {
-        buffer = fmt::format("T{:02x}", latest_signal);
+        buffer = fmt::format("T{:02x};", latest_signal);
    }

-    if (thread) {
-        buffer += fmt::format(";thread:{:x};", thread->GetThreadId());
-    }
+    buffer += fmt::format("thread:{:x};", thread->GetThreadId());

    SendReply(buffer.c_str());
 }
@@ -775,12 +711,8 @@ static void ReadRegister() {
        LongToGdbHex(reply, RegRead(id, current_thread));
    } else if (id == CPSR_REGISTER) {
        IntToGdbHex(reply, (u32)RegRead(id, current_thread));
-    } else if (id >= UC_ARM64_REG_Q0 && id < FPSCR_REGISTER) {
-        LongToGdbHex(reply, RegRead(id, current_thread));
-    } else if (id == FPSCR_REGISTER) {
-        LongToGdbHex(reply, RegRead(TODO_DUMMY_REG_998, current_thread));
    } else {
-        LongToGdbHex(reply, RegRead(TODO_DUMMY_REG_997, current_thread));
+        return SendReply("E01");
    }

    SendReply(reinterpret_cast<char*>(reply));
@@ -797,7 +729,7 @@ static void ReadRegisters() {
        LongToGdbHex(bufptr + reg * 16, RegRead(reg, current_thread));
    }

-    bufptr += 32 * 16;
+    bufptr += (32 * 16);

    LongToGdbHex(bufptr, RegRead(PC_REGISTER, current_thread));

@@ -807,16 +739,6 @@ static void ReadRegisters() {

    bufptr += 8;

-    for (int reg = UC_ARM64_REG_Q0; reg <= UC_ARM64_REG_Q0 + 31; reg++) {
-        LongToGdbHex(bufptr + reg * 16, RegRead(reg, current_thread));
-    }
-
-    bufptr += 32 * 32;
-
-    LongToGdbHex(bufptr, RegRead(TODO_DUMMY_REG_998, current_thread));
-
-    bufptr += 8;
-
    SendReply(reinterpret_cast<char*>(buffer));
 }

@@ -837,17 +759,10 @@ static void WriteRegister() {
        RegWrite(id, GdbHexToLong(buffer_ptr), current_thread);
    } else if (id == CPSR_REGISTER) {
        RegWrite(id, GdbHexToInt(buffer_ptr), current_thread);
-    } else if (id >= UC_ARM64_REG_Q0 && id < FPSCR_REGISTER) {
-        RegWrite(id, GdbHexToLong(buffer_ptr), current_thread);
-    } else if (id == FPSCR_REGISTER) {
-        RegWrite(TODO_DUMMY_REG_998, GdbHexToLong(buffer_ptr), current_thread);
    } else {
-        RegWrite(TODO_DUMMY_REG_997, GdbHexToLong(buffer_ptr), current_thread);
+        return SendReply("E01");
    }

-    // Update Unicorn context skipping scheduler, no running threads at this point
-    Core::System::GetInstance().ArmInterface(current_core).LoadContext(current_thread->context);
-
    SendReply("OK");
 }

@@ -858,25 +773,18 @@ static void WriteRegisters() {
    if (command_buffer[0] != 'G')
        return SendReply("E01");

-    for (int i = 0, reg = 0; reg <= FPSCR_REGISTER; i++, reg++) {
+    for (int i = 0, reg = 0; reg <= CPSR_REGISTER; i++, reg++) {
        if (reg <= SP_REGISTER) {
            RegWrite(reg, GdbHexToLong(buffer_ptr + i * 16), current_thread);
        } else if (reg == PC_REGISTER) {
            RegWrite(PC_REGISTER, GdbHexToLong(buffer_ptr + i * 16), current_thread);
        } else if (reg == CPSR_REGISTER) {
            RegWrite(CPSR_REGISTER, GdbHexToInt(buffer_ptr + i * 16), current_thread);
-        } else if (reg >= UC_ARM64_REG_Q0 && reg < FPSCR_REGISTER) {
-            RegWrite(reg, GdbHexToLong(buffer_ptr + i * 16), current_thread);
-        } else if (reg == FPSCR_REGISTER) {
-            RegWrite(TODO_DUMMY_REG_998, GdbHexToLong(buffer_ptr + i * 16), current_thread);
        } else {
            UNIMPLEMENTED();
        }
    }

-    // Update Unicorn context skipping scheduler, no running threads at this point
-    Core::System::GetInstance().ArmInterface(current_core).LoadContext(current_thread->context);
-
    SendReply("OK");
 }

@@ -898,10 +806,6 @@ static void ReadMemory() {
        SendReply("E01");
    }

-    if (addr < Memory::PROCESS_IMAGE_VADDR || addr >= Memory::MAP_REGION_VADDR_END) {
-        return SendReply("E00");
-    }
-
    if (!Memory::IsValidVirtualAddress(addr)) {
        return SendReply("E00");
    }
@@ -936,18 +840,16 @@ static void WriteMemory() {
 }

 void Break(bool is_memory_break) {
-    send_trap = true;
+    if (!halt_loop) {
+        halt_loop = true;
+        send_trap = true;
+    }

    memory_break = is_memory_break;
 }

 /// Tell the CPU that it should perform a single step.
 static void Step() {
-    if (command_length > 1) {
-        RegWrite(PC_REGISTER, GdbHexToLong(command_buffer + 1), current_thread);
-        // Update Unicorn context skipping scheduler, no running threads at this point
-        Core::System::GetInstance().ArmInterface(current_core).LoadContext(current_thread->context);
-    }
    step_loop = true;
    halt_loop = true;
    send_trap = true;
@@ -1188,8 +1090,6 @@ static void Init(u16 port) {
    breakpoints_read.clear();
    breakpoints_write.clear();

-    modules.clear();
-
    // Start gdb server
    LOG_INFO(Debug_GDBStub, "Starting GDB server on port {}...", port);

@@ -1292,12 +1192,8 @@ void SetCpuStepFlag(bool is_step) {

 void SendTrap(Kernel::Thread* thread, int trap) {
    if (send_trap) {
-        if (!halt_loop || current_thread == thread) {
-            current_thread = thread;
-            SendSignal(thread, trap);
-        }
-        halt_loop = true;
        send_trap = false;
+        SendSignal(thread, trap);
    }
 }
 }; // namespace GDBStub
--- a/src/core/gdbstub/gdbstub.h
+++ b/src/core/gdbstub/gdbstub.h
@@ -6,7 +6,6 @@

 #pragma once

-#include <string>
 #include "common/common_types.h"
 #include "core/hle/kernel/thread.h"

@@ -52,9 +51,6 @@ bool IsServerEnabled();
 /// Returns true if there is an active socket connection.
 bool IsConnected();

-/// Register module.
-void RegisterModule(std::string name, PAddr beg, PAddr end, bool add_elf_ext = true);
-
 /**
 * Signal to the gdbstub server that it should halt CPU execution.
 *
@@ -84,10 +80,10 @@ BreakpointAddress GetNextBreakpointFromAddress(PAddr addr, GDBStub::BreakpointTy
 */
 bool CheckBreakpoint(PAddr addr, GDBStub::BreakpointType type);

-/// If set to true, the CPU will halt at the beginning of the next CPU loop.
+// If set to true, the CPU will halt at the beginning of the next CPU loop.
 bool GetCpuHaltFlag();

-/// If set to true and the CPU is halted, the CPU will step one instruction.
+// If set to true and the CPU is halted, the CPU will step one instruction.
 bool GetCpuStepFlag();

 /**
--- a/src/core/hle/service/audio/audout_u.cpp
+++ b/src/core/hle/service/audio/audout_u.cpp
@@ -27,12 +27,12 @@ public:
            {0, &IAudioOut::GetAudioOutState, "GetAudioOutState"},
            {1, &IAudioOut::StartAudioOut, "StartAudioOut"},
            {2, &IAudioOut::StopAudioOut, "StopAudioOut"},
-            {3, &IAudioOut::AppendAudioOutBufferImpl, "AppendAudioOutBuffer"},
+            {3, &IAudioOut::AppendAudioOutBuffer, "AppendAudioOutBuffer"},
            {4, &IAudioOut::RegisterBufferEvent, "RegisterBufferEvent"},
-            {5, &IAudioOut::GetReleasedAudioOutBufferImpl, "GetReleasedAudioOutBuffer"},
+            {5, &IAudioOut::GetReleasedAudioOutBuffer, "GetReleasedAudioOutBuffer"},
            {6, nullptr, "ContainsAudioOutBuffer"},
-            {7, &IAudioOut::AppendAudioOutBufferImpl, "AppendAudioOutBufferAuto"},
-            {8, &IAudioOut::GetReleasedAudioOutBufferImpl, "GetReleasedAudioOutBufferAuto"},
+            {7, nullptr, "AppendAudioOutBufferAuto"},
+            {8, nullptr, "GetReleasedAudioOutBufferAuto"},
            {9, nullptr, "GetAudioOutBufferCount"},
            {10, nullptr, "GetAudioOutPlayedSampleCount"},
            {11, nullptr, "FlushAudioOutBuffers"},
@@ -96,7 +96,7 @@ private:
        rb.PushCopyObjects(buffer_event);
    }

-    void AppendAudioOutBufferImpl(Kernel::HLERequestContext& ctx) {
+    void AppendAudioOutBuffer(Kernel::HLERequestContext& ctx) {
        LOG_WARNING(Service_Audio, "(STUBBED) called");
        IPC::RequestParser rp{ctx};

@@ -107,7 +107,7 @@ private:
        rb.Push(RESULT_SUCCESS);
    }

-    void GetReleasedAudioOutBufferImpl(Kernel::HLERequestContext& ctx) {
+    void GetReleasedAudioOutBuffer(Kernel::HLERequestContext& ctx) {
        LOG_WARNING(Service_Audio, "(STUBBED) called");

        // TODO(st4rk): This is how libtransistor currently implements the
@@ -163,7 +163,7 @@ private:
    AudioState audio_out_state;
 };

-void AudOutU::ListAudioOutsImpl(Kernel::HLERequestContext& ctx) {
+void AudOutU::ListAudioOuts(Kernel::HLERequestContext& ctx) {
    LOG_WARNING(Service_Audio, "(STUBBED) called");
    IPC::RequestParser rp{ctx};

@@ -179,7 +179,7 @@ void AudOutU::ListAudioOutsImpl(Kernel::HLERequestContext& ctx) {
    rb.Push<u32>(1);
 }

-void AudOutU::OpenAudioOutImpl(Kernel::HLERequestContext& ctx) {
+void AudOutU::OpenAudioOut(Kernel::HLERequestContext& ctx) {
    LOG_WARNING(Service_Audio, "(STUBBED) called");

    if (!audio_out_interface) {
@@ -196,10 +196,10 @@ void AudOutU::OpenAudioOutImpl(Kernel::HLERequestContext& ctx) {
 }

 AudOutU::AudOutU() : ServiceFramework("audout:u") {
-    static const FunctionInfo functions[] = {{0, &AudOutU::ListAudioOutsImpl, "ListAudioOuts"},
-                                             {1, &AudOutU::OpenAudioOutImpl, "OpenAudioOut"},
-                                             {2, &AudOutU::ListAudioOutsImpl, "ListAudioOutsAuto"},
-                                             {3, &AudOutU::OpenAudioOutImpl, "OpenAudioOutAuto"}};
+    static const FunctionInfo functions[] = {{0, &AudOutU::ListAudioOuts, "ListAudioOuts"},
+                                             {1, &AudOutU::OpenAudioOut, "OpenAudioOut"},
+                                             {2, nullptr, "ListAudioOutsAuto"},
+                                             {3, nullptr, "OpenAudioOutAuto"}};
    RegisterHandlers(functions);
 }

--- a/src/core/hle/service/audio/audout_u.h
+++ b/src/core/hle/service/audio/audout_u.h
@@ -22,8 +22,8 @@ public:
 private:
    std::shared_ptr<IAudioOut> audio_out_interface;

-    void ListAudioOutsImpl(Kernel::HLERequestContext& ctx);
-    void OpenAudioOutImpl(Kernel::HLERequestContext& ctx);
+    void ListAudioOuts(Kernel::HLERequestContext& ctx);
+    void OpenAudioOut(Kernel::HLERequestContext& ctx);

    enum class PcmFormat : u32 {
        Invalid = 0,
--- a/src/core/hle/service/audio/audren_u.cpp
+++ b/src/core/hle/service/audio/audren_u.cpp
@@ -47,7 +47,6 @@ public:

        // Start the audio event
        CoreTiming::ScheduleEvent(audio_ticks, audio_event);
-        voice_status_list.resize(worker_params.voice_count);
    }
    ~IAudioRenderer() {
        CoreTiming::UnscheduleEvent(audio_event, 0);
@@ -69,12 +68,6 @@ private:
                    buf.data() + sizeof(UpdateDataHeader) + config.behavior_size,
                    memory_pool_count * sizeof(MemoryPoolInfo));

-        std::vector<VoiceInfo> voice_info(worker_params.voice_count);
-        std::memcpy(voice_info.data(),
-                    buf.data() + sizeof(UpdateDataHeader) + config.behavior_size +
-                        config.memory_pools_size + config.voice_resource_size,
-                    worker_params.voice_count * sizeof(VoiceInfo));
-
        UpdateDataHeader response_data{worker_params};

        ASSERT(ctx.GetWriteBufferSize() == response_data.total_size);
@@ -87,27 +80,12 @@ private:
                memory_pool[i].state = MemoryPoolStates::Attached;
            else if (mem_pool_info[i].pool_state == MemoryPoolStates::RequestDetach)
                memory_pool[i].state = MemoryPoolStates::Detached;
+            else
+                memory_pool[i].state = mem_pool_info[i].pool_state;
        }
        std::memcpy(output.data() + sizeof(UpdateDataHeader), memory_pool.data(),
                    response_data.memory_pools_size);

-        for (unsigned i = 0; i < voice_info.size(); i++) {
-            if (voice_info[i].is_new) {
-                voice_status_list[i].played_sample_count = 0;
-                voice_status_list[i].wave_buffer_consumed = 0;
-            } else if (voice_info[i].play_state == (u8)PlayStates::Started) {
-                for (u32 buff_idx = 0; buff_idx < voice_info[i].wave_buffer_count; buff_idx++) {
-                    voice_status_list[i].played_sample_count +=
-                        (voice_info[i].wave_buffer[buff_idx].end_sample_offset -
-                         voice_info[i].wave_buffer[buff_idx].start_sample_offset) /
-                        2;
-                    voice_status_list[i].wave_buffer_consumed++;
-                }
-            }
-        }
-        std::memcpy(output.data() + sizeof(UpdateDataHeader) + response_data.memory_pools_size,
-                    voice_status_list.data(), response_data.voices_size);
-
        ctx.WriteBuffer(output);

        IPC::ResponseBuilder rb{ctx, 2};
@@ -152,11 +130,6 @@ private:
        Released = 0x6,
    };

-    enum class PlayStates : u8 {
-        Started = 0,
-        Stopped = 1,
-    };
-
    struct MemoryPoolEntry {
        MemoryPoolStates state;
        u32_le unknown_4;
@@ -181,9 +154,7 @@ private:
            behavior_size = 0xb0;
            memory_pools_size = (config.effect_count + (config.voice_count * 4)) * 0x10;
            voices_size = config.voice_count * 0x10;
-            voice_resource_size = 0x0;
            effects_size = config.effect_count * 0x10;
-            mixes_size = 0x0;
            sinks_size = config.sink_count * 0x20;
            performance_manager_size = 0x10;
            total_size = sizeof(UpdateDataHeader) + behavior_size + memory_pools_size +
@@ -204,69 +175,11 @@ private:
    };
    static_assert(sizeof(UpdateDataHeader) == 0x40, "UpdateDataHeader has wrong size");

-    struct BiquadFilter {
-        u8 enable;
-        INSERT_PADDING_BYTES(1);
-        s16_le numerator[3];
-        s16_le denominator[2];
-    };
-    static_assert(sizeof(BiquadFilter) == 0xc, "BiquadFilter has wrong size");
-
-    struct WaveBuffer {
-        u64_le buffer_addr;
-        u64_le buffer_sz;
-        s32_le start_sample_offset;
-        s32_le end_sample_offset;
-        u8 loop;
-        u8 end_of_stream;
-        u8 sent_to_server;
-        INSERT_PADDING_BYTES(5);
-        u64 context_addr;
-        u64 context_sz;
-        INSERT_PADDING_BYTES(8);
-    };
-    static_assert(sizeof(WaveBuffer) == 0x38, "WaveBuffer has wrong size");
-
-    struct VoiceInfo {
-        u32_le id;
-        u32_le node_id;
-        u8 is_new;
-        u8 is_in_use;
-        u8 play_state;
-        u8 sample_format;
-        u32_le sample_rate;
-        u32_le priority;
-        u32_le sorting_order;
-        u32_le channel_count;
-        float_le pitch;
-        float_le volume;
-        BiquadFilter biquad_filter[2];
-        u32_le wave_buffer_count;
-        u16_le wave_buffer_head;
-        INSERT_PADDING_BYTES(6);
-        u64_le additional_params_addr;
-        u64_le additional_params_sz;
-        u32_le mix_id;
-        u32_le splitter_info_id;
-        WaveBuffer wave_buffer[4];
-        u32_le voice_channel_resource_ids[6];
-        INSERT_PADDING_BYTES(24);
-    };
-    static_assert(sizeof(VoiceInfo) == 0x170, "VoiceInfo is wrong size");
-
-    struct VoiceOutStatus {
-        u64_le played_sample_count;
-        u32_le wave_buffer_consumed;
-        INSERT_PADDING_WORDS(1);
-    };
-    static_assert(sizeof(VoiceOutStatus) == 0x10, "VoiceOutStatus has wrong size");
-
    /// This is used to trigger the audio event callback.
    CoreTiming::EventType* audio_event;

    Kernel::SharedPtr<Kernel::Event> system_event;
    AudioRendererParameter worker_params;
-    std::vector<VoiceOutStatus> voice_status_list;
 };

 class IAudioDevice final : public ServiceFramework<IAudioDevice> {
--- a/src/core/hle/service/filesystem/fsp_srv.cpp
+++ b/src/core/hle/service/filesystem/fsp_srv.cpp
@@ -7,7 +7,6 @@
 #include "common/string_util.h"
 #include "core/core.h"
 #include "core/file_sys/directory.h"
-#include "core/file_sys/errors.h"
 #include "core/file_sys/filesystem.h"
 #include "core/file_sys/storage.h"
 #include "core/hle/ipc_helpers.h"
@@ -532,20 +531,12 @@ void FSP_SRV::CreateSaveData(Kernel::HLERequestContext& ctx) {
 void FSP_SRV::MountSaveData(Kernel::HLERequestContext& ctx) {
    LOG_WARNING(Service_FS, "(STUBBED) called");

-    // TODO(Subv): Read the input parameters and mount the requested savedata instead of always
-    // mounting the current process' savedata.
    FileSys::Path unused;
-    auto filesystem = OpenFileSystem(Type::SaveData, unused);
-
-    if (filesystem.Failed()) {
-        IPC::ResponseBuilder rb{ctx, 2, 0, 0};
-        rb.Push(ResultCode(ErrorModule::FS, FileSys::ErrCodes::SaveDataNotFound));
-        return;
-    }
+    auto filesystem = OpenFileSystem(Type::SaveData, unused).Unwrap();

    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<IFileSystem>(std::move(filesystem.Unwrap()));
+    rb.PushIpcInterface<IFileSystem>(std::move(filesystem));
 }

 void FSP_SRV::GetGlobalAccessLogMode(Kernel::HLERequestContext& ctx) {
--- a/src/core/hle/service/hid/hid.cpp
+++ b/src/core/hle/service/hid/hid.cpp
@@ -75,7 +75,7 @@ private:

        // Set up controllers as neon red+blue Joy-Con attached to console
        ControllerHeader& controller_header = mem.controllers[Controller_Handheld].header;
-        controller_header.type = ControllerType_Handheld;
+        controller_header.type = ControllerType_Handheld | ControllerType_JoyconPair;
        controller_header.single_colors_descriptor = ColorDesc_ColorsNonexistent;
        controller_header.right_color_body = JOYCON_BODY_NEON_RED;
        controller_header.right_color_buttons = JOYCON_BUTTONS_NEON_RED;
@@ -84,21 +84,23 @@ private:

        for (size_t controller = 0; controller < mem.controllers.size(); controller++) {
            for (int index = 0; index < HID_NUM_LAYOUTS; index++) {
+                // TODO(DarkLordZach): Is this layout/controller config actually invalid?
+                if (controller == Controller_Handheld && index == Layout_Single)
+                    continue;
+
                ControllerLayout& layout = mem.controllers[controller].layouts[index];
                layout.header.num_entries = HID_NUM_ENTRIES;
                layout.header.max_entry_index = HID_NUM_ENTRIES - 1;

                // HID shared memory stores the state of the past 17 samples in a circlular buffer,
                // each with a timestamp in number of samples since boot.
-                const ControllerInputEntry& last_entry = layout.entries[layout.header.latest_entry];
-
                layout.header.timestamp_ticks = CoreTiming::GetTicks();
                layout.header.latest_entry = (layout.header.latest_entry + 1) % HID_NUM_ENTRIES;

                ControllerInputEntry& entry = layout.entries[layout.header.latest_entry];
-                entry.timestamp = last_entry.timestamp + 1;
+                entry.timestamp++;
                // TODO(shinyquagsire23): Is this always identical to timestamp?
-                entry.timestamp_2 = entry.timestamp;
+                entry.timestamp_2++;

                // TODO(shinyquagsire23): More than just handheld input
                if (controller != Controller_Handheld)
--- a/src/core/hle/service/nifm/nifm.cpp
+++ b/src/core/hle/service/nifm/nifm.cpp
@@ -148,24 +148,6 @@ private:

        LOG_DEBUG(Service_NIFM, "called");
    }
-    void IsWirelessCommunicationEnabled(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_NIFM, "(STUBBED) called");
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u8>(0);
-    }
-    void IsEthernetCommunicationEnabled(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_NIFM, "(STUBBED) called");
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u8>(0);
-    }
-    void IsAnyInternetRequestAccepted(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_NIFM, "(STUBBED) called");
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u8>(0);
-    }
 };

 IGeneralService::IGeneralService() : ServiceFramework("IGeneralService") {
@@ -185,11 +167,11 @@ IGeneralService::IGeneralService() : ServiceFramework("IGeneralService") {
        {14, &IGeneralService::CreateTemporaryNetworkProfile, "CreateTemporaryNetworkProfile"},
        {15, nullptr, "GetCurrentIpConfigInfo"},
        {16, nullptr, "SetWirelessCommunicationEnabled"},
-        {17, &IGeneralService::IsWirelessCommunicationEnabled, "IsWirelessCommunicationEnabled"},
+        {17, nullptr, "IsWirelessCommunicationEnabled"},
        {18, nullptr, "GetInternetConnectionStatus"},
        {19, nullptr, "SetEthernetCommunicationEnabled"},
-        {20, &IGeneralService::IsEthernetCommunicationEnabled, "IsEthernetCommunicationEnabled"},
-        {21, &IGeneralService::IsAnyInternetRequestAccepted, "IsAnyInternetRequestAccepted"},
+        {20, nullptr, "IsEthernetCommunicationEnabled"},
+        {21, nullptr, "IsAnyInternetRequestAccepted"},
        {22, nullptr, "IsAnyForegroundRequestAccepted"},
        {23, nullptr, "PutToSleep"},
        {24, nullptr, "WakeUp"},
--- a/src/core/hle/service/nvdrv/devices/nvhost_ctrl.cpp
+++ b/src/core/hle/service/nvdrv/devices/nvhost_ctrl.cpp
@@ -29,9 +29,24 @@ u32 nvhost_ctrl::ioctl(Ioctl command, const std::vector<u8>& input, std::vector<
 u32 nvhost_ctrl::NvOsGetConfigU32(const std::vector<u8>& input, std::vector<u8>& output) {
    IocGetConfigParams params{};
    std::memcpy(&params, input.data(), sizeof(params));
-    LOG_TRACE(Service_NVDRV, "called, setting={}!{}", params.domain_str.data(),
+    LOG_DEBUG(Service_NVDRV, "called, setting={}!{}", params.domain_str.data(),
              params.param_str.data());
-    return 0x30006; // Returns error on production mode
+
+    if (!strcmp(params.domain_str.data(), "nv")) {
+        if (!strcmp(params.param_str.data(), "NV_MEMORY_PROFILER")) {
+            params.config_str[0] = '0';
+        } else if (!strcmp(params.param_str.data(), "NVN_THROUGH_OPENGL")) {
+            params.config_str[0] = '0';
+        } else if (!strcmp(params.param_str.data(), "NVRM_GPU_PREVENT_USE")) {
+            params.config_str[0] = '0';
+        } else {
+            params.config_str[0] = '\0';
+        }
+    } else {
+        UNIMPLEMENTED(); // unknown domain? Only nv has been seen so far on hardware
+    }
+    std::memcpy(output.data(), &params, sizeof(params));
+    return 0;
 }

 u32 nvhost_ctrl::IocCtrlEventWait(const std::vector<u8>& input, std::vector<u8>& output,
--- a/src/core/loader/deconstructed_rom_directory.cpp
+++ b/src/core/loader/deconstructed_rom_directory.cpp
@@ -9,7 +9,6 @@
 #include "common/logging/log.h"
 #include "common/string_util.h"
 #include "core/file_sys/romfs_factory.h"
-#include "core/gdbstub/gdbstub.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/resource_limit.h"
 #include "core/hle/service/filesystem/filesystem.h"
@@ -134,8 +133,6 @@ ResultStatus AppLoader_DeconstructedRomDirectory::Load(
        next_load_addr = AppLoader_NSO::LoadModule(path, load_addr);
        if (next_load_addr) {
            LOG_DEBUG(Loader, "loaded module {} @ 0x{:X}", module, load_addr);
-            // Register module with GDBStub
-            GDBStub::RegisterModule(module, load_addr, next_load_addr - 1, false);
        } else {
            next_load_addr = load_addr;
        }
--- a/src/core/loader/nca.cpp
+++ b/src/core/loader/nca.cpp
@@ -7,12 +7,10 @@
 #include "common/common_funcs.h"
 #include "common/file_util.h"
 #include "common/logging/log.h"
-#include "common/string_util.h"
 #include "common/swap.h"
 #include "core/core.h"
 #include "core/file_sys/program_metadata.h"
 #include "core/file_sys/romfs_factory.h"
-#include "core/gdbstub/gdbstub.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/resource_limit.h"
 #include "core/hle/service/filesystem/filesystem.h"
@@ -261,8 +259,6 @@ ResultStatus AppLoader_NCA::Load(Kernel::SharedPtr<Kernel::Process>& process) {
        next_load_addr = AppLoader_NSO::LoadModule(module, nca->GetExeFsFile(module), load_addr);
        if (next_load_addr) {
            LOG_DEBUG(Loader, "loaded module {} @ 0x{:X}", module, load_addr);
-            // Register module with GDBStub
-            GDBStub::RegisterModule(module, load_addr, next_load_addr - 1, false);
        } else {
            next_load_addr = load_addr;
        }
--- a/src/core/loader/nro.cpp
+++ b/src/core/loader/nro.cpp
@@ -9,7 +9,6 @@
 #include "common/logging/log.h"
 #include "common/swap.h"
 #include "core/core.h"
-#include "core/gdbstub/gdbstub.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/resource_limit.h"
 #include "core/loader/nro.h"
@@ -116,9 +115,6 @@ bool AppLoader_NRO::LoadNro(const std::string& path, VAddr load_base) {
    codeset->memory = std::make_shared<std::vector<u8>>(std::move(program_image));
    Core::CurrentProcess()->LoadModule(codeset, load_base);

-    // Register module with GDBStub
-    GDBStub::RegisterModule(codeset->name, load_base, load_base);
-
    return true;
 }

--- a/src/core/loader/nso.cpp
+++ b/src/core/loader/nso.cpp
@@ -10,7 +10,6 @@
 #include "common/logging/log.h"
 #include "common/swap.h"
 #include "core/core.h"
-#include "core/gdbstub/gdbstub.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/resource_limit.h"
 #include "core/loader/nso.h"
@@ -148,9 +147,6 @@ VAddr AppLoader_NSO::LoadModule(const std::string& name, const std::vector<u8>&
    codeset->memory = std::make_shared<std::vector<u8>>(std::move(program_image));
    Core::CurrentProcess()->LoadModule(codeset, load_base);

-    // Register module with GDBStub
-    GDBStub::RegisterModule(codeset->name, load_base, load_base);
-
    return load_base + image_size;
 }

--- a/src/video_core/engines/maxwell_3d.cpp
+++ b/src/video_core/engines/maxwell_3d.cpp
@@ -126,10 +126,6 @@ void Maxwell3D::WriteReg(u32 method, u32 value, u32 remaining_params) {
        DrawArrays();
        break;
    }
-    case MAXWELL3D_REG_INDEX(clear_buffers): {
-        ProcessClearBuffers();
-        break;
-    }
    case MAXWELL3D_REG_INDEX(query.query_get): {
        ProcessQueryGet();
        break;
@@ -398,12 +394,25 @@ u32 Maxwell3D::GetRegisterValue(u32 method) const {
    return regs.reg_array[method];
 }

-void Maxwell3D::ProcessClearBuffers() {
-    ASSERT(regs.clear_buffers.R == regs.clear_buffers.G &&
-           regs.clear_buffers.R == regs.clear_buffers.B &&
-           regs.clear_buffers.R == regs.clear_buffers.A);
+bool Maxwell3D::IsShaderStageEnabled(Regs::ShaderStage stage) const {
+    // The Vertex stage is always enabled.
+    if (stage == Regs::ShaderStage::Vertex)
+        return true;

-    VideoCore::g_renderer->Rasterizer()->Clear();
+    switch (stage) {
+    case Regs::ShaderStage::TesselationControl:
+        return regs.shader_config[static_cast<size_t>(Regs::ShaderProgram::TesselationControl)]
+                   .enable != 0;
+    case Regs::ShaderStage::TesselationEval:
+        return regs.shader_config[static_cast<size_t>(Regs::ShaderProgram::TesselationEval)]
+                   .enable != 0;
+    case Regs::ShaderStage::Geometry:
+        return regs.shader_config[static_cast<size_t>(Regs::ShaderProgram::Geometry)].enable != 0;
+    case Regs::ShaderStage::Fragment:
+        return regs.shader_config[static_cast<size_t>(Regs::ShaderProgram::Fragment)].enable != 0;
+    }
+
+    UNREACHABLE();
 }

 } // namespace Engines
--- a/src/video_core/engines/maxwell_3d.h
+++ b/src/video_core/engines/maxwell_3d.h
@@ -281,26 +281,14 @@ public:
        };

        enum class ComparisonOp : u32 {
-            // These values are used by Nouveau and most games, they correspond to the OpenGL token
-            // values for these operations.
-            Never = 0x200,
-            Less = 0x201,
-            Equal = 0x202,
-            LessEqual = 0x203,
-            Greater = 0x204,
-            NotEqual = 0x205,
-            GreaterEqual = 0x206,
-            Always = 0x207,
-
-            // These values are used by some games, they seem to be NV04 values.
-            NeverOld = 1,
-            LessOld = 2,
-            EqualOld = 3,
-            LessEqualOld = 4,
-            GreaterOld = 5,
-            NotEqualOld = 6,
-            GreaterEqualOld = 7,
-            AlwaysOld = 8,
+            Never = 0,
+            Less = 1,
+            Equal = 2,
+            LessEqual = 3,
+            Greater = 4,
+            NotEqual = 5,
+            GreaterEqual = 6,
+            Always = 7,
        };

        struct Cull {
@@ -379,14 +367,6 @@ public:
            }
        };

-        bool IsShaderConfigEnabled(size_t index) const {
-            // The VertexB is always enabled.
-            if (index == static_cast<size_t>(Regs::ShaderProgram::VertexB)) {
-                return true;
-            }
-            return shader_config[index].enable != 0;
-        }
-
        union {
            struct {
                INSERT_PADDING_WORDS(0x45);
@@ -456,12 +436,7 @@ public:
                    u32 count;
                } vertex_buffer;

-                INSERT_PADDING_WORDS(1);
-
-                float clear_color[4];
-                float clear_depth;
-
-                INSERT_PADDING_WORDS(0x93);
+                INSERT_PADDING_WORDS(0x99);

                struct {
                    u32 address_high;
@@ -498,11 +473,9 @@ public:

                u32 depth_write_enabled;

-                INSERT_PADDING_WORDS(0x7);
+                INSERT_PADDING_WORDS(0x8);

-                u32 d3d_cull_mode;
-
-                ComparisonOp depth_test_func;
+                BitField<0, 3, ComparisonOp> depth_test_func;

                INSERT_PADDING_WORDS(0xB);

@@ -520,13 +493,7 @@ public:
                    u32 enable[NumRenderTargets];
                } blend;

-                INSERT_PADDING_WORDS(0xB);
-
-                union {
-                    BitField<4, 1, u32> triangle_rast_flip;
-                } screen_y_control;
-
-                INSERT_PADDING_WORDS(0x21);
+                INSERT_PADDING_WORDS(0x2D);

                u32 vb_element_base;

@@ -556,12 +523,7 @@ public:
                    }
                } tic;

-                INSERT_PADDING_WORDS(0x21);
-
-                union {
-                    BitField<2, 1, u32> coord_origin;
-                    BitField<3, 10, u32> enable;
-                } point_coord_replace;
+                INSERT_PADDING_WORDS(0x22);

                struct {
                    u32 code_address_high;
@@ -622,21 +584,7 @@ public:

                Cull cull;

-                INSERT_PADDING_WORDS(0x2B);
-
-                union {
-                    u32 raw;
-                    BitField<0, 1, u32> Z;
-                    BitField<1, 1, u32> S;
-                    BitField<2, 1, u32> R;
-                    BitField<3, 1, u32> G;
-                    BitField<4, 1, u32> B;
-                    BitField<5, 1, u32> A;
-                    BitField<6, 4, u32> RT;
-                    BitField<10, 11, u32> layer;
-                } clear_buffers;
-
-                INSERT_PADDING_WORDS(0x4B);
+                INSERT_PADDING_WORDS(0x77);

                struct {
                    u32 query_address_high;
@@ -788,6 +736,9 @@ public:
    /// Returns the texture information for a specific texture in a specific shader stage.
    Texture::FullTextureInfo GetStageTexture(Regs::ShaderStage stage, size_t offset) const;

+    /// Returns whether the specified shader stage is enabled or not.
+    bool IsShaderStageEnabled(Regs::ShaderStage stage) const;
+
 private:
    std::unordered_map<u32, std::vector<u32>> uploaded_macros;

@@ -815,9 +766,6 @@ private:
    /// Handles writes to the macro uploading registers.
    void ProcessMacroUpload(u32 data);

-    /// Handles a write to the CLEAR_BUFFERS register.
-    void ProcessClearBuffers();
-
    /// Handles a write to the QUERY_GET register.
    void ProcessQueryGet();

@@ -840,27 +788,21 @@ ASSERT_REG_POSITION(rt, 0x200);
 ASSERT_REG_POSITION(viewport_transform[0], 0x280);
 ASSERT_REG_POSITION(viewport, 0x300);
 ASSERT_REG_POSITION(vertex_buffer, 0x35D);
-ASSERT_REG_POSITION(clear_color[0], 0x360);
-ASSERT_REG_POSITION(clear_depth, 0x364);
 ASSERT_REG_POSITION(zeta, 0x3F8);
 ASSERT_REG_POSITION(vertex_attrib_format[0], 0x458);
 ASSERT_REG_POSITION(rt_control, 0x487);
 ASSERT_REG_POSITION(depth_test_enable, 0x4B3);
 ASSERT_REG_POSITION(independent_blend_enable, 0x4B9);
 ASSERT_REG_POSITION(depth_write_enabled, 0x4BA);
-ASSERT_REG_POSITION(d3d_cull_mode, 0x4C2);
 ASSERT_REG_POSITION(depth_test_func, 0x4C3);
 ASSERT_REG_POSITION(blend, 0x4CF);
-ASSERT_REG_POSITION(screen_y_control, 0x4EB);
 ASSERT_REG_POSITION(vb_element_base, 0x50D);
 ASSERT_REG_POSITION(tsc, 0x557);
 ASSERT_REG_POSITION(tic, 0x55D);
-ASSERT_REG_POSITION(point_coord_replace, 0x581);
 ASSERT_REG_POSITION(code_address, 0x582);
 ASSERT_REG_POSITION(draw, 0x585);
 ASSERT_REG_POSITION(index_array, 0x5F2);
 ASSERT_REG_POSITION(cull, 0x646);
-ASSERT_REG_POSITION(clear_buffers, 0x674);
 ASSERT_REG_POSITION(query, 0x6C0);
 ASSERT_REG_POSITION(vertex_array[0], 0x700);
 ASSERT_REG_POSITION(independent_blend, 0x780);
--- a/src/video_core/engines/shader_bytecode.h
+++ b/src/video_core/engines/shader_bytecode.h
@@ -142,7 +142,6 @@ enum class PredCondition : u64 {
    GreaterThan = 4,
    NotEqual = 5,
    GreaterEqual = 6,
-    LessThanWithNan = 9,
    NotEqualWithNan = 13,
    // TODO(Subv): Other condition types
 };
@@ -195,18 +194,6 @@ enum class UniformType : u64 {
    Double = 5,
 };

-enum class IMinMaxExchange : u64 {
-    None = 0,
-    XLo = 1,
-    XMed = 2,
-    XHi = 3,
-};
-
-enum class FlowCondition : u64 {
-    Always = 0xF,
-    Fcsm_Tr = 0x1C, // TODO(bunnei): What is this used for?
-};
-
 union Instruction {
    Instruction& operator=(const Instruction& instr) {
        value = instr.value;
@@ -291,25 +278,11 @@ union Instruction {
        BitField<49, 1, u64> negate_a;
    } alu_integer;

-    union {
-        BitField<39, 3, u64> pred;
-        BitField<42, 1, u64> negate_pred;
-        BitField<43, 2, IMinMaxExchange> exchange;
-        BitField<48, 1, u64> is_signed;
-    } imnmx;
-
    union {
        BitField<54, 1, u64> saturate;
        BitField<56, 1, u64> negate_a;
    } iadd32i;

-    union {
-        BitField<53, 1, u64> negate_b;
-        BitField<54, 1, u64> abs_a;
-        BitField<56, 1, u64> negate_a;
-        BitField<57, 1, u64> abs_b;
-    } fadd32i;
-
    union {
        BitField<20, 8, u64> shift_position;
        BitField<28, 8, u64> shift_length;
@@ -321,10 +294,6 @@ union Instruction {
        }
    } bfe;

-    union {
-        BitField<0, 5, FlowCondition> cond;
-    } flow;
-
    union {
        BitField<48, 1, u64> negate_b;
        BitField<49, 1, u64> negate_c;
@@ -359,19 +328,6 @@ union Instruction {
        BitField<49, 3, PredCondition> cond;
    } isetp;

-    union {
-        BitField<0, 3, u64> pred0;
-        BitField<3, 3, u64> pred3;
-        BitField<12, 3, u64> pred12;
-        BitField<15, 1, u64> neg_pred12;
-        BitField<24, 2, PredOperation> cond;
-        BitField<29, 3, u64> pred29;
-        BitField<32, 1, u64> neg_pred29;
-        BitField<39, 3, u64> pred39;
-        BitField<42, 1, u64> neg_pred39;
-        BitField<45, 2, PredOperation> op;
-    } psetp;
-
    union {
        BitField<39, 3, u64> pred39;
        BitField<42, 1, u64> neg_pred;
@@ -482,8 +438,6 @@ public:
    enum class Id {
        KIL,
        SSY,
-        SYNC,
-        DEPBAR,
        BFE_C,
        BFE_R,
        BFE_IMM,
@@ -504,7 +458,6 @@ public:
        FADD_C,
        FADD_R,
        FADD_IMM,
-        FADD32I,
        FMUL_C,
        FMUL_R,
        FMUL_IMM,
@@ -581,7 +534,6 @@ public:
        Shift,
        Ffma,
        Flow,
-        Synch,
        Memory,
        FloatSet,
        FloatSetPredicate,
@@ -686,25 +638,22 @@ private:
            INST("111000110011----", Id::KIL, Type::Flow, "KIL"),
            INST("111000101001----", Id::SSY, Type::Flow, "SSY"),
            INST("111000100100----", Id::BRA, Type::Flow, "BRA"),
-            INST("1111000011110---", Id::DEPBAR, Type::Synch, "DEPBAR"),
-            INST("1111000011111---", Id::SYNC, Type::Synch, "SYNC"),
            INST("1110111111011---", Id::LD_A, Type::Memory, "LD_A"),
            INST("1110111110010---", Id::LD_C, Type::Memory, "LD_C"),
            INST("1110111111110---", Id::ST_A, Type::Memory, "ST_A"),
-            INST("110000----111---", Id::TEX, Type::Memory, "TEX"),
+            INST("1100000000111---", Id::TEX, Type::Memory, "TEX"),
            INST("1101111101001---", Id::TEXQ, Type::Memory, "TEXQ"),
            INST("1101100---------", Id::TEXS, Type::Memory, "TEXS"),
            INST("1101101---------", Id::TLDS, Type::Memory, "TLDS"),
            INST("111000110000----", Id::EXIT, Type::Trivial, "EXIT"),
            INST("11100000--------", Id::IPA, Type::Trivial, "IPA"),
-            INST("0011001-1-------", Id::FFMA_IMM, Type::Ffma, "FFMA_IMM"),
+            INST("001100101-------", Id::FFMA_IMM, Type::Ffma, "FFMA_IMM"),
            INST("010010011-------", Id::FFMA_CR, Type::Ffma, "FFMA_CR"),
            INST("010100011-------", Id::FFMA_RC, Type::Ffma, "FFMA_RC"),
            INST("010110011-------", Id::FFMA_RR, Type::Ffma, "FFMA_RR"),
            INST("0100110001011---", Id::FADD_C, Type::Arithmetic, "FADD_C"),
            INST("0101110001011---", Id::FADD_R, Type::Arithmetic, "FADD_R"),
            INST("0011100-01011---", Id::FADD_IMM, Type::Arithmetic, "FADD_IMM"),
-            INST("000010----------", Id::FADD32I, Type::ArithmeticImmediate, "FADD32I"),
            INST("0100110001101---", Id::FMUL_C, Type::Arithmetic, "FMUL_C"),
            INST("0101110001101---", Id::FMUL_R, Type::Arithmetic, "FMUL_R"),
            INST("0011100-01101---", Id::FMUL_IMM, Type::Arithmetic, "FMUL_IMM"),
@@ -733,9 +682,9 @@ private:
            INST("0100110001100---", Id::FMNMX_C, Type::Arithmetic, "FMNMX_C"),
            INST("0101110001100---", Id::FMNMX_R, Type::Arithmetic, "FMNMX_R"),
            INST("0011100-01100---", Id::FMNMX_IMM, Type::Arithmetic, "FMNMX_IMM"),
-            INST("0100110000100---", Id::IMNMX_C, Type::ArithmeticInteger, "IMNMX_C"),
-            INST("0101110000100---", Id::IMNMX_R, Type::ArithmeticInteger, "IMNMX_R"),
-            INST("0011100-00100---", Id::IMNMX_IMM, Type::ArithmeticInteger, "IMNMX_IMM"),
+            INST("0100110000100---", Id::IMNMX_C, Type::Arithmetic, "FMNMX_IMM"),
+            INST("0101110000100---", Id::IMNMX_R, Type::Arithmetic, "FMNMX_IMM"),
+            INST("0011100-00100---", Id::IMNMX_IMM, Type::Arithmetic, "FMNMX_IMM"),
            INST("0100110000000---", Id::BFE_C, Type::Bfe, "BFE_C"),
            INST("0101110000000---", Id::BFE_R, Type::Bfe, "BFE_R"),
            INST("0011100-00000---", Id::BFE_IMM, Type::Bfe, "BFE_IMM"),
--- a/src/video_core/rasterizer_interface.h
+++ b/src/video_core/rasterizer_interface.h
@@ -19,9 +19,6 @@ public:
    /// Draw the current batch of vertex arrays
    virtual void DrawArrays() = 0;

-    /// Clear the current framebuffer
-    virtual void Clear() = 0;
-
    /// Notify rasterizer that the specified Maxwell register has been changed
    virtual void NotifyMaxwellRegisterChanged(u32 method) = 0;

--- a/src/video_core/renderer_opengl/gl_rasterizer.cpp
+++ b/src/video_core/renderer_opengl/gl_rasterizer.cpp
@@ -181,19 +181,6 @@ std::pair<u8*, GLintptr> RasterizerOpenGL::SetupVertexArrays(u8* array_ptr,
    return {array_ptr, buffer_offset};
 }

-static GLShader::ProgramCode GetShaderProgramCode(Maxwell::ShaderProgram program) {
-    auto& gpu = Core::System().GetInstance().GPU().Maxwell3D();
-
-    // Fetch program code from memory
-    GLShader::ProgramCode program_code;
-    auto& shader_config = gpu.regs.shader_config[static_cast<size_t>(program)];
-    const u64 gpu_address{gpu.regs.code_address.CodeAddress() + shader_config.offset};
-    const boost::optional<VAddr> cpu_address{gpu.memory_manager.GpuToCpuAddress(gpu_address)};
-    Memory::ReadBlock(*cpu_address, program_code.data(), program_code.size() * sizeof(u64));
-
-    return program_code;
-}
-
 void RasterizerOpenGL::SetupShaders(u8* buffer_ptr, GLintptr buffer_offset) {
    // Helper function for uploading uniform data
    const auto copy_buffer = [&](GLuint handle, GLintptr offset, GLsizeiptr size) {
@@ -206,23 +193,26 @@ void RasterizerOpenGL::SetupShaders(u8* buffer_ptr, GLintptr buffer_offset) {
    };

    auto& gpu = Core::System().GetInstance().GPU().Maxwell3D();
+    ASSERT_MSG(!gpu.regs.shader_config[0].enable, "VertexA is unsupported!");

    // Next available bindpoints to use when uploading the const buffers and textures to the GLSL
    // shaders. The constbuffer bindpoint starts after the shader stage configuration bind points.
    u32 current_constbuffer_bindpoint = uniform_buffers.size();
    u32 current_texture_bindpoint = 0;

-    for (size_t index = 0; index < Maxwell::MaxShaderProgram; ++index) {
+    for (unsigned index = 1; index < Maxwell::MaxShaderProgram; ++index) {
        auto& shader_config = gpu.regs.shader_config[index];
        const Maxwell::ShaderProgram program{static_cast<Maxwell::ShaderProgram>(index)};

+        const auto& stage = index - 1; // Stage indices are 0 - 5
+
+        const bool is_enabled = gpu.IsShaderStageEnabled(static_cast<Maxwell::ShaderStage>(stage));
+
        // Skip stages that are not enabled
-        if (!gpu.regs.IsShaderConfigEnabled(index)) {
+        if (!is_enabled) {
            continue;
        }

-        const size_t stage{index == 0 ? 0 : index - 1}; // Stage indices are 0 - 5
-
        GLShader::MaxwellUniformData ubo{};
        ubo.SetFromRegs(gpu.state.shader_stages[stage]);
        std::memcpy(buffer_ptr, &ubo, sizeof(ubo));
@@ -238,21 +228,16 @@ void RasterizerOpenGL::SetupShaders(u8* buffer_ptr, GLintptr buffer_offset) {
        buffer_ptr += sizeof(GLShader::MaxwellUniformData);
        buffer_offset += sizeof(GLShader::MaxwellUniformData);

-        GLShader::ShaderSetup setup{GetShaderProgramCode(program)};
+        // Fetch program code from memory
+        GLShader::ProgramCode program_code;
+        const u64 gpu_address{gpu.regs.code_address.CodeAddress() + shader_config.offset};
+        const boost::optional<VAddr> cpu_address{gpu.memory_manager.GpuToCpuAddress(gpu_address)};
+        Memory::ReadBlock(*cpu_address, program_code.data(), program_code.size() * sizeof(u64));
+        GLShader::ShaderSetup setup{std::move(program_code)};
+
        GLShader::ShaderEntries shader_resources;

        switch (program) {
-        case Maxwell::ShaderProgram::VertexA: {
-            // VertexB is always enabled, so when VertexA is enabled, we have two vertex shaders.
-            // Conventional HW does not support this, so we combine VertexA and VertexB into one
-            // stage here.
-            setup.SetProgramB(GetShaderProgramCode(Maxwell::ShaderProgram::VertexB));
-            GLShader::MaxwellVSConfig vs_config{setup};
-            shader_resources =
-                shader_program_manager->UseProgrammableVertexShader(vs_config, setup);
-            break;
-        }
-
        case Maxwell::ShaderProgram::VertexB: {
            GLShader::MaxwellVSConfig vs_config{setup};
            shader_resources =
@@ -283,12 +268,6 @@ void RasterizerOpenGL::SetupShaders(u8* buffer_ptr, GLintptr buffer_offset) {
        current_texture_bindpoint =
            SetupTextures(static_cast<Maxwell::ShaderStage>(stage), gl_stage_program,
                          current_texture_bindpoint, shader_resources.texture_samplers);
-
-        // When VertexA is enabled, we have dual vertex shaders
-        if (program == Maxwell::ShaderProgram::VertexA) {
-            // VertexB was combined with VertexA, so we skip the VertexB iteration
-            index++;
-        }
    }

    shader_program_manager->UseTrivialGeometryShader();
@@ -318,13 +297,22 @@ bool RasterizerOpenGL::AccelerateDrawBatch(bool is_indexed) {
    return true;
 }

-std::pair<Surface, Surface> RasterizerOpenGL::ConfigureFramebuffers(bool using_color_fb,
-                                                                    bool using_depth_fb) {
+void RasterizerOpenGL::DrawArrays() {
+    if (accelerate_draw == AccelDraw::Disabled)
+        return;
+
+    MICROPROFILE_SCOPE(OpenGL_Drawing);
    const auto& regs = Core::System().GetInstance().GPU().Maxwell3D().regs;

+    // Sync the depth test state before configuring the framebuffer surfaces.
+    SyncDepthTestState();
+
    // TODO(bunnei): Implement this
    const bool has_stencil = false;

+    const bool using_color_fb = true;
+    const bool using_depth_fb = regs.zeta.Address() != 0;
+
    const MathUtil::Rectangle<s32> viewport_rect{regs.viewport_transform[0].GetRect()};

    const bool write_color_fb =
@@ -356,6 +344,11 @@ std::pair<Surface, Surface> RasterizerOpenGL::ConfigureFramebuffers(bool using_c
    BindFramebufferSurfaces(color_surface, depth_surface, has_stencil);

    SyncViewport(surfaces_rect);
+    SyncBlendState();
+    SyncCullMode();
+
+    // TODO(bunnei): Sync framebuffer_scale uniform here
+    // TODO(bunnei): Sync scissorbox uniform(s) here

    // Viewport can have negative offsets or larger dimensions than our framebuffer sub-rect. Enable
    // scissor test to prevent drawing outside of the framebuffer region
@@ -366,74 +359,6 @@ std::pair<Surface, Surface> RasterizerOpenGL::ConfigureFramebuffers(bool using_c
    state.scissor.height = draw_rect.GetHeight();
    state.Apply();

-    // Only return the surface to be marked as dirty if writing to it is enabled.
-    return std::make_pair(write_color_fb ? color_surface : nullptr,
-                          write_depth_fb ? depth_surface : nullptr);
-}
-
-void RasterizerOpenGL::Clear() {
-    const auto& regs = Core::System().GetInstance().GPU().Maxwell3D().regs;
-
-    bool use_color_fb = false;
-    bool use_depth_fb = false;
-
-    GLbitfield clear_mask = 0;
-    if (regs.clear_buffers.R && regs.clear_buffers.G && regs.clear_buffers.B &&
-        regs.clear_buffers.A) {
-        clear_mask |= GL_COLOR_BUFFER_BIT;
-        use_color_fb = true;
-    }
-    if (regs.clear_buffers.Z) {
-        clear_mask |= GL_DEPTH_BUFFER_BIT;
-        use_depth_fb = true;
-
-        // Always enable the depth write when clearing the depth buffer. The depth write mask is
-        // ignored when clearing the buffer in the Switch, but OpenGL obeys it so we set it to true.
-        state.depth.test_enabled = true;
-        state.depth.write_mask = GL_TRUE;
-        state.depth.test_func = GL_ALWAYS;
-        state.Apply();
-    }
-
-    if (clear_mask == 0)
-        return;
-
-    auto [dirty_color_surface, dirty_depth_surface] =
-        ConfigureFramebuffers(use_color_fb, use_depth_fb);
-
-    // TODO(Subv): Support clearing only partial colors.
-    glClearColor(regs.clear_color[0], regs.clear_color[1], regs.clear_color[2],
-                 regs.clear_color[3]);
-    glClearDepth(regs.clear_depth);
-
-    glClear(clear_mask);
-
-    // Mark framebuffer surfaces as dirty
-    if (dirty_color_surface != nullptr) {
-        res_cache.MarkSurfaceAsDirty(dirty_color_surface);
-    }
-    if (dirty_depth_surface != nullptr) {
-        res_cache.MarkSurfaceAsDirty(dirty_depth_surface);
-    }
-}
-
-void RasterizerOpenGL::DrawArrays() {
-    if (accelerate_draw == AccelDraw::Disabled)
-        return;
-
-    MICROPROFILE_SCOPE(OpenGL_Drawing);
-    const auto& regs = Core::System().GetInstance().GPU().Maxwell3D().regs;
-
-    auto [dirty_color_surface, dirty_depth_surface] =
-        ConfigureFramebuffers(true, regs.zeta.Address() != 0);
-
-    SyncDepthTestState();
-    SyncBlendState();
-    SyncCullMode();
-
-    // TODO(bunnei): Sync framebuffer_scale uniform here
-    // TODO(bunnei): Sync scissorbox uniform(s) here
-
    // Draw the vertex batch
    const bool is_indexed = accelerate_draw == AccelDraw::Indexed;
    const u64 index_buffer_size{regs.index_array.count * regs.index_array.FormatSizeInBytes()};
@@ -514,11 +439,11 @@ void RasterizerOpenGL::DrawArrays() {
    state.Apply();

    // Mark framebuffer surfaces as dirty
-    if (dirty_color_surface != nullptr) {
-        res_cache.MarkSurfaceAsDirty(dirty_color_surface);
+    if (color_surface != nullptr && write_color_fb) {
+        res_cache.MarkSurfaceAsDirty(color_surface);
    }
-    if (dirty_depth_surface != nullptr) {
-        res_cache.MarkSurfaceAsDirty(dirty_depth_surface);
+    if (depth_surface != nullptr && write_depth_fb) {
+        res_cache.MarkSurfaceAsDirty(depth_surface);
    }
 }

@@ -631,6 +556,9 @@ u32 RasterizerOpenGL::SetupConstBuffers(Maxwell::ShaderStage stage, GLuint progr
    auto& gpu = Core::System::GetInstance().GPU();
    auto& maxwell3d = gpu.Get3DEngine();

+    ASSERT_MSG(maxwell3d.IsShaderStageEnabled(stage),
+               "Attempted to upload constbuffer of disabled shader stage");
+
    // Reset all buffer draw state for this stage.
    for (auto& buffer : state.draw.const_buffers[static_cast<size_t>(stage)]) {
        buffer.bindpoint = 0;
@@ -697,6 +625,9 @@ u32 RasterizerOpenGL::SetupTextures(Maxwell::ShaderStage stage, GLuint program,
    auto& gpu = Core::System::GetInstance().GPU();
    auto& maxwell3d = gpu.Get3DEngine();

+    ASSERT_MSG(maxwell3d.IsShaderStageEnabled(stage),
+               "Attempted to upload textures of disabled shader stage");
+
    ASSERT_MSG(current_unit + entries.size() <= std::size(state.texture_units),
               "Exceeded the number of active textures.");

@@ -706,10 +637,7 @@ u32 RasterizerOpenGL::SetupTextures(Maxwell::ShaderStage stage, GLuint program,

        // Bind the uniform to the sampler.
        GLint uniform = glGetUniformLocation(program, entry.GetName().c_str());
-        if (uniform == -1) {
-            continue;
-        }
-
+        ASSERT(uniform != -1);
        glProgramUniform1i(program, uniform, current_bindpoint);

        const auto texture = maxwell3d.GetStageTexture(entry.GetStage(), entry.GetOffset());
@@ -794,19 +722,6 @@ void RasterizerOpenGL::SyncCullMode() {
    if (state.cull.enabled) {
        state.cull.front_face = MaxwellToGL::FrontFace(regs.cull.front_face);
        state.cull.mode = MaxwellToGL::CullFace(regs.cull.cull_face);
-
-        const bool flip_triangles{regs.screen_y_control.triangle_rast_flip == 0 ||
-                                  regs.viewport_transform[0].scale_y < 0.0f};
-
-        // If the GPU is configured to flip the rasterized triangles, then we need to flip the
-        // notion of front and back. Note: We flip the triangles when the value of the register is 0
-        // because OpenGL already does it for us.
-        if (flip_triangles) {
-            if (state.cull.front_face == GL_CCW)
-                state.cull.front_face = GL_CW;
-            else if (state.cull.front_face == GL_CW)
-                state.cull.front_face = GL_CCW;
-        }
    }
 }

--- a/src/video_core/renderer_opengl/gl_rasterizer.h
+++ b/src/video_core/renderer_opengl/gl_rasterizer.h
@@ -7,7 +7,6 @@
 #include <array>
 #include <cstddef>
 #include <memory>
-#include <utility>
 #include <vector>
 #include <glad/glad.h>
 #include "common/common_types.h"
@@ -29,7 +28,6 @@ public:
    ~RasterizerOpenGL() override;

    void DrawArrays() override;
-    void Clear() override;
    void NotifyMaxwellRegisterChanged(u32 method) override;
    void FlushAll() override;
    void FlushRegion(Tegra::GPUVAddr addr, u64 size) override;
@@ -83,10 +81,6 @@ private:
        u32 border_color_a;
    };

-    /// Configures the color and depth framebuffer states and returns the dirty <Color, Depth>
-    /// surfaces if writing was enabled.
-    std::pair<Surface, Surface> ConfigureFramebuffers(bool using_color_fb, bool using_depth_fb);
-
    /// Binds the framebuffer color and depth surface
    void BindFramebufferSurfaces(const Surface& color_surface, const Surface& depth_surface,
                                 bool has_stencil);
--- a/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp
+++ b/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp
@@ -65,25 +65,6 @@ struct FormatTuple {
    return params;
 }

-/*static*/ SurfaceParams SurfaceParams::CreateForDepthBuffer(
-    const Tegra::Engines::Maxwell3D::Regs::RenderTargetConfig& config, Tegra::GPUVAddr zeta_address,
-    Tegra::DepthFormat format) {
-
-    SurfaceParams params{};
-    params.addr = zeta_address;
-    params.is_tiled = true;
-    params.block_height = Tegra::Texture::TICEntry::DefaultBlockHeight;
-    params.pixel_format = PixelFormatFromDepthFormat(format);
-    params.component_type = ComponentTypeFromDepthFormat(format);
-    params.type = GetFormatType(params.pixel_format);
-    params.size_in_bytes = params.SizeInBytes();
-    params.width = config.width;
-    params.height = config.height;
-    params.unaligned_height = config.height;
-    params.size_in_bytes = params.SizeInBytes();
-    return params;
-}
-
 static constexpr std::array<FormatTuple, SurfaceParams::MaxPixelFormat> tex_format_tuples = {{
    {GL_RGBA8, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, ComponentType::UNorm, false}, // ABGR8
    {GL_RGB, GL_RGB, GL_UNSIGNED_SHORT_5_6_5_REV, ComponentType::UNorm, false},    // B5G6R5
@@ -102,16 +83,11 @@ static constexpr std::array<FormatTuple, SurfaceParams::MaxPixelFormat> tex_form
    {GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
     true},                                                                                 // DXT45
    {GL_COMPRESSED_RED_RGTC1, GL_RED, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm, true}, // DXN1
-    {GL_COMPRESSED_RGBA_BPTC_UNORM_ARB, GL_RGB, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
-     true},                                                             // BC7U
    {GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // ASTC_2D_4X4

    // DepthStencil formats
    {GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, ComponentType::UNorm,
     false}, // Z24S8
-    {GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, ComponentType::UNorm,
-     false},                                                                            // S8Z24
-    {GL_DEPTH_COMPONENT32F, GL_DEPTH_COMPONENT, GL_FLOAT, ComponentType::Float, false}, // Z32F
 }};

 static const FormatTuple& GetFormatTuple(PixelFormat pixel_format, ComponentType component_type) {
@@ -155,6 +131,13 @@ MathUtil::Rectangle<u32> SurfaceParams::GetRect() const {
    return {0, actual_height, width, 0};
 }

+static void ConvertASTCToRGBA8(std::vector<u8>& data, PixelFormat format, u32 width, u32 height) {
+    u32 block_width{};
+    u32 block_height{};
+    std::tie(block_width, block_height) = GetASTCBlockSize(format);
+    data = Tegra::Texture::ASTC::Decompress(data, width, height, block_width, block_height);
+}
+
 template <bool morton_to_gl, PixelFormat format>
 void MortonCopy(u32 stride, u32 block_height, u32 height, u8* gl_buffer, Tegra::GPUVAddr addr) {
    constexpr u32 bytes_per_pixel = SurfaceParams::GetFormatBpp(format) / CHAR_BIT;
@@ -193,9 +176,7 @@ static constexpr std::array<void (*)(u32, u32, u32, u8*, Tegra::GPUVAddr),
        MortonCopy<true, PixelFormat::R11FG11FB10F>, MortonCopy<true, PixelFormat::RGBA32UI>,
        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::Z24S8>,        MortonCopy<true, PixelFormat::S8Z24>,
-        MortonCopy<true, PixelFormat::Z32F>,
+        MortonCopy<true, PixelFormat::ASTC_2D_4X4>,  MortonCopy<true, PixelFormat::Z24S8>,
 };

 static constexpr std::array<void (*)(u32, u32, u32, u8*, Tegra::GPUVAddr),
@@ -209,16 +190,13 @@ 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 the DXT1/DXT23/DXT45/DXN1/BC7U formats is not yet supported
-        nullptr,
+        // TODO(Subv): Swizzling the DXT1/DXT23/DXT45/DXN1 formats is not yet supported
        nullptr,
        nullptr,
        nullptr,
        nullptr,
        MortonCopy<false, PixelFormat::ABGR8>,
        MortonCopy<false, PixelFormat::Z24S8>,
-        MortonCopy<false, PixelFormat::S8Z24>,
-        MortonCopy<false, PixelFormat::Z32F>,
 };

 // Allocate an uninitialized texture of appropriate size and format for the surface
@@ -256,71 +234,6 @@ CachedSurface::CachedSurface(const SurfaceParams& params) : params(params) {
                           rect.GetWidth(), rect.GetHeight());
 }

-static void ConvertS8Z24ToZ24S8(std::vector<u8>& data, u32 width, u32 height) {
-    union S8Z24 {
-        BitField<0, 24, u32> z24;
-        BitField<24, 8, u32> s8;
-    };
-    static_assert(sizeof(S8Z24) == 4, "S8Z24 is incorrect size");
-
-    union Z24S8 {
-        BitField<0, 8, u32> s8;
-        BitField<8, 24, u32> z24;
-    };
-    static_assert(sizeof(Z24S8) == 4, "Z24S8 is incorrect size");
-
-    S8Z24 input_pixel{};
-    Z24S8 output_pixel{};
-    for (size_t y = 0; y < height; ++y) {
-        for (size_t x = 0; x < width; ++x) {
-            const size_t offset{y * width + x};
-            std::memcpy(&input_pixel, &data[offset], sizeof(S8Z24));
-            output_pixel.s8.Assign(input_pixel.s8);
-            output_pixel.z24.Assign(input_pixel.z24);
-            std::memcpy(&data[offset], &output_pixel, sizeof(Z24S8));
-        }
-    }
-}
-/**
- * Helper function to perform software conversion (as needed) when loading a buffer from Switch
- * memory. This is for Maxwell pixel formats that cannot be represented as-is in OpenGL or with
- * typical desktop GPUs.
- */
-static void ConvertFormatAsNeeded_LoadGLBuffer(std::vector<u8>& data, PixelFormat pixel_format,
-                                               u32 width, u32 height) {
-    switch (pixel_format) {
-    case PixelFormat::ASTC_2D_4X4: {
-        // Convert ASTC pixel formats to RGBA8, as most desktop GPUs do not support ASTC.
-        u32 block_width{};
-        u32 block_height{};
-        std::tie(block_width, block_height) = GetASTCBlockSize(pixel_format);
-        data = Tegra::Texture::ASTC::Decompress(data, width, height, block_width, block_height);
-        break;
-    }
-    case PixelFormat::S8Z24:
-        // Convert the S8Z24 depth format to Z24S8, as OpenGL does not support S8Z24.
-        ConvertS8Z24ToZ24S8(data, width, height);
-        break;
-    }
-}
-
-/**
- * Helper function to perform software conversion (as needed) when flushing a buffer to Switch
- * memory. This is for Maxwell pixel formats that cannot be represented as-is in OpenGL or with
- * typical desktop GPUs.
- */
-static void ConvertFormatAsNeeded_FlushGLBuffer(std::vector<u8>& /*data*/, PixelFormat pixel_format,
-                                                u32 /*width*/, u32 /*height*/) {
-    switch (pixel_format) {
-    case PixelFormat::ASTC_2D_4X4:
-    case PixelFormat::S8Z24:
-        LOG_CRITICAL(Render_OpenGL, "Unimplemented pixel_format={}",
-                     static_cast<u32>(pixel_format));
-        UNREACHABLE();
-        break;
-    }
-}
-
 MICROPROFILE_DEFINE(OpenGL_SurfaceLoad, "OpenGL", "Surface Load", MP_RGB(128, 64, 192));
 void CachedSurface::LoadGLBuffer() {
    ASSERT(params.type != SurfaceType::Fill);
@@ -343,7 +256,10 @@ void CachedSurface::LoadGLBuffer() {
            params.width, params.block_height, params.height, gl_buffer.data(), params.addr);
    }

-    ConvertFormatAsNeeded_LoadGLBuffer(gl_buffer, params.pixel_format, params.width, params.height);
+    if (IsPixelFormatASTC(params.pixel_format)) {
+        // ASTC formats are converted to RGBA8 in software, as most PC GPUs do not support this
+        ConvertASTCToRGBA8(gl_buffer, params.pixel_format, params.width, params.height);
+    }
 }

 MICROPROFILE_DEFINE(OpenGL_SurfaceFlush, "OpenGL", "Surface Flush", MP_RGB(128, 192, 64));
@@ -356,9 +272,6 @@ void CachedSurface::FlushGLBuffer() {

    MICROPROFILE_SCOPE(OpenGL_SurfaceFlush);

-    ConvertFormatAsNeeded_FlushGLBuffer(gl_buffer, params.pixel_format, params.width,
-                                        params.height);
-
    if (!params.is_tiled) {
        std::memcpy(dst_buffer, gl_buffer.data(), params.size_in_bytes);
    } else {
@@ -486,16 +399,15 @@ SurfaceSurfaceRect_Tuple RasterizerCacheOpenGL::GetFramebufferSurfaces(
    LOG_WARNING(Render_OpenGL, "hard-coded for render target 0!");

    // get color and depth surfaces
-    SurfaceParams color_params{};
-    SurfaceParams depth_params{};
-
-    if (using_color_fb) {
-        color_params = SurfaceParams::CreateForFramebuffer(regs.rt[0]);
-    }
+    const SurfaceParams color_params{SurfaceParams::CreateForFramebuffer(regs.rt[0])};
+    SurfaceParams depth_params{color_params};

    if (using_depth_fb) {
-        depth_params =
-            SurfaceParams::CreateForDepthBuffer(regs.rt[0], regs.zeta.Address(), regs.zeta.format);
+        depth_params.addr = regs.zeta.Address();
+        depth_params.pixel_format = SurfaceParams::PixelFormatFromDepthFormat(regs.zeta.format);
+        depth_params.component_type = SurfaceParams::ComponentTypeFromDepthFormat(regs.zeta.format);
+        depth_params.type = SurfaceParams::GetFormatType(depth_params.pixel_format);
+        depth_params.size_in_bytes = depth_params.SizeInBytes();
    }

    MathUtil::Rectangle<u32> color_rect{};
--- a/src/video_core/renderer_opengl/gl_rasterizer_cache.h
+++ b/src/video_core/renderer_opengl/gl_rasterizer_cache.h
@@ -35,15 +35,12 @@ struct SurfaceParams {
        DXT23 = 9,
        DXT45 = 10,
        DXN1 = 11, // This is also known as BC4
-        BC7U = 12,
-        ASTC_2D_4X4 = 13,
+        ASTC_2D_4X4 = 12,

        MaxColorFormat,

        // DepthStencil formats
-        Z24S8 = 14,
-        S8Z24 = 15,
-        Z32F = 16,
+        Z24S8 = 13,

        MaxDepthStencilFormat,

@@ -93,11 +90,8 @@ struct SurfaceParams {
            4, // DXT23
            4, // DXT45
            4, // DXN1
-            4, // BC7U
            4, // ASTC_2D_4X4
            1, // Z24S8
-            1, // S8Z24
-            1, // Z32F
        }};

        ASSERT(static_cast<size_t>(format) < compression_factor_table.size());
@@ -121,11 +115,8 @@ struct SurfaceParams {
            128, // DXT23
            128, // DXT45
            64,  // DXN1
-            128, // BC7U
            32,  // ASTC_2D_4X4
            32,  // Z24S8
-            32,  // S8Z24
-            32,  // Z32F
        }};

        ASSERT(static_cast<size_t>(format) < bpp_table.size());
@@ -137,12 +128,8 @@ struct SurfaceParams {

    static PixelFormat PixelFormatFromDepthFormat(Tegra::DepthFormat format) {
        switch (format) {
-        case Tegra::DepthFormat::S8_Z24_UNORM:
-            return PixelFormat::S8Z24;
        case Tegra::DepthFormat::Z24_S8_UNORM:
            return PixelFormat::Z24S8;
-        case Tegra::DepthFormat::Z32_FLOAT:
-            return PixelFormat::Z32F;
        default:
            LOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format));
            UNREACHABLE();
@@ -195,8 +182,6 @@ struct SurfaceParams {
            return PixelFormat::DXT45;
        case Tegra::Texture::TextureFormat::DXN1:
            return PixelFormat::DXN1;
-        case Tegra::Texture::TextureFormat::BC7U:
-            return PixelFormat::BC7U;
        case Tegra::Texture::TextureFormat::ASTC_2D_4X4:
            return PixelFormat::ASTC_2D_4X4;
        default:
@@ -232,8 +217,6 @@ struct SurfaceParams {
            return Tegra::Texture::TextureFormat::DXT45;
        case PixelFormat::DXN1:
            return Tegra::Texture::TextureFormat::DXN1;
-        case PixelFormat::BC7U:
-            return Tegra::Texture::TextureFormat::BC7U;
        case PixelFormat::ASTC_2D_4X4:
            return Tegra::Texture::TextureFormat::ASTC_2D_4X4;
        default:
@@ -243,12 +226,8 @@ struct SurfaceParams {

    static Tegra::DepthFormat DepthFormatFromPixelFormat(PixelFormat format) {
        switch (format) {
-        case PixelFormat::S8Z24:
-            return Tegra::DepthFormat::S8_Z24_UNORM;
        case PixelFormat::Z24S8:
            return Tegra::DepthFormat::Z24_S8_UNORM;
-        case PixelFormat::Z32F:
-            return Tegra::DepthFormat::Z32_FLOAT;
        default:
            UNREACHABLE();
        }
@@ -295,11 +274,8 @@ struct SurfaceParams {

    static ComponentType ComponentTypeFromDepthFormat(Tegra::DepthFormat format) {
        switch (format) {
-        case Tegra::DepthFormat::S8_Z24_UNORM:
        case Tegra::DepthFormat::Z24_S8_UNORM:
            return ComponentType::UNorm;
-        case Tegra::DepthFormat::Z32_FLOAT:
-            return ComponentType::Float;
        default:
            LOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format));
            UNREACHABLE();
@@ -342,18 +318,13 @@ struct SurfaceParams {
        return addr <= (region_addr + region_size) && region_addr <= (addr + size_in_bytes);
    }

-    /// Creates SurfaceParams from a texture configuration
+    /// Creates SurfaceParams from a texture configation
    static SurfaceParams CreateForTexture(const Tegra::Texture::FullTextureInfo& config);

-    /// Creates SurfaceParams from a framebuffer configuration
+    /// Creates SurfaceParams from a framebuffer configation
    static SurfaceParams CreateForFramebuffer(
        const Tegra::Engines::Maxwell3D::Regs::RenderTargetConfig& config);

-    /// Creates SurfaceParams for a depth buffer configuration
-    static SurfaceParams CreateForDepthBuffer(
-        const Tegra::Engines::Maxwell3D::Regs::RenderTargetConfig& config,
-        Tegra::GPUVAddr zeta_address, Tegra::DepthFormat format);
-
    Tegra::GPUVAddr addr;
    bool is_tiled;
    u32 block_height;
--- a/src/video_core/renderer_opengl/gl_shader_decompiler.cpp
+++ b/src/video_core/renderer_opengl/gl_shader_decompiler.cpp
@@ -42,14 +42,13 @@ enum class ExitMethod {
 struct Subroutine {
    /// Generates a name suitable for GLSL source code.
    std::string GetName() const {
-        return "sub_" + std::to_string(begin) + '_' + std::to_string(end) + '_' + suffix;
+        return "sub_" + std::to_string(begin) + '_' + std::to_string(end);
    }

-    u32 begin;                 ///< Entry point of the subroutine.
-    u32 end;                   ///< Return point of the subroutine.
-    const std::string& suffix; ///< Suffix of the shader, used to make a unique subroutine name
-    ExitMethod exit_method;    ///< Exit method of the subroutine.
-    std::set<u32> labels;      ///< Addresses refereced by JMP instructions.
+    u32 begin;              ///< Entry point of the subroutine.
+    u32 end;                ///< Return point of the subroutine.
+    ExitMethod exit_method; ///< Exit method of the subroutine.
+    std::set<u32> labels;   ///< Addresses refereced by JMP instructions.

    bool operator<(const Subroutine& rhs) const {
        return std::tie(begin, end) < std::tie(rhs.begin, rhs.end);
@@ -59,11 +58,11 @@ struct Subroutine {
 /// Analyzes shader code and produces a set of subroutines.
 class ControlFlowAnalyzer {
 public:
-    ControlFlowAnalyzer(const ProgramCode& program_code, u32 main_offset, const std::string& suffix)
+    ControlFlowAnalyzer(const ProgramCode& program_code, u32 main_offset)
        : program_code(program_code) {

        // Recursively finds all subroutines.
-        const Subroutine& program_main = AddSubroutine(main_offset, PROGRAM_END, suffix);
+        const Subroutine& program_main = AddSubroutine(main_offset, PROGRAM_END);
        if (program_main.exit_method != ExitMethod::AlwaysEnd)
            throw DecompileFail("Program does not always end");
    }
@@ -78,12 +77,12 @@ private:
    std::map<std::pair<u32, u32>, ExitMethod> exit_method_map;

    /// 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});
+    const Subroutine& AddSubroutine(u32 begin, u32 end) {
+        auto iter = subroutines.find(Subroutine{begin, end});
        if (iter != subroutines.end())
            return *iter;

-        Subroutine subroutine{begin, end, suffix};
+        Subroutine subroutine{begin, end};
        subroutine.exit_method = Scan(begin, end, subroutine.labels);
        if (subroutine.exit_method == ExitMethod::Undetermined)
            throw DecompileFail("Recursive function detected");
@@ -192,8 +191,7 @@ public:
        UnsignedInteger,
    };

-    GLSLRegister(size_t index, ShaderWriter& shader, const std::string& suffix)
-        : index{index}, shader{shader}, suffix{suffix} {}
+    GLSLRegister(size_t index, ShaderWriter& shader) : index{index}, shader{shader} {}

    /// Gets the GLSL type string for a register
    static std::string GetTypeString(Type type) {
@@ -218,7 +216,7 @@ public:
    /// Returns a GLSL string representing the current state of the register
    const std::string GetActiveString() {
        declr_type.insert(active_type);
-        return GetPrefixString(active_type) + std::to_string(index) + '_' + suffix;
+        return GetPrefixString(active_type) + std::to_string(index);
    }

    /// Returns true if the active type is a float
@@ -253,7 +251,6 @@ private:
    ShaderWriter& shader;
    Type active_type{Type::Float};
    std::set<Type> declr_type;
-    const std::string& suffix;
 };

 /**
@@ -265,8 +262,8 @@ private:
 class GLSLRegisterManager {
 public:
    GLSLRegisterManager(ShaderWriter& shader, ShaderWriter& declarations,
-                        const Maxwell3D::Regs::ShaderStage& stage, const std::string& suffix)
-        : shader{shader}, declarations{declarations}, stage{stage}, suffix{suffix} {
+                        const Maxwell3D::Regs::ShaderStage& stage)
+        : shader{shader}, declarations{declarations}, stage{stage} {
        BuildRegisterList();
    }

@@ -433,12 +430,12 @@ public:
    }

    /// Add declarations for registers
-    void GenerateDeclarations(const std::string& suffix) {
+    void GenerateDeclarations() {
        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;");
+                                     GLSLRegister::GetPrefixString(type) +
+                                     std::to_string(reg.GetIndex()) + " = 0;");
            }
        }
        declarations.AddNewLine();
@@ -561,7 +558,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, shader);
        }
    }

@@ -623,17 +620,16 @@ private:
    std::array<ConstBufferEntry, Maxwell3D::Regs::MaxConstBuffers> declr_const_buffers;
    std::vector<SamplerEntry> used_samplers;
    const Maxwell3D::Regs::ShaderStage& stage;
-    const std::string& suffix;
 };

 class GLSLGenerator {
 public:
    GLSLGenerator(const std::set<Subroutine>& subroutines, const ProgramCode& program_code,
-                  u32 main_offset, Maxwell3D::Regs::ShaderStage stage, const std::string& suffix)
+                  u32 main_offset, Maxwell3D::Regs::ShaderStage stage)
        : subroutines(subroutines), program_code(program_code), main_offset(main_offset),
-          stage(stage), suffix(suffix) {
+          stage(stage) {

-        Generate(suffix);
+        Generate();
    }

    std::string GetShaderCode() {
@@ -648,7 +644,7 @@ public:
 private:
    /// Gets the Subroutine object corresponding to the specified address.
    const Subroutine& GetSubroutine(u32 begin, u32 end) const {
-        auto iter = subroutines.find(Subroutine{begin, end, suffix});
+        auto iter = subroutines.find(Subroutine{begin, end});
        ASSERT(iter != subroutines.end());
        return *iter;
    }
@@ -693,7 +689,7 @@ private:
        // Can't assign to the constant predicate.
        ASSERT(pred != static_cast<u64>(Pred::UnusedIndex));

-        std::string variable = 'p' + std::to_string(pred) + '_' + suffix;
+        std::string variable = 'p' + std::to_string(pred);
        shader.AddLine(variable + " = " + value + ';');
        declr_predicates.insert(std::move(variable));
    }
@@ -711,7 +707,7 @@ private:
        if (index == static_cast<u64>(Pred::UnusedIndex))
            variable = "true";
        else
-            variable = 'p' + std::to_string(index) + '_' + suffix;
+            variable = 'p' + std::to_string(index);

        if (negate) {
            return "!(" + variable + ')';
@@ -732,10 +728,10 @@ private:
                                       const std::string& op_a, const std::string& op_b) const {
        using Tegra::Shader::PredCondition;
        static const std::unordered_map<PredCondition, const char*> PredicateComparisonStrings = {
-            {PredCondition::LessThan, "<"},        {PredCondition::Equal, "=="},
-            {PredCondition::LessEqual, "<="},      {PredCondition::GreaterThan, ">"},
-            {PredCondition::NotEqual, "!="},       {PredCondition::GreaterEqual, ">="},
-            {PredCondition::LessThanWithNan, "<"}, {PredCondition::NotEqualWithNan, "!="},
+            {PredCondition::LessThan, "<"},         {PredCondition::Equal, "=="},
+            {PredCondition::LessEqual, "<="},       {PredCondition::GreaterThan, ">"},
+            {PredCondition::NotEqual, "!="},        {PredCondition::GreaterEqual, ">="},
+            {PredCondition::NotEqualWithNan, "!="},
        };

        const auto& comparison{PredicateComparisonStrings.find(condition)};
@@ -743,8 +739,7 @@ private:
                   "Unknown predicate comparison operation");

        std::string predicate{'(' + op_a + ") " + comparison->second + " (" + op_b + ')'};
-        if (condition == PredCondition::LessThanWithNan ||
-            condition == PredCondition::NotEqualWithNan) {
+        if (condition == PredCondition::NotEqualWithNan) {
            predicate += " || isnan(" + op_a + ") || isnan(" + op_b + ')';
        }

@@ -973,29 +968,6 @@ private:
                    regs.GetRegisterAsFloat(instr.gpr8) + " * " + GetImmediate32(instr), 1, 1);
                break;
            }
-            case OpCode::Id::FADD32I: {
-                std::string op_a = regs.GetRegisterAsFloat(instr.gpr8);
-                std::string op_b = GetImmediate32(instr);
-
-                if (instr.fadd32i.abs_a) {
-                    op_a = "abs(" + op_a + ')';
-                }
-
-                if (instr.fadd32i.negate_a) {
-                    op_a = "-(" + op_a + ')';
-                }
-
-                if (instr.fadd32i.abs_b) {
-                    op_b = "abs(" + op_b + ')';
-                }
-
-                if (instr.fadd32i.negate_b) {
-                    op_b = "-(" + op_b + ')';
-                }
-
-                regs.SetRegisterToFloat(instr.gpr0, 0, op_a + " + " + op_b, 1, 1);
-                break;
-            }
            }
            break;
        }
@@ -1155,20 +1127,6 @@ private:
                WriteLogicOperation(instr.gpr0, instr.alu.lop.operation, op_a, op_b);
                break;
            }
-            case OpCode::Id::IMNMX_C:
-            case OpCode::Id::IMNMX_R:
-            case OpCode::Id::IMNMX_IMM: {
-                ASSERT_MSG(instr.imnmx.exchange == Tegra::Shader::IMinMaxExchange::None,
-                           "Unimplemented");
-                std::string condition =
-                    GetPredicateCondition(instr.imnmx.pred, instr.imnmx.negate_pred != 0);
-                std::string parameters = op_a + ',' + op_b;
-                regs.SetRegisterToInteger(instr.gpr0, instr.imnmx.is_signed, 0,
-                                          '(' + condition + ") ? min(" + parameters + ") : max(" +
-                                              parameters + ')',
-                                          1, 1);
-                break;
-            }
            default: {
                LOG_CRITICAL(HW_GPU, "Unhandled ArithmeticInteger instruction: {}",
                             opcode->GetName());
@@ -1255,9 +1213,6 @@ private:
                switch (instr.conversion.f2f.rounding) {
                case Tegra::Shader::F2fRoundingOp::None:
                    break;
-                case Tegra::Shader::F2fRoundingOp::Round:
-                    op_a = "roundEven(" + op_a + ')';
-                    break;
                case Tegra::Shader::F2fRoundingOp::Floor:
                    op_a = "floor(" + op_a + ')';
                    break;
@@ -1522,36 +1477,6 @@ private:
            }
            break;
        }
-        case OpCode::Type::PredicateSetPredicate: {
-            std::string op_a =
-                GetPredicateCondition(instr.psetp.pred12, instr.psetp.neg_pred12 != 0);
-            std::string op_b =
-                GetPredicateCondition(instr.psetp.pred29, instr.psetp.neg_pred29 != 0);
-
-            using Tegra::Shader::Pred;
-            // We can't use the constant predicate as destination.
-            ASSERT(instr.psetp.pred3 != static_cast<u64>(Pred::UnusedIndex));
-
-            std::string second_pred =
-                GetPredicateCondition(instr.psetp.pred39, instr.psetp.neg_pred39 != 0);
-
-            std::string combiner = GetPredicateCombiner(instr.psetp.op);
-
-            std::string predicate =
-                '(' + op_a + ") " + GetPredicateCombiner(instr.psetp.cond) + " (" + op_b + ')';
-
-            // Set the primary predicate to the result of Predicate OP SecondPredicate
-            SetPredicate(instr.psetp.pred3,
-                         '(' + predicate + ") " + combiner + " (" + second_pred + ')');
-
-            if (instr.psetp.pred0 != static_cast<u64>(Pred::UnusedIndex)) {
-                // Set the secondary predicate to the result of !Predicate OP SecondPredicate,
-                // if enabled
-                SetPredicate(instr.psetp.pred0,
-                             "!(" + predicate + ") " + combiner + " (" + second_pred + ')');
-            }
-            break;
-        }
        case OpCode::Type::FloatSet: {
            std::string op_a = instr.fset.neg_a ? "-" : "";
            op_a += regs.GetRegisterAsFloat(instr.gpr8);
@@ -1644,32 +1569,16 @@ private:
                    shader.AddLine("color.a = " + regs.GetRegisterAsFloat(3) + ';');
                }

-                switch (instr.flow.cond) {
-                case Tegra::Shader::FlowCondition::Always:
-                    shader.AddLine("return true;");
-                    if (instr.pred.pred_index == static_cast<u64>(Pred::UnusedIndex)) {
-                        // If this is an unconditional exit then just end processing here,
-                        // otherwise we have to account for the possibility of the condition
-                        // not being met, so continue processing the next instruction.
-                        offset = PROGRAM_END - 1;
-                    }
-                    break;
-
-                case Tegra::Shader::FlowCondition::Fcsm_Tr:
-                    // TODO(bunnei): What is this used for? If we assume this conditon is not
-                    // satisifed, dual vertex shaders in Farming Simulator make more sense
-                    LOG_CRITICAL(HW_GPU, "Skipping unknown FlowCondition::Fcsm_Tr");
-                    break;
-
-                default:
-                    LOG_CRITICAL(HW_GPU, "Unhandled flow condition: {}",
-                                 static_cast<u32>(instr.flow.cond.Value()));
-                    UNREACHABLE();
+                shader.AddLine("return true;");
+                if (instr.pred.pred_index == static_cast<u64>(Pred::UnusedIndex)) {
+                    // If this is an unconditional exit then just end processing here, otherwise
+                    // we have to account for the possibility of the condition not being met, so
+                    // continue processing the next instruction.
+                    offset = PROGRAM_END - 1;
                }
                break;
            }
            case OpCode::Id::KIL: {
-                ASSERT(instr.flow.cond == Tegra::Shader::FlowCondition::Always);
                shader.AddLine("discard;");
                break;
            }
@@ -1690,14 +1599,6 @@ private:
                // can ignore this when generating GLSL code.
                break;
            }
-            case OpCode::Id::SYNC:
-                ASSERT(instr.flow.cond == Tegra::Shader::FlowCondition::Always);
-            case OpCode::Id::DEPBAR: {
-                // TODO(Subv): Find out if we actually have to care about these instructions or if
-                // the GLSL compiler takes care of that for us.
-                LOG_WARNING(HW_GPU, "DEPBAR/SYNC instruction is stubbed");
-                break;
-            }
            default: {
                LOG_CRITICAL(HW_GPU, "Unhandled instruction: {}", opcode->GetName());
                UNREACHABLE();
@@ -1732,7 +1633,7 @@ private:
        return program_counter;
    }

-    void Generate(const std::string& suffix) {
+    void Generate() {
        // Add declarations for all subroutines
        for (const auto& subroutine : subroutines) {
            shader.AddLine("bool " + subroutine.GetName() + "();");
@@ -1740,7 +1641,7 @@ private:
        shader.AddNewLine();

        // Add the main entry point
-        shader.AddLine("bool exec_" + suffix + "() {");
+        shader.AddLine("bool exec_shader() {");
        ++shader.scope;
        CallSubroutine(GetSubroutine(main_offset, PROGRAM_END));
        --shader.scope;
@@ -1803,7 +1704,7 @@ private:

    /// Add declarations for registers
    void GenerateDeclarations() {
-        regs.GenerateDeclarations(suffix);
+        regs.GenerateDeclarations();

        for (const auto& pred : declr_predicates) {
            declarations.AddLine("bool " + pred + " = false;");
@@ -1816,30 +1717,27 @@ private:
    const ProgramCode& program_code;
    const u32 main_offset;
    Maxwell3D::Regs::ShaderStage stage;
-    const std::string& suffix;

    ShaderWriter shader;
    ShaderWriter declarations;
-    GLSLRegisterManager regs{shader, declarations, stage, suffix};
+    GLSLRegisterManager regs{shader, declarations, stage};

    // Declarations
    std::set<std::string> declr_predicates;
 }; // namespace Decompiler

 std::string GetCommonDeclarations() {
-    std::string declarations;
+    std::string declarations = "bool exec_shader();\n";
    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,
-                                                Maxwell3D::Regs::ShaderStage stage,
-                                                const std::string& suffix) {
+                                                Maxwell3D::Regs::ShaderStage stage) {
    try {
-        auto subroutines = ControlFlowAnalyzer(program_code, main_offset, suffix).GetSubroutines();
-        GLSLGenerator generator(subroutines, program_code, main_offset, stage, suffix);
+        auto subroutines = ControlFlowAnalyzer(program_code, main_offset).GetSubroutines();
+        GLSLGenerator generator(subroutines, program_code, main_offset, stage);
        return ProgramResult{generator.GetShaderCode(), generator.GetEntries()};
    } catch (const DecompileFail& exception) {
        LOG_ERROR(HW_GPU, "Shader decompilation failed: {}", exception.what());
--- a/src/video_core/renderer_opengl/gl_shader_decompiler.h
+++ b/src/video_core/renderer_opengl/gl_shader_decompiler.h
@@ -20,8 +20,7 @@ using Tegra::Engines::Maxwell3D;
 std::string GetCommonDeclarations();

 boost::optional<ProgramResult> DecompileProgram(const ProgramCode& program_code, u32 main_offset,
-                                                Maxwell3D::Regs::ShaderStage stage,
-                                                const std::string& suffix);
+                                                Maxwell3D::Regs::ShaderStage stage);

 } // namespace Decompiler
 } // namespace GLShader
--- a/src/video_core/renderer_opengl/gl_shader_gen.cpp
+++ b/src/video_core/renderer_opengl/gl_shader_gen.cpp
@@ -17,17 +17,10 @@ ProgramResult GenerateVertexShader(const ShaderSetup& setup, const MaxwellVSConf
    std::string out = "#version 430 core\n";
    out += "#extension GL_ARB_separate_shader_objects : enable\n\n";
    out += Decompiler::GetCommonDeclarations();
-    out += "bool exec_vertex();\n";
-
-    if (setup.IsDualProgram()) {
-        out += "bool exec_vertex_b();\n";
-    }
-
-    ProgramResult program =
-        Decompiler::DecompileProgram(setup.program.code, PROGRAM_OFFSET,
-                                     Maxwell3D::Regs::ShaderStage::Vertex, "vertex")
-            .get_value_or({});

+    ProgramResult program = Decompiler::DecompileProgram(setup.program_code, PROGRAM_OFFSET,
+                                                         Maxwell3D::Regs::ShaderStage::Vertex)
+                                .get_value_or({});
    out += R"(

 out gl_PerVertex {
@@ -41,14 +34,7 @@ layout (std140) uniform vs_config {
 };

 void main() {
-    exec_vertex();
-)";
-
-    if (setup.IsDualProgram()) {
-        out += "    exec_vertex_b();";
-    }
-
-    out += R"(
+    exec_shader();

    // Viewport can be flipped, which is unsupported by glViewport
    position.xy *= viewport_flip.xy;
@@ -58,19 +44,8 @@ void main() {
    // For now, this is here to bring order in lieu of proper emulation
    position.w = 1.0;
 }
-
 )";
-
    out += program.first;
-
-    if (setup.IsDualProgram()) {
-        ProgramResult program_b =
-            Decompiler::DecompileProgram(setup.program.code_b, PROGRAM_OFFSET,
-                                         Maxwell3D::Regs::ShaderStage::Vertex, "vertex_b")
-                .get_value_or({});
-        out += program_b.first;
-    }
-
    return {out, program.second};
 }

@@ -78,13 +53,12 @@ ProgramResult GenerateFragmentShader(const ShaderSetup& setup, const MaxwellFSCo
    std::string out = "#version 430 core\n";
    out += "#extension GL_ARB_separate_shader_objects : enable\n\n";
    out += Decompiler::GetCommonDeclarations();
-    out += "bool exec_fragment();\n";

-    ProgramResult program =
-        Decompiler::DecompileProgram(setup.program.code, PROGRAM_OFFSET,
-                                     Maxwell3D::Regs::ShaderStage::Fragment, "fragment")
-            .get_value_or({});
+    ProgramResult program = Decompiler::DecompileProgram(setup.program_code, PROGRAM_OFFSET,
+                                                         Maxwell3D::Regs::ShaderStage::Fragment)
+                                .get_value_or({});
    out += R"(
+
 in vec4 position;
 out vec4 color;

@@ -93,7 +67,7 @@ layout (std140) uniform fs_config {
 };

 void main() {
-    exec_fragment();
+    exec_shader();
 }

 )";
--- a/src/video_core/renderer_opengl/gl_shader_gen.h
+++ b/src/video_core/renderer_opengl/gl_shader_gen.h
@@ -115,48 +115,21 @@ struct ShaderEntries {
 using ProgramResult = std::pair<std::string, ShaderEntries>;

 struct ShaderSetup {
-    ShaderSetup(const ProgramCode& program_code) {
-        program.code = program_code;
-    }
-
-    struct {
-        ProgramCode code;
-        ProgramCode code_b; // Used for dual vertex shaders
-    } program;
+    ShaderSetup(ProgramCode&& program_code) : program_code(std::move(program_code)) {}

+    ProgramCode program_code;
    bool program_code_hash_dirty = true;

    u64 GetProgramCodeHash() {
        if (program_code_hash_dirty) {
-            program_code_hash = GetNewHash();
+            program_code_hash = Common::ComputeHash64(&program_code, sizeof(program_code));
            program_code_hash_dirty = false;
        }
        return program_code_hash;
    }

-    /// Used in scenarios where we have a dual vertex shaders
-    void SetProgramB(const ProgramCode& program_b) {
-        program.code_b = program_b;
-        has_program_b = true;
-    }
-
-    bool IsDualProgram() const {
-        return has_program_b;
-    }
-
 private:
-    u64 GetNewHash() const {
-        if (has_program_b) {
-            // Compute hash over dual shader programs
-            return Common::ComputeHash64(&program, sizeof(program));
-        } else {
-            // Compute hash over a single shader program
-            return Common::ComputeHash64(&program.code, program.code.size());
-        }
-    }
-
    u64 program_code_hash{};
-    bool has_program_b{};
 };

 struct MaxwellShaderConfigCommon {
--- a/src/video_core/renderer_opengl/maxwell_to_gl.h
+++ b/src/video_core/renderer_opengl/maxwell_to_gl.h
@@ -29,10 +29,6 @@ inline GLenum VertexType(Maxwell::VertexAttribute attrib) {
        switch (attrib.size) {
        case Maxwell::VertexAttribute::Size::Size_8_8_8_8:
            return GL_UNSIGNED_BYTE;
-        case Maxwell::VertexAttribute::Size::Size_16_16:
-            return GL_UNSIGNED_SHORT;
-        case Maxwell::VertexAttribute::Size::Size_10_10_10_2:
-            return GL_UNSIGNED_INT_2_10_10_10_REV;
        }

        LOG_CRITICAL(Render_OpenGL, "Unimplemented vertex size={}", attrib.SizeString());
@@ -45,10 +41,6 @@ inline GLenum VertexType(Maxwell::VertexAttribute attrib) {
        switch (attrib.size) {
        case Maxwell::VertexAttribute::Size::Size_8_8_8_8:
            return GL_BYTE;
-        case Maxwell::VertexAttribute::Size::Size_16_16:
-            return GL_SHORT;
-        case Maxwell::VertexAttribute::Size::Size_10_10_10_2:
-            return GL_INT_2_10_10_10_REV;
        }

        LOG_CRITICAL(Render_OpenGL, "Unimplemented vertex size={}", attrib.SizeString());
@@ -211,28 +203,20 @@ inline GLenum SwizzleSource(Tegra::Texture::SwizzleSource source) {
 inline GLenum ComparisonOp(Maxwell::ComparisonOp comparison) {
    switch (comparison) {
    case Maxwell::ComparisonOp::Never:
-    case Maxwell::ComparisonOp::NeverOld:
        return GL_NEVER;
    case Maxwell::ComparisonOp::Less:
-    case Maxwell::ComparisonOp::LessOld:
        return GL_LESS;
    case Maxwell::ComparisonOp::Equal:
-    case Maxwell::ComparisonOp::EqualOld:
        return GL_EQUAL;
    case Maxwell::ComparisonOp::LessEqual:
-    case Maxwell::ComparisonOp::LessEqualOld:
        return GL_LEQUAL;
    case Maxwell::ComparisonOp::Greater:
-    case Maxwell::ComparisonOp::GreaterOld:
        return GL_GREATER;
    case Maxwell::ComparisonOp::NotEqual:
-    case Maxwell::ComparisonOp::NotEqualOld:
        return GL_NOTEQUAL;
    case Maxwell::ComparisonOp::GreaterEqual:
-    case Maxwell::ComparisonOp::GreaterEqualOld:
        return GL_GEQUAL;
    case Maxwell::ComparisonOp::Always:
-    case Maxwell::ComparisonOp::AlwaysOld:
        return GL_ALWAYS;
    }
    LOG_CRITICAL(Render_OpenGL, "Unimplemented comparison op={}", static_cast<u32>(comparison));
--- a/src/video_core/textures/decoders.cpp
+++ b/src/video_core/textures/decoders.cpp
@@ -52,7 +52,6 @@ u32 BytesPerPixel(TextureFormat format) {
        return 8;
    case TextureFormat::DXT23:
    case TextureFormat::DXT45:
-    case TextureFormat::BC7U:
        // In this case a 'pixel' actually refers to a 4x4 tile.
        return 16;
    case TextureFormat::ASTC_2D_4X4:
@@ -77,9 +76,7 @@ u32 BytesPerPixel(TextureFormat format) {

 static u32 DepthBytesPerPixel(DepthFormat format) {
    switch (format) {
-    case DepthFormat::S8_Z24_UNORM:
    case DepthFormat::Z24_S8_UNORM:
-    case DepthFormat::Z32_FLOAT:
        return 4;
    default:
        UNIMPLEMENTED_MSG("Format not implemented");
@@ -99,7 +96,6 @@ std::vector<u8> UnswizzleTexture(VAddr address, TextureFormat format, u32 width,
    case TextureFormat::DXT23:
    case TextureFormat::DXT45:
    case TextureFormat::DXN1:
-    case TextureFormat::BC7U:
        // In the DXT and DXN formats, each 4x4 tile is swizzled instead of just individual pixel
        // values.
        CopySwizzledData(width / 4, height / 4, bytes_per_pixel, bytes_per_pixel, data,
@@ -133,9 +129,7 @@ std::vector<u8> UnswizzleDepthTexture(VAddr address, DepthFormat format, u32 wid
    std::vector<u8> unswizzled_data(width * height * bytes_per_pixel);

    switch (format) {
-    case DepthFormat::S8_Z24_UNORM:
    case DepthFormat::Z24_S8_UNORM:
-    case DepthFormat::Z32_FLOAT:
        CopySwizzledData(width, height, bytes_per_pixel, bytes_per_pixel, data,
                         unswizzled_data.data(), true, block_height);
        break;
@@ -157,7 +151,6 @@ std::vector<u8> DecodeTexture(const std::vector<u8>& texture_data, TextureFormat
    case TextureFormat::DXT23:
    case TextureFormat::DXT45:
    case TextureFormat::DXN1:
-    case TextureFormat::BC7U:
    case TextureFormat::ASTC_2D_4X4:
    case TextureFormat::A8R8G8B8:
    case TextureFormat::A2B10G10R10:
--- a/src/yuzu/bootmanager.cpp
+++ b/src/yuzu/bootmanager.cpp
@@ -127,14 +127,13 @@ void GRenderWindow::moveContext() {
 }

 void GRenderWindow::SwapBuffers() {
-    // In our multi-threaded QGLWidget use case we shouldn't need to call `makeCurrent`,
-    // since we never call `doneCurrent` in this thread.
-    // However:
-    // - The Qt debug runtime prints a bogus warning on the console if `makeCurrent` wasn't called
-    // since the last time `swapBuffers` was executed;
-    // - On macOS, if `makeCurrent` isn't called explicitely, resizing the buffer breaks.
+#if !defined(QT_NO_DEBUG)
+    // Qt debug runtime prints a bogus warning on the console if you haven't called makeCurrent
+    // since the last time you called swapBuffers. This presumably means something if you're using
+    // QGLWidget the "regular" way, but in our multi-threaded use case is harmless since we never
+    // call doneCurrent in this thread.
    child->makeCurrent();
-
+#endif
    child->swapBuffers();
 }

--- a/src/yuzu/debugger/console.cpp
+++ b/src/yuzu/debugger/console.cpp
@@ -14,13 +14,6 @@

 namespace Debugger {
 void ToggleConsole() {
-    static bool console_shown = false;
-    if (console_shown == UISettings::values.show_console) {
-        return;
-    } else {
-        console_shown = UISettings::values.show_console;
-    }
-
 #if defined(_WIN32) && !defined(_DEBUG)
    FILE* temp;
    if (UISettings::values.show_console) {
--- a/src/yuzu/main.cpp
+++ b/src/yuzu/main.cpp
@@ -908,6 +908,8 @@ void GMainWindow::UpdateUITheme() {
 #endif

 int main(int argc, char* argv[]) {
+    Log::AddBackend(std::make_unique<Log::ColorConsoleBackend>());
+
    MicroProfileOnThreadCreate("Frontend");
    SCOPE_EXIT({ MicroProfileShutdown(); });

--- a/src/yuzu_cmd/default_ini.h
+++ b/src/yuzu_cmd/default_ini.h
@@ -166,7 +166,7 @@ use_virtual_sd =
 # 1 (default): Yes, 0: No
 use_docked_mode =

-# The system region that yuzu will use during emulation
+# The system region that Citra will use during emulation
 # -1: Auto-select (default), 0: Japan, 1: USA, 2: Europe, 3: Australia, 4: China, 5: Korea, 6: Taiwan
 region_value =

--- a/src/yuzu_cmd/emu_window/emu_window_sdl2.cpp
+++ b/src/yuzu_cmd/emu_window/emu_window_sdl2.cpp
@@ -126,7 +126,7 @@ EmuWindow_SDL2::EmuWindow_SDL2(bool fullscreen) {
                         SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI);

    if (render_window == nullptr) {
-        LOG_CRITICAL(Frontend, "Failed to create SDL2 window! {}", SDL_GetError());
+        LOG_CRITICAL(Frontend, "Failed to create SDL2 window! Exiting...");
        exit(1);
    }

@@ -137,12 +137,12 @@ EmuWindow_SDL2::EmuWindow_SDL2(bool fullscreen) {
    gl_context = SDL_GL_CreateContext(render_window);

    if (gl_context == nullptr) {
-        LOG_CRITICAL(Frontend, "Failed to create SDL2 GL context! {}", SDL_GetError());
+        LOG_CRITICAL(Frontend, "Failed to create SDL2 GL context! Exiting...");
        exit(1);
    }

    if (!gladLoadGLLoader(static_cast<GLADloadproc>(SDL_GL_GetProcAddress))) {
-        LOG_CRITICAL(Frontend, "Failed to initialize GL functions! {}", SDL_GetError());
+        LOG_CRITICAL(Frontend, "Failed to initialize GL functions! Exiting...");
        exit(1);
    }

--- a/src/yuzu_cmd/yuzu.cpp
+++ b/src/yuzu_cmd/yuzu.cpp
@@ -22,8 +22,10 @@
 #include "yuzu_cmd/config.h"
 #include "yuzu_cmd/emu_window/emu_window_sdl2.h"

+#ifdef _MSC_VER
+#include <getopt.h>
+#else
 #include <getopt.h>
-#ifndef _MSC_VER
 #include <unistd.h>
 #endif

@@ -125,7 +127,6 @@ int main(int argc, char** argv) {
 #endif

    Log::Filter log_filter(Log::Level::Debug);
-    log_filter.ParseFilterString(Settings::values.log_filter);
    Log::SetGlobalFilter(log_filter);

    Log::AddBackend(std::make_unique<Log::ColorConsoleBackend>());
@@ -141,6 +142,8 @@ int main(int argc, char** argv) {
        return -1;
    }

+    log_filter.ParseFilterString(Settings::values.log_filter);
+
    // Apply the command line arguments
    Settings::values.gdbstub_port = gdb_port;
    Settings::values.use_gdbstub = use_gdbstub;