"Merge Tagged PR 1340"

CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.15)
+cmake_minimum_required(VERSION 3.11)
 
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/CMakeModules")
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/externals/cmake-modules")
@@ -13,7 +13,7 @@ project(yuzu)
 option(ENABLE_SDL2 "Enable the SDL2 frontend" ON)
 
 option(ENABLE_QT "Enable the Qt frontend" ON)
-CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_QT "Download bundled Qt binaries" ON "ENABLE_QT;MSVC" OFF)
+CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_QT "Download bundled Qt binaries" OFF "ENABLE_QT;MSVC" OFF)
 
 option(ENABLE_WEB_SERVICE "Enable web services (telemetry, etc.)" ON)
 

src/core/hle/kernel/readable_event.cpp

@@ -38,7 +38,7 @@ void ReadableEvent::Clear() {
 
 ResultCode ReadableEvent::Reset() {
     if (!is_signaled) {
-        LOG_TRACE(Kernel, "Handle is not signaled! object_id={}, object_type={}, object_name={}",
+        LOG_ERROR(Kernel, "Handle is not signaled! object_id={}, object_type={}, object_name={}",
                   GetObjectId(), GetTypeName(), GetName());
         return ERR_INVALID_STATE;
     }

src/core/hle/service/hid/hid.cpp

@@ -161,7 +161,7 @@ Hid::Hid(Core::System& system) : ServiceFramework("hid"), system(system) {
         {40, nullptr, "AcquireXpadIdEventHandle"},
         {41, nullptr, "ReleaseXpadIdEventHandle"},
         {51, &Hid::ActivateXpad, "ActivateXpad"},
-        {55, &Hid::GetXpadIDs, "GetXpadIds"},
+        {55, nullptr, "GetXpadIds"},
         {56, nullptr, "ActivateJoyXpad"},
         {58, nullptr, "GetJoyXpadLifoHandle"},
         {59, nullptr, "GetJoyXpadIds"},
@@ -319,17 +319,6 @@ void Hid::ActivateXpad(Kernel::HLERequestContext& ctx) {
     rb.Push(RESULT_SUCCESS);
 }
 
-void Hid::GetXpadIDs(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto applet_resource_user_id{rp.Pop<u64>()};
-
-    LOG_DEBUG(Service_HID, "(STUBBED) called, applet_resource_user_id={}", applet_resource_user_id);
-
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(RESULT_SUCCESS);
-    rb.Push(0);
-}
-
 void Hid::ActivateDebugPad(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const auto applet_resource_user_id{rp.Pop<u64>()};

src/core/hle/service/hid/hid.h

@@ -86,7 +86,6 @@ public:
 private:
     void CreateAppletResource(Kernel::HLERequestContext& ctx);
     void ActivateXpad(Kernel::HLERequestContext& ctx);
-    void GetXpadIDs(Kernel::HLERequestContext& ctx);
     void ActivateDebugPad(Kernel::HLERequestContext& ctx);
     void ActivateTouchScreen(Kernel::HLERequestContext& ctx);
     void ActivateMouse(Kernel::HLERequestContext& ctx);

src/core/settings.h

@@ -474,7 +474,6 @@ struct Values {
     bool reporting_services;
     bool quest_flag;
     bool disable_cpu_opt;
-    bool disable_macro_jit;
 
     // BCAT
     std::string bcat_backend;

src/video_core/CMakeLists.txt

@@ -25,12 +25,6 @@ add_library(video_core STATIC
     engines/shader_bytecode.h
     engines/shader_header.h
     engines/shader_type.h
-    macro/macro.cpp
-    macro/macro.h
-    macro/macro_interpreter.cpp
-    macro/macro_interpreter.h
-    macro/macro_jit_x64.cpp
-    macro/macro_jit_x64.h
     fence_manager.h
     gpu.cpp
     gpu.h
@@ -42,6 +36,8 @@ add_library(video_core STATIC
     gpu_thread.h
     guest_driver.cpp
     guest_driver.h
+    macro_interpreter.cpp
+    macro_interpreter.h
     memory_manager.cpp
     memory_manager.h
     morton.cpp

src/video_core/buffer_cache/buffer_cache.h

@@ -56,28 +56,24 @@ public:
         if (use_fast_cbuf || size < max_stream_size) {
             if (!is_written && !IsRegionWritten(cpu_addr, cpu_addr + size - 1)) {
                 auto& memory_manager = system.GPU().MemoryManager();
-                const bool is_granular = memory_manager.IsGranularRange(gpu_addr, size);
                 if (use_fast_cbuf) {
-                    u8* dest;
-                    if (is_granular) {
-                        dest = memory_manager.GetPointer(gpu_addr);
+                    if (memory_manager.IsGranularRange(gpu_addr, size)) {
+                        const auto host_ptr = memory_manager.GetPointer(gpu_addr);
+                        return ConstBufferUpload(host_ptr, size);
                     } else {
                         staging_buffer.resize(size);
-                        dest = staging_buffer.data();
-                        memory_manager.ReadBlockUnsafe(gpu_addr, dest, size);
+                        memory_manager.ReadBlockUnsafe(gpu_addr, staging_buffer.data(), size);
+                        return ConstBufferUpload(staging_buffer.data(), size);
                     }
-                    return ConstBufferUpload(dest, size);
-                }
-                if (is_granular) {
-                    u8* const host_ptr = memory_manager.GetPointer(gpu_addr);
-                    return StreamBufferUpload(size, alignment, [host_ptr, size](u8* dest) {
-                        std::memcpy(dest, host_ptr, size);
-                    });
                 } else {
-                    return StreamBufferUpload(
-                        size, alignment, [&memory_manager, gpu_addr, size](u8* dest) {
-                            memory_manager.ReadBlockUnsafe(gpu_addr, dest, size);
-                        });
+                    if (memory_manager.IsGranularRange(gpu_addr, size)) {
+                        const auto host_ptr = memory_manager.GetPointer(gpu_addr);
+                        return StreamBufferUpload(host_ptr, size, alignment);
+                    } else {
+                        staging_buffer.resize(size);
+                        memory_manager.ReadBlockUnsafe(gpu_addr, staging_buffer.data(), size);
+                        return StreamBufferUpload(staging_buffer.data(), size, alignment);
+                    }
                 }
             }
         }
@@ -105,9 +101,7 @@ public:
     BufferInfo UploadHostMemory(const void* raw_pointer, std::size_t size,
                                 std::size_t alignment = 4) {
         std::lock_guard lock{mutex};
-        return StreamBufferUpload(size, alignment, [raw_pointer, size](u8* dest) {
-            std::memcpy(dest, raw_pointer, size);
-        });
+        return StreamBufferUpload(raw_pointer, size, alignment);
     }
 
     void Map(std::size_t max_size) {
@@ -430,11 +424,11 @@ private:
         map->MarkAsModified(false, 0);
     }
 
-    template <typename Callable>
-    BufferInfo StreamBufferUpload(std::size_t size, std::size_t alignment, Callable&& callable) {
+    BufferInfo StreamBufferUpload(const void* raw_pointer, std::size_t size,
+                                  std::size_t alignment) {
         AlignBuffer(alignment);
         const std::size_t uploaded_offset = buffer_offset;
-        callable(buffer_ptr);
+        std::memcpy(buffer_ptr, raw_pointer, size);
 
         buffer_ptr += size;
         buffer_offset += size;

src/video_core/engines/maxwell_3d.cpp

@@ -25,8 +25,9 @@ constexpr u32 MacroRegistersStart = 0xE00;
 Maxwell3D::Maxwell3D(Core::System& system, VideoCore::RasterizerInterface& rasterizer,
                      MemoryManager& memory_manager)
     : system{system}, rasterizer{rasterizer}, memory_manager{memory_manager},
-      macro_engine{GetMacroEngine(*this)}, upload_state{memory_manager, regs.upload} {
+      macro_interpreter{*this}, upload_state{memory_manager, regs.upload} {
     dirty.flags.flip();
+
     InitializeRegisterDefaults();
 }
 
@@ -105,11 +106,7 @@ void Maxwell3D::InitializeRegisterDefaults() {
     regs.rasterize_enable = 1;
     regs.rt_separate_frag_data = 1;
     regs.framebuffer_srgb = 1;
-    regs.line_width_aliased = 1.0f;
-    regs.line_width_smooth = 1.0f;
     regs.front_face = Maxwell3D::Regs::FrontFace::ClockWise;
-    regs.polygon_mode_back = Maxwell3D::Regs::PolygonMode::Fill;
-    regs.polygon_mode_front = Maxwell3D::Regs::PolygonMode::Fill;
 
     shadow_state = regs;
 
@@ -119,7 +116,7 @@ void Maxwell3D::InitializeRegisterDefaults() {
     mme_inline[MAXWELL3D_REG_INDEX(index_array.count)] = true;
 }
 
-void Maxwell3D::CallMacroMethod(u32 method, const std::vector<u32>& parameters) {
+void Maxwell3D::CallMacroMethod(u32 method, std::size_t num_parameters, const u32* parameters) {
     // Reset the current macro.
     executing_macro = 0;
 
@@ -128,7 +125,7 @@ void Maxwell3D::CallMacroMethod(u32 method, const std::vector<u32>& parameters)
         ((method - MacroRegistersStart) >> 1) % static_cast<u32>(macro_positions.size());
 
     // Execute the current macro.
-    macro_engine->Execute(macro_positions[entry], parameters);
+    macro_interpreter.Execute(macro_positions[entry], num_parameters, parameters);
     if (mme_draw.current_mode != MMEDrawMode::Undefined) {
         FlushMMEInlineDraw();
     }
@@ -164,7 +161,7 @@ void Maxwell3D::CallMethod(u32 method, u32 method_argument, bool is_last_call) {
 
         // Call the macro when there are no more parameters in the command buffer
         if (is_last_call) {
-            CallMacroMethod(executing_macro, macro_params);
+            CallMacroMethod(executing_macro, macro_params.size(), macro_params.data());
             macro_params.clear();
         }
         return;
@@ -200,7 +197,7 @@ void Maxwell3D::CallMethod(u32 method, u32 method_argument, bool is_last_call) {
         break;
     }
     case MAXWELL3D_REG_INDEX(macros.data): {
-        macro_engine->AddCode(regs.macros.upload_address, arg);
+        ProcessMacroUpload(arg);
         break;
     }
     case MAXWELL3D_REG_INDEX(macros.bind): {
@@ -309,7 +306,7 @@ void Maxwell3D::CallMultiMethod(u32 method, const u32* base_start, u32 amount,
 
         // Call the macro when there are no more parameters in the command buffer
         if (amount == methods_pending) {
-            CallMacroMethod(executing_macro, macro_params);
+            CallMacroMethod(executing_macro, macro_params.size(), macro_params.data());
             macro_params.clear();
         }
         return;
@@ -423,7 +420,9 @@ void Maxwell3D::FlushMMEInlineDraw() {
 }
 
 void Maxwell3D::ProcessMacroUpload(u32 data) {
-    macro_engine->AddCode(regs.macros.upload_address++, data);
+    ASSERT_MSG(regs.macros.upload_address < macro_memory.size(),
+               "upload_address exceeded macro_memory size!");
+    macro_memory[regs.macros.upload_address++] = data;
 }
 
 void Maxwell3D::ProcessMacroBind(u32 data) {

src/video_core/engines/maxwell_3d.h

@@ -23,7 +23,7 @@
 #include "video_core/engines/engine_upload.h"
 #include "video_core/engines/shader_type.h"
 #include "video_core/gpu.h"
-#include "video_core/macro/macro.h"
+#include "video_core/macro_interpreter.h"
 #include "video_core/textures/texture.h"
 
 namespace Core {
@@ -1411,6 +1411,15 @@ public:
 
     const VideoCore::GuestDriverProfile& AccessGuestDriverProfile() const override;
 
+    /// Memory for macro code - it's undetermined how big this is, however 1MB is much larger than
+    /// we've seen used.
+    using MacroMemory = std::array<u32, 0x40000>;
+
+    /// Gets a reference to macro memory.
+    const MacroMemory& GetMacroMemory() const {
+        return macro_memory;
+    }
+
     bool ShouldExecute() const {
         return execute_on;
     }
@@ -1459,13 +1468,16 @@ private:
 
     std::array<bool, Regs::NUM_REGS> mme_inline{};
 
+    /// Memory for macro code
+    MacroMemory macro_memory;
+
     /// Macro method that is currently being executed / being fed parameters.
     u32 executing_macro = 0;
     /// Parameters that have been submitted to the macro call so far.
     std::vector<u32> macro_params;
 
     /// Interpreter for the macro codes uploaded to the GPU.
-    std::unique_ptr<MacroEngine> macro_engine;
+    MacroInterpreter macro_interpreter;
 
     static constexpr u32 null_cb_data = 0xFFFFFFFF;
     struct {
@@ -1494,7 +1506,7 @@ private:
      * @param num_parameters Number of arguments
      * @param parameters Arguments to the method call
      */
-    void CallMacroMethod(u32 method, const std::vector<u32>& parameters);
+    void CallMacroMethod(u32 method, std::size_t num_parameters, const u32* parameters);
 
     /// Handles writes to the macro uploading register.
     void ProcessMacroUpload(u32 data);

src/video_core/macro/macro.cpp

@@ -1,45 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/assert.h"
-#include "common/logging/log.h"
-#include "core/settings.h"
-#include "video_core/macro/macro.h"
-#include "video_core/macro/macro_interpreter.h"
-#include "video_core/macro/macro_jit_x64.h"
-
-namespace Tegra {
-
-void MacroEngine::AddCode(u32 method, u32 data) {
-    uploaded_macro_code[method].push_back(data);
-}
-
-void MacroEngine::Execute(u32 method, const std::vector<u32>& parameters) {
-    auto compiled_macro = macro_cache.find(method);
-    if (compiled_macro != macro_cache.end()) {
-        compiled_macro->second->Execute(parameters, method);
-    } else {
-        // Macro not compiled, check if it's uploaded and if so, compile it
-        auto macro_code = uploaded_macro_code.find(method);
-        if (macro_code == uploaded_macro_code.end()) {
-            UNREACHABLE_MSG("Macro 0x{0:x} was not uploaded", method);
-            return;
-        }
-        macro_cache[method] = Compile(macro_code->second);
-        macro_cache[method]->Execute(parameters, method);
-    }
-}
-
-std::unique_ptr<MacroEngine> GetMacroEngine(Engines::Maxwell3D& maxwell3d) {
-    if (Settings::values.disable_macro_jit) {
-        return std::make_unique<MacroInterpreter>(maxwell3d);
-    }
-#ifdef ARCHITECTURE_x86_64
-    return std::make_unique<MacroJITx64>(maxwell3d);
-#else
-    return std::make_unique<MacroInterpreter>(maxwell3d);
-#endif
-}
-
-} // namespace Tegra

src/video_core/macro/macro.h

@@ -1,128 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <memory>
-#include <unordered_map>
-#include <vector>
-#include "common/bit_field.h"
-#include "common/common_types.h"
-
-namespace Tegra {
-namespace Engines {
-class Maxwell3D;
-}
-namespace Macro {
-constexpr std::size_t NUM_MACRO_REGISTERS = 8;
-enum class Operation : u32 {
-    ALU = 0,
-    AddImmediate = 1,
-    ExtractInsert = 2,
-    ExtractShiftLeftImmediate = 3,
-    ExtractShiftLeftRegister = 4,
-    Read = 5,
-    Unused = 6, // This operation doesn't seem to be a valid encoding.
-    Branch = 7,
-};
-
-enum class ALUOperation : u32 {
-    Add = 0,
-    AddWithCarry = 1,
-    Subtract = 2,
-    SubtractWithBorrow = 3,
-    // Operations 4-7 don't seem to be valid encodings.
-    Xor = 8,
-    Or = 9,
-    And = 10,
-    AndNot = 11,
-    Nand = 12
-};
-
-enum class ResultOperation : u32 {
-    IgnoreAndFetch = 0,
-    Move = 1,
-    MoveAndSetMethod = 2,
-    FetchAndSend = 3,
-    MoveAndSend = 4,
-    FetchAndSetMethod = 5,
-    MoveAndSetMethodFetchAndSend = 6,
-    MoveAndSetMethodSend = 7
-};
-
-enum class BranchCondition : u32 {
-    Zero = 0,
-    NotZero = 1,
-};
-
-union Opcode {
-    u32 raw;
-    BitField<0, 3, Operation> operation;
-    BitField<4, 3, ResultOperation> result_operation;
-    BitField<4, 1, BranchCondition> branch_condition;
-    // If set on a branch, then the branch doesn't have a delay slot.
-    BitField<5, 1, u32> branch_annul;
-    BitField<7, 1, u32> is_exit;
-    BitField<8, 3, u32> dst;
-    BitField<11, 3, u32> src_a;
-    BitField<14, 3, u32> src_b;
-    // The signed immediate overlaps the second source operand and the alu operation.
-    BitField<14, 18, s32> immediate;
-
-    BitField<17, 5, ALUOperation> alu_operation;
-
-    // Bitfield instructions data
-    BitField<17, 5, u32> bf_src_bit;
-    BitField<22, 5, u32> bf_size;
-    BitField<27, 5, u32> bf_dst_bit;
-
-    u32 GetBitfieldMask() const {
-        return (1 << bf_size) - 1;
-    }
-
-    s32 GetBranchTarget() const {
-        return static_cast<s32>(immediate * sizeof(u32));
-    }
-};
-
-union MethodAddress {
-    u32 raw;
-    BitField<0, 12, u32> address;
-    BitField<12, 6, u32> increment;
-};
-
-} // namespace Macro
-
-class CachedMacro {
-public:
-    virtual ~CachedMacro() = default;
-    /**
-     * Executes the macro code with the specified input parameters.
-     * @param code The macro byte code to execute
-     * @param parameters The parameters of the macro
-     */
-    virtual void Execute(const std::vector<u32>& parameters, u32 method) = 0;
-};
-
-class MacroEngine {
-public:
-    virtual ~MacroEngine() = default;
-
-    // Store the uploaded macro code to compile them when they're called.
-    void AddCode(u32 method, u32 data);
-
-    // Compiles the macro if its not in the cache, and executes the compiled macro
-    void Execute(u32 method, const std::vector<u32>& parameters);
-
-protected:
-    virtual std::unique_ptr<CachedMacro> Compile(const std::vector<u32>& code) = 0;
-
-private:
-    std::unordered_map<u32, std::unique_ptr<CachedMacro>> macro_cache;
-    std::unordered_map<u32, std::vector<u32>> uploaded_macro_code;
-};
-
-std::unique_ptr<MacroEngine> GetMacroEngine(Engines::Maxwell3D& maxwell3d);
-
-} // namespace Tegra

src/video_core/macro/macro_jit_x64.cpp

@@ -1,640 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/assert.h"
-#include "common/logging/log.h"
-#include "common/microprofile.h"
-#include "common/x64/xbyak_util.h"
-#include "video_core/engines/maxwell_3d.h"
-#include "video_core/macro/macro_interpreter.h"
-#include "video_core/macro/macro_jit_x64.h"
-
-MICROPROFILE_DEFINE(MacroJitCompile, "GPU", "Compile macro JIT", MP_RGB(173, 255, 47));
-MICROPROFILE_DEFINE(MacroJitExecute, "GPU", "Execute macro JIT", MP_RGB(255, 255, 0));
-
-namespace Tegra {
-static const Xbyak::Reg64 PARAMETERS = Xbyak::util::r9;
-static const Xbyak::Reg64 REGISTERS = Xbyak::util::r10;
-static const Xbyak::Reg64 STATE = Xbyak::util::r11;
-static const Xbyak::Reg64 NEXT_PARAMETER = Xbyak::util::r12;
-static const Xbyak::Reg32 RESULT = Xbyak::util::r13d;
-static const Xbyak::Reg64 RESULT_64 = Xbyak::util::r13;
-static const Xbyak::Reg32 METHOD_ADDRESS = Xbyak::util::r14d;
-static const Xbyak::Reg64 METHOD_ADDRESS_64 = Xbyak::util::r14;
-static const Xbyak::Reg64 BRANCH_HOLDER = Xbyak::util::r15;
-
-static const std::bitset<32> PERSISTENT_REGISTERS = Common::X64::BuildRegSet({
-    PARAMETERS,
-    REGISTERS,
-    STATE,
-    NEXT_PARAMETER,
-    RESULT,
-    METHOD_ADDRESS,
-    BRANCH_HOLDER,
-});
-
-MacroJITx64::MacroJITx64(Engines::Maxwell3D& maxwell3d) : maxwell3d(maxwell3d) {}
-
-std::unique_ptr<CachedMacro> MacroJITx64::Compile(const std::vector<u32>& code) {
-    return std::make_unique<MacroJITx64Impl>(maxwell3d, code);
-}
-
-MacroJITx64Impl::MacroJITx64Impl(Engines::Maxwell3D& maxwell3d, const std::vector<u32>& code)
-    : Xbyak::CodeGenerator(MAX_CODE_SIZE), code(code), maxwell3d(maxwell3d) {
-    Compile();
-}
-
-MacroJITx64Impl::~MacroJITx64Impl() = default;
-
-void MacroJITx64Impl::Execute(const std::vector<u32>& parameters, u32 method) {
-    MICROPROFILE_SCOPE(MacroJitExecute);
-    ASSERT_OR_EXECUTE(program != nullptr, { return; });
-    JITState state{};
-    state.maxwell3d = &maxwell3d;
-    state.registers = {};
-    state.parameters = parameters.data();
-    program(&state);
-}
-
-void MacroJITx64Impl::Compile_ALU(Macro::Opcode opcode) {
-    const bool is_a_zero = opcode.src_a == 0;
-    const bool is_b_zero = opcode.src_b == 0;
-    const bool valid_operation = !is_a_zero && !is_b_zero;
-    const bool is_move_operation = !is_a_zero && is_b_zero;
-    const bool has_zero_register = is_a_zero || is_b_zero;
-
-    Xbyak::Reg64 src_a;
-    Xbyak::Reg32 src_b;
-
-    if (!optimizer.zero_reg_skip) {
-        src_a = Compile_GetRegister(opcode.src_a, RESULT_64);
-        src_b = Compile_GetRegister(opcode.src_b, ebx);
-    } else {
-        if (!is_a_zero) {
-            src_a = Compile_GetRegister(opcode.src_a, RESULT_64);
-        }
-        if (!is_b_zero) {
-            src_b = Compile_GetRegister(opcode.src_b, ebx);
-        }
-    }
-    Xbyak::Label skip_carry{};
-
-    bool has_emitted = false;
-
-    switch (opcode.alu_operation) {
-    case Macro::ALUOperation::Add:
-        if (optimizer.zero_reg_skip) {
-            if (valid_operation) {
-                add(src_a, src_b);
-            }
-        } else {
-            add(src_a, src_b);
-        }
-
-        if (!optimizer.can_skip_carry) {
-            setc(byte[STATE + offsetof(JITState, carry_flag)]);
-        }
-        break;
-    case Macro::ALUOperation::AddWithCarry:
-        bt(dword[STATE + offsetof(JITState, carry_flag)], 0);
-        adc(src_a, src_b);
-        setc(byte[STATE + offsetof(JITState, carry_flag)]);
-        break;
-    case Macro::ALUOperation::Subtract:
-        if (optimizer.zero_reg_skip) {
-            if (valid_operation) {
-                sub(src_a, src_b);
-                has_emitted = true;
-            }
-        } else {
-            sub(src_a, src_b);
-            has_emitted = true;
-        }
-        if (!optimizer.can_skip_carry && has_emitted) {
-            setc(byte[STATE + offsetof(JITState, carry_flag)]);
-        }
-        break;
-    case Macro::ALUOperation::SubtractWithBorrow:
-        bt(dword[STATE + offsetof(JITState, carry_flag)], 0);
-        sbb(src_a, src_b);
-        setc(byte[STATE + offsetof(JITState, carry_flag)]);
-        break;
-    case Macro::ALUOperation::Xor:
-        if (optimizer.zero_reg_skip) {
-            if (valid_operation) {
-                xor_(src_a, src_b);
-            }
-        } else {
-            xor_(src_a, src_b);
-        }
-        break;
-    case Macro::ALUOperation::Or:
-        if (optimizer.zero_reg_skip) {
-            if (valid_operation) {
-                or_(src_a, src_b);
-            }
-        } else {
-            or_(src_a, src_b);
-        }
-        break;
-    case Macro::ALUOperation::And:
-        if (optimizer.zero_reg_skip) {
-            if (!has_zero_register) {
-                and_(src_a, src_b);
-            }
-        } else {
-            and_(src_a, src_b);
-        }
-        break;
-    case Macro::ALUOperation::AndNot:
-        if (optimizer.zero_reg_skip) {
-            if (!is_a_zero) {
-                not_(src_b);
-                and_(src_a, src_b);
-            }
-        } else {
-            not_(src_b);
-            and_(src_a, src_b);
-        }
-        break;
-    case Macro::ALUOperation::Nand:
-        if (optimizer.zero_reg_skip) {
-            if (!is_a_zero) {
-                and_(src_a, src_b);
-                not_(src_a);
-            }
-        } else {
-            and_(src_a, src_b);
-            not_(src_a);
-        }
-        break;
-    default:
-        UNIMPLEMENTED_MSG("Unimplemented ALU operation {}",
-                          static_cast<std::size_t>(opcode.alu_operation.Value()));
-        break;
-    }
-    Compile_ProcessResult(opcode.result_operation, opcode.dst);
-}
-
-void MacroJITx64Impl::Compile_AddImmediate(Macro::Opcode opcode) {
-    if (optimizer.skip_dummy_addimmediate) {
-        // Games tend to use this as an exit instruction placeholder. It's to encode an instruction
-        // without doing anything. In our case we can just not emit anything.
-        if (opcode.result_operation == Macro::ResultOperation::Move && opcode.dst == 0) {
-            return;
-        }
-    }
-    // Check for redundant moves
-    if (optimizer.optimize_for_method_move &&
-        opcode.result_operation == Macro::ResultOperation::MoveAndSetMethod) {
-        if (next_opcode.has_value()) {
-            const auto next = *next_opcode;
-            if (next.result_operation == Macro::ResultOperation::MoveAndSetMethod) {
-                return;
-            }
-        }
-    }
-    if (optimizer.zero_reg_skip && opcode.src_a == 0) {
-        if (opcode.immediate == 0) {
-            xor_(RESULT, RESULT);
-        } else {
-            mov(RESULT, opcode.immediate);
-        }
-    } else {
-        auto result = Compile_GetRegister(opcode.src_a, RESULT);
-        if (opcode.immediate > 2) {
-            add(result, opcode.immediate);
-        } else if (opcode.immediate == 1) {
-            inc(result);
-        } else if (opcode.immediate < 0) {
-            sub(result, opcode.immediate * -1);
-        }
-    }
-    Compile_ProcessResult(opcode.result_operation, opcode.dst);
-}
-
-void MacroJITx64Impl::Compile_ExtractInsert(Macro::Opcode opcode) {
-    auto dst = Compile_GetRegister(opcode.src_a, RESULT);
-    auto src = Compile_GetRegister(opcode.src_b, eax);
-
-    if (opcode.bf_src_bit != 0 && opcode.bf_src_bit != 31) {
-        shr(src, opcode.bf_src_bit);
-    } else if (opcode.bf_src_bit == 31) {
-        xor_(src, src);
-    }
-    // Don't bother masking the whole register since we're using a 32 bit register
-    if (opcode.bf_size != 31 && opcode.bf_size != 0) {
-        and_(src, opcode.GetBitfieldMask());
-    } else if (opcode.bf_size == 0) {
-        xor_(src, src);
-    }
-    if (opcode.bf_dst_bit != 31 && opcode.bf_dst_bit != 0) {
-        shl(src, opcode.bf_dst_bit);
-    } else if (opcode.bf_dst_bit == 31) {
-        xor_(src, src);
-    }
-
-    const u32 mask = ~(opcode.GetBitfieldMask() << opcode.bf_dst_bit);
-    if (mask != 0xffffffff) {
-        and_(dst, mask);
-    }
-    or_(dst, src);
-    Compile_ProcessResult(opcode.result_operation, opcode.dst);
-}
-
-void MacroJITx64Impl::Compile_ExtractShiftLeftImmediate(Macro::Opcode opcode) {
-    auto dst = Compile_GetRegister(opcode.src_a, eax);
-    auto src = Compile_GetRegister(opcode.src_b, RESULT);
-
-    shr(src, al);
-    if (opcode.bf_size != 0 && opcode.bf_size != 31) {
-        and_(src, opcode.GetBitfieldMask());
-    } else if (opcode.bf_size == 0) {
-        xor_(src, src);
-    }
-
-    if (opcode.bf_dst_bit != 0 && opcode.bf_dst_bit != 31) {
-        shl(src, opcode.bf_dst_bit);
-    } else if (opcode.bf_dst_bit == 31) {
-        xor_(src, src);
-    }
-    Compile_ProcessResult(opcode.result_operation, opcode.dst);
-}
-
-void MacroJITx64Impl::Compile_ExtractShiftLeftRegister(Macro::Opcode opcode) {
-    auto dst = Compile_GetRegister(opcode.src_a, eax);
-    auto src = Compile_GetRegister(opcode.src_b, RESULT);
-
-    if (opcode.bf_src_bit != 0) {
-        shr(src, opcode.bf_src_bit);
-    }
-
-    if (opcode.bf_size != 31) {
-        and_(src, opcode.GetBitfieldMask());
-    }
-    shl(src, al);
-    Compile_ProcessResult(opcode.result_operation, opcode.dst);
-}
-
-static u32 Read(Engines::Maxwell3D* maxwell3d, u32 method) {
-    return maxwell3d->GetRegisterValue(method);
-}
-
-static void Send(Engines::Maxwell3D* maxwell3d, Macro::MethodAddress method_address, u32 value) {
-    maxwell3d->CallMethodFromMME(method_address.address, value);
-}
-
-void MacroJITx64Impl::Compile_Read(Macro::Opcode opcode) {
-    if (optimizer.zero_reg_skip && opcode.src_a == 0) {
-        if (opcode.immediate == 0) {
-            xor_(RESULT, RESULT);
-        } else {
-            mov(RESULT, opcode.immediate);
-        }
-    } else {
-        auto result = Compile_GetRegister(opcode.src_a, RESULT);
-        if (opcode.immediate > 2) {
-            add(result, opcode.immediate);
-        } else if (opcode.immediate == 1) {
-            inc(result);
-        } else if (opcode.immediate < 0) {
-            sub(result, opcode.immediate * -1);
-        }
-    }
-    Common::X64::ABI_PushRegistersAndAdjustStackGPS(*this, PersistentCallerSavedRegs(), 0);
-    mov(Common::X64::ABI_PARAM1, qword[STATE]);
-    mov(Common::X64::ABI_PARAM2, RESULT);
-    Common::X64::CallFarFunction(*this, &Read);
-    Common::X64::ABI_PopRegistersAndAdjustStackGPS(*this, PersistentCallerSavedRegs(), 0);
-    mov(RESULT, Common::X64::ABI_RETURN.cvt32());
-    Compile_ProcessResult(opcode.result_operation, opcode.dst);
-}
-
-void Tegra::MacroJITx64Impl::Compile_Send(Xbyak::Reg32 value) {
-    Common::X64::ABI_PushRegistersAndAdjustStackGPS(*this, PersistentCallerSavedRegs(), 0);
-    mov(Common::X64::ABI_PARAM1, qword[STATE]);
-    mov(Common::X64::ABI_PARAM2, METHOD_ADDRESS);
-    mov(Common::X64::ABI_PARAM3, value);
-    Common::X64::CallFarFunction(*this, &Send);
-    Common::X64::ABI_PopRegistersAndAdjustStackGPS(*this, PersistentCallerSavedRegs(), 0);
-
-    Xbyak::Label dont_process{};
-    // Get increment
-    test(METHOD_ADDRESS, 0x3f000);
-    // If zero, method address doesn't update
-    je(dont_process);
-
-    mov(ecx, METHOD_ADDRESS);
-    and_(METHOD_ADDRESS, 0xfff);
-    shr(ecx, 12);
-    and_(ecx, 0x3f);
-    lea(eax, ptr[rcx + METHOD_ADDRESS_64]);
-    sal(ecx, 12);
-    or_(eax, ecx);
-
-    mov(METHOD_ADDRESS, eax);
-
-    L(dont_process);
-}
-
-void Tegra::MacroJITx64Impl::Compile_Branch(Macro::Opcode opcode) {
-    ASSERT_MSG(!is_delay_slot, "Executing a branch in a delay slot is not valid");
-    const s32 jump_address =
-        static_cast<s32>(pc) + static_cast<s32>(opcode.GetBranchTarget() / sizeof(s32));
-
-    Xbyak::Label end;
-    auto value = Compile_GetRegister(opcode.src_a, eax);
-    test(value, value);
-    if (optimizer.has_delayed_pc) {
-        switch (opcode.branch_condition) {
-        case Macro::BranchCondition::Zero:
-            jne(end, T_NEAR);
-            break;
-        case Macro::BranchCondition::NotZero:
-            je(end, T_NEAR);
-            break;
-        }
-
-        if (opcode.branch_annul) {
-            xor_(BRANCH_HOLDER, BRANCH_HOLDER);
-            jmp(labels[jump_address], T_NEAR);
-        } else {
-            Xbyak::Label handle_post_exit{};
-            Xbyak::Label skip{};
-            jmp(skip, T_NEAR);
-            if (opcode.is_exit) {
-                L(handle_post_exit);
-                // Execute 1 instruction
-                mov(BRANCH_HOLDER, end_of_code);
-                // Jump to next instruction to skip delay slot check
-                jmp(labels[jump_address], T_NEAR);
-            } else {
-                L(handle_post_exit);
-                xor_(BRANCH_HOLDER, BRANCH_HOLDER);
-                jmp(labels[jump_address], T_NEAR);
-            }
-            L(skip);
-            mov(BRANCH_HOLDER, handle_post_exit);
-            jmp(delay_skip[pc], T_NEAR);
-        }
-    } else {
-        switch (opcode.branch_condition) {
-        case Macro::BranchCondition::Zero:
-            je(labels[jump_address], T_NEAR);
-            break;
-        case Macro::BranchCondition::NotZero:
-            jne(labels[jump_address], T_NEAR);
-            break;
-        }
-    }
-
-    L(end);
-}
-
-void Tegra::MacroJITx64Impl::Optimizer_ScanFlags() {
-    optimizer.can_skip_carry = true;
-    optimizer.has_delayed_pc = false;
-    for (auto raw_op : code) {
-        Macro::Opcode op{};
-        op.raw = raw_op;
-
-        if (op.operation == Macro::Operation::ALU) {
-            // Scan for any ALU operations which actually use the carry flag, if they don't exist in
-            // our current code we can skip emitting the carry flag handling operations
-            if (op.alu_operation == Macro::ALUOperation::AddWithCarry ||
-                op.alu_operation == Macro::ALUOperation::SubtractWithBorrow) {
-                optimizer.can_skip_carry = false;
-            }
-        }
-
-        if (op.operation == Macro::Operation::Branch) {
-            if (!op.branch_annul) {
-                optimizer.has_delayed_pc = true;
-            }
-        }
-    }
-}
-
-void MacroJITx64Impl::Compile() {
-    MICROPROFILE_SCOPE(MacroJitCompile);
-    bool keep_executing = true;
-    labels.fill(Xbyak::Label());
-
-    Common::X64::ABI_PushRegistersAndAdjustStackGPS(*this, Common::X64::ABI_ALL_CALLEE_SAVED, 8);
-    // JIT state
-    mov(STATE, Common::X64::ABI_PARAM1);
-    mov(PARAMETERS, qword[Common::X64::ABI_PARAM1 +
-                          static_cast<Xbyak::uint32>(offsetof(JITState, parameters))]);
-    mov(REGISTERS, Common::X64::ABI_PARAM1);
-    add(REGISTERS, static_cast<Xbyak::uint32>(offsetof(JITState, registers)));
-    xor_(RESULT, RESULT);
-    xor_(METHOD_ADDRESS, METHOD_ADDRESS);
-    xor_(NEXT_PARAMETER, NEXT_PARAMETER);
-    xor_(BRANCH_HOLDER, BRANCH_HOLDER);
-
-    mov(dword[REGISTERS + 4], Compile_FetchParameter());
-
-    // Track get register for zero registers and mark it as no-op
-    optimizer.zero_reg_skip = true;
-
-    // AddImmediate tends to be used as a NOP instruction, if we detect this we can
-    // completely skip the entire code path and no emit anything
-    optimizer.skip_dummy_addimmediate = true;
-
-    // SMO tends to emit a lot of unnecessary method moves, we can mitigate this by only emitting
-    // one if our register isn't "dirty"
-    optimizer.optimize_for_method_move = true;
-
-    // Check to see if we can skip emitting certain instructions
-    Optimizer_ScanFlags();
-
-    const u32 op_count = static_cast<u32>(code.size());
-    for (u32 i = 0; i < op_count; i++) {
-        if (i < op_count - 1) {
-            pc = i + 1;
-            next_opcode = GetOpCode();
-        } else {
-            next_opcode = {};
-        }
-        pc = i;
-        Compile_NextInstruction();
-    }
-
-    L(end_of_code);
-
-    Common::X64::ABI_PopRegistersAndAdjustStackGPS(*this, Common::X64::ABI_ALL_CALLEE_SAVED, 8);
-    ret();
-    ready();
-    program = getCode<ProgramType>();
-}
-
-bool MacroJITx64Impl::Compile_NextInstruction() {
-    const auto opcode = GetOpCode();
-    if (labels[pc].getAddress()) {
-        return false;
-    }
-
-    L(labels[pc]);
-
-    switch (opcode.operation) {
-    case Macro::Operation::ALU:
-        Compile_ALU(opcode);
-        break;
-    case Macro::Operation::AddImmediate:
-        Compile_AddImmediate(opcode);
-        break;
-    case Macro::Operation::ExtractInsert:
-        Compile_ExtractInsert(opcode);
-        break;
-    case Macro::Operation::ExtractShiftLeftImmediate:
-        Compile_ExtractShiftLeftImmediate(opcode);
-        break;
-    case Macro::Operation::ExtractShiftLeftRegister:
-        Compile_ExtractShiftLeftRegister(opcode);
-        break;
-    case Macro::Operation::Read:
-        Compile_Read(opcode);
-        break;
-    case Macro::Operation::Branch:
-        Compile_Branch(opcode);
-        break;
-    default:
-        UNIMPLEMENTED_MSG("Unimplemented opcode {}", opcode.operation.Value());
-        break;
-    }
-
-    if (optimizer.has_delayed_pc) {
-        if (opcode.is_exit) {
-            mov(rax, end_of_code);
-            test(BRANCH_HOLDER, BRANCH_HOLDER);
-            cmove(BRANCH_HOLDER, rax);
-            // Jump to next instruction to skip delay slot check
-            je(labels[pc + 1], T_NEAR);
-        } else {
-            // TODO(ogniK): Optimize delay slot branching
-            Xbyak::Label no_delay_slot{};
-            test(BRANCH_HOLDER, BRANCH_HOLDER);
-            je(no_delay_slot, T_NEAR);
-            mov(rax, BRANCH_HOLDER);
-            xor_(BRANCH_HOLDER, BRANCH_HOLDER);
-            jmp(rax);
-            L(no_delay_slot);
-        }
-        L(delay_skip[pc]);
-        if (opcode.is_exit) {
-            return false;
-        }
-    } else {
-        test(BRANCH_HOLDER, BRANCH_HOLDER);
-        jne(end_of_code, T_NEAR);
-        if (opcode.is_exit) {
-            inc(BRANCH_HOLDER);
-            return false;
-        }
-    }
-    return true;
-}
-
-Xbyak::Reg32 Tegra::MacroJITx64Impl::Compile_FetchParameter() {
-    mov(eax, dword[PARAMETERS + NEXT_PARAMETER * sizeof(u32)]);
-    inc(NEXT_PARAMETER);
-    return eax;
-}
-
-Xbyak::Reg32 MacroJITx64Impl::Compile_GetRegister(u32 index, Xbyak::Reg32 dst) {
-    if (index == 0) {
-        // Register 0 is always zero
-        xor_(dst, dst);
-    } else {
-        mov(dst, dword[REGISTERS + index * sizeof(u32)]);
-    }
-
-    return dst;
-}
-
-Xbyak::Reg64 Tegra::MacroJITx64Impl::Compile_GetRegister(u32 index, Xbyak::Reg64 dst) {
-    if (index == 0) {
-        // Register 0 is always zero
-        xor_(dst, dst);
-    } else {
-        mov(dst, dword[REGISTERS + index * sizeof(u32)]);
-    }
-
-    return dst;
-}
-
-void Tegra::MacroJITx64Impl::Compile_WriteCarry(Xbyak::Reg64 dst) {
-    Xbyak::Label zero{}, end{};
-    xor_(ecx, ecx);
-    shr(dst, 32);
-    setne(cl);
-    mov(dword[STATE + offsetof(JITState, carry_flag)], ecx);
-}
-
-void MacroJITx64Impl::Compile_ProcessResult(Macro::ResultOperation operation, u32 reg) {
-    auto SetRegister = [=](u32 reg, Xbyak::Reg32 result) {
-        // Register 0 is supposed to always return 0. NOP is implemented as a store to the zero
-        // register.
-        if (reg == 0) {
-            return;
-        }
-        mov(dword[REGISTERS + reg * sizeof(u32)], result);
-    };
-    auto SetMethodAddress = [=](Xbyak::Reg32 reg) { mov(METHOD_ADDRESS, reg); };
-
-    switch (operation) {
-    case Macro::ResultOperation::IgnoreAndFetch:
-        SetRegister(reg, Compile_FetchParameter());
-        break;
-    case Macro::ResultOperation::Move:
-        SetRegister(reg, RESULT);
-        break;
-    case Macro::ResultOperation::MoveAndSetMethod:
-        SetRegister(reg, RESULT);
-        SetMethodAddress(RESULT);
-        break;
-    case Macro::ResultOperation::FetchAndSend:
-        // Fetch parameter and send result.
-        SetRegister(reg, Compile_FetchParameter());
-        Compile_Send(RESULT);
-        break;
-    case Macro::ResultOperation::MoveAndSend:
-        // Move and send result.
-        SetRegister(reg, RESULT);
-        Compile_Send(RESULT);
-        break;
-    case Macro::ResultOperation::FetchAndSetMethod:
-        // Fetch parameter and use result as Method Address.
-        SetRegister(reg, Compile_FetchParameter());
-        SetMethodAddress(RESULT);
-        break;
-    case Macro::ResultOperation::MoveAndSetMethodFetchAndSend:
-        // Move result and use as Method Address, then fetch and send parameter.
-        SetRegister(reg, RESULT);
-        SetMethodAddress(RESULT);
-        Compile_Send(Compile_FetchParameter());
-        break;
-    case Macro::ResultOperation::MoveAndSetMethodSend:
-        // Move result and use as Method Address, then send bits 12:17 of result.
-        SetRegister(reg, RESULT);
-        SetMethodAddress(RESULT);
-        shr(RESULT, 12);
-        and_(RESULT, 0b111111);
-        Compile_Send(RESULT);
-        break;
-    default:
-        UNIMPLEMENTED_MSG("Unimplemented macro operation {}", static_cast<std::size_t>(operation));
-    }
-}
-
-Macro::Opcode MacroJITx64Impl::GetOpCode() const {
-    ASSERT(pc < code.size());
-    return {code[pc]};
-}
-
-std::bitset<32> MacroJITx64Impl::PersistentCallerSavedRegs() const {
-    return PERSISTENT_REGISTERS & Common::X64::ABI_ALL_CALLER_SAVED;
-}
-
-} // namespace Tegra

src/video_core/macro/macro_jit_x64.h

@@ -1,100 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-#include <bitset>
-#include <xbyak.h>
-#include "common/bit_field.h"
-#include "common/common_types.h"
-#include "common/x64/xbyak_abi.h"
-#include "video_core/macro/macro.h"
-
-namespace Tegra {
-
-namespace Engines {
-class Maxwell3D;
-}
-
-/// MAX_CODE_SIZE is arbitrarily chosen based on current booting games
-constexpr size_t MAX_CODE_SIZE = 0x10000;
-
-class MacroJITx64 final : public MacroEngine {
-public:
-    explicit MacroJITx64(Engines::Maxwell3D& maxwell3d);
-
-protected:
-    std::unique_ptr<CachedMacro> Compile(const std::vector<u32>& code) override;
-
-private:
-    Engines::Maxwell3D& maxwell3d;
-};
-
-class MacroJITx64Impl : public Xbyak::CodeGenerator, public CachedMacro {
-public:
-    MacroJITx64Impl(Engines::Maxwell3D& maxwell3d, const std::vector<u32>& code);
-    ~MacroJITx64Impl();
-
-    void Execute(const std::vector<u32>& parameters, u32 method) override;
-
-    void Compile_ALU(Macro::Opcode opcode);
-    void Compile_AddImmediate(Macro::Opcode opcode);
-    void Compile_ExtractInsert(Macro::Opcode opcode);
-    void Compile_ExtractShiftLeftImmediate(Macro::Opcode opcode);
-    void Compile_ExtractShiftLeftRegister(Macro::Opcode opcode);
-    void Compile_Read(Macro::Opcode opcode);
-    void Compile_Branch(Macro::Opcode opcode);
-
-private:
-    void Optimizer_ScanFlags();
-
-    void Compile();
-    bool Compile_NextInstruction();
-
-    Xbyak::Reg32 Compile_FetchParameter();
-    Xbyak::Reg32 Compile_GetRegister(u32 index, Xbyak::Reg32 dst);
-    Xbyak::Reg64 Compile_GetRegister(u32 index, Xbyak::Reg64 dst);
-    void Compile_WriteCarry(Xbyak::Reg64 dst);
-
-    void Compile_ProcessResult(Macro::ResultOperation operation, u32 reg);
-    void Compile_Send(Xbyak::Reg32 value);
-
-    Macro::Opcode GetOpCode() const;
-    std::bitset<32> PersistentCallerSavedRegs() const;
-
-    struct JITState {
-        Engines::Maxwell3D* maxwell3d{};
-        std::array<u32, Macro::NUM_MACRO_REGISTERS> registers{};
-        const u32* parameters{};
-        u32 carry_flag{};
-    };
-    static_assert(offsetof(JITState, maxwell3d) == 0, "Maxwell3D is not at 0x0");
-    using ProgramType = void (*)(JITState*);
-
-    struct OptimizerState {
-        bool can_skip_carry{};
-        bool has_delayed_pc{};
-        bool zero_reg_skip{};
-        bool skip_dummy_addimmediate{};
-        bool optimize_for_method_move{};
-    };
-    OptimizerState optimizer{};
-
-    std::optional<Macro::Opcode> next_opcode{};
-    ProgramType program{nullptr};
-
-    std::array<Xbyak::Label, MAX_CODE_SIZE> labels{};
-    std::array<Xbyak::Label, MAX_CODE_SIZE> delay_skip{};
-    Xbyak::Label end_of_code{};
-
-    bool is_delay_slot{};
-    u32 pc{};
-    std::optional<u32> delayed_pc;
-
-    const std::vector<u32>& code;
-    Engines::Maxwell3D& maxwell3d;
-};
-
-} // namespace Tegra

src/video_core/macro_interpreter.cpp

@@ -1,4 +1,4 @@
-// Copyright 2020 yuzu Emulator Project
+// Copyright 2018 yuzu Emulator Project
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
@@ -6,46 +6,109 @@
 #include "common/logging/log.h"
 #include "common/microprofile.h"
 #include "video_core/engines/maxwell_3d.h"
-#include "video_core/macro/macro_interpreter.h"
+#include "video_core/macro_interpreter.h"
 
 MICROPROFILE_DEFINE(MacroInterp, "GPU", "Execute macro interpreter", MP_RGB(128, 128, 192));
 
 namespace Tegra {
+namespace {
+enum class Operation : u32 {
+    ALU = 0,
+    AddImmediate = 1,
+    ExtractInsert = 2,
+    ExtractShiftLeftImmediate = 3,
+    ExtractShiftLeftRegister = 4,
+    Read = 5,
+    Unused = 6, // This operation doesn't seem to be a valid encoding.
+    Branch = 7,
+};
+} // Anonymous namespace
+
+enum class MacroInterpreter::ALUOperation : u32 {
+    Add = 0,
+    AddWithCarry = 1,
+    Subtract = 2,
+    SubtractWithBorrow = 3,
+    // Operations 4-7 don't seem to be valid encodings.
+    Xor = 8,
+    Or = 9,
+    And = 10,
+    AndNot = 11,
+    Nand = 12
+};
+
+enum class MacroInterpreter::ResultOperation : u32 {
+    IgnoreAndFetch = 0,
+    Move = 1,
+    MoveAndSetMethod = 2,
+    FetchAndSend = 3,
+    MoveAndSend = 4,
+    FetchAndSetMethod = 5,
+    MoveAndSetMethodFetchAndSend = 6,
+    MoveAndSetMethodSend = 7
+};
+
+enum class MacroInterpreter::BranchCondition : u32 {
+    Zero = 0,
+    NotZero = 1,
+};
+
+union MacroInterpreter::Opcode {
+    u32 raw;
+    BitField<0, 3, Operation> operation;
+    BitField<4, 3, ResultOperation> result_operation;
+    BitField<4, 1, BranchCondition> branch_condition;
+    // If set on a branch, then the branch doesn't have a delay slot.
+    BitField<5, 1, u32> branch_annul;
+    BitField<7, 1, u32> is_exit;
+    BitField<8, 3, u32> dst;
+    BitField<11, 3, u32> src_a;
+    BitField<14, 3, u32> src_b;
+    // The signed immediate overlaps the second source operand and the alu operation.
+    BitField<14, 18, s32> immediate;
+
+    BitField<17, 5, ALUOperation> alu_operation;
+
+    // Bitfield instructions data
+    BitField<17, 5, u32> bf_src_bit;
+    BitField<22, 5, u32> bf_size;
+    BitField<27, 5, u32> bf_dst_bit;
+
+    u32 GetBitfieldMask() const {
+        return (1 << bf_size) - 1;
+    }
+
+    s32 GetBranchTarget() const {
+        return static_cast<s32>(immediate * sizeof(u32));
+    }
+};
+
 MacroInterpreter::MacroInterpreter(Engines::Maxwell3D& maxwell3d) : maxwell3d(maxwell3d) {}
 
-std::unique_ptr<CachedMacro> MacroInterpreter::Compile(const std::vector<u32>& code) {
-    return std::make_unique<MacroInterpreterImpl>(maxwell3d, code);
-}
-
-MacroInterpreterImpl::MacroInterpreterImpl(Engines::Maxwell3D& maxwell3d,
-                                           const std::vector<u32>& code)
-    : maxwell3d(maxwell3d), code(code) {}
-
-void MacroInterpreterImpl::Execute(const std::vector<u32>& parameters, u32 method) {
+void MacroInterpreter::Execute(u32 offset, std::size_t num_parameters, const u32* parameters) {
     MICROPROFILE_SCOPE(MacroInterp);
     Reset();
 
     registers[1] = parameters[0];
-    num_parameters = parameters.size();
 
     if (num_parameters > parameters_capacity) {
         parameters_capacity = num_parameters;
         this->parameters = std::make_unique<u32[]>(num_parameters);
     }
-    std::memcpy(this->parameters.get(), parameters.data(), num_parameters * sizeof(u32));
+    std::memcpy(this->parameters.get(), parameters, num_parameters * sizeof(u32));
     this->num_parameters = num_parameters;
 
     // Execute the code until we hit an exit condition.
     bool keep_executing = true;
     while (keep_executing) {
-        keep_executing = Step(false);
+        keep_executing = Step(offset, false);
     }
 
     // Assert the the macro used all the input parameters
     ASSERT(next_parameter_index == num_parameters);
 }
 
-void MacroInterpreterImpl::Reset() {
+void MacroInterpreter::Reset() {
     registers = {};
     pc = 0;
     delayed_pc = {};
@@ -57,10 +120,10 @@ void MacroInterpreterImpl::Reset() {
     carry_flag = false;
 }
 
-bool MacroInterpreterImpl::Step(bool is_delay_slot) {
+bool MacroInterpreter::Step(u32 offset, bool is_delay_slot) {
     u32 base_address = pc;
 
-    Macro::Opcode opcode = GetOpcode();
+    Opcode opcode = GetOpcode(offset);
     pc += 4;
 
     // Update the program counter if we were delayed
@@ -71,18 +134,18 @@ bool MacroInterpreterImpl::Step(bool is_delay_slot) {
     }
 
     switch (opcode.operation) {
-    case Macro::Operation::ALU: {
+    case Operation::ALU: {
         u32 result = GetALUResult(opcode.alu_operation, GetRegister(opcode.src_a),
                                   GetRegister(opcode.src_b));
         ProcessResult(opcode.result_operation, opcode.dst, result);
         break;
     }
-    case Macro::Operation::AddImmediate: {
+    case Operation::AddImmediate: {
         ProcessResult(opcode.result_operation, opcode.dst,
                       GetRegister(opcode.src_a) + opcode.immediate);
         break;
     }
-    case Macro::Operation::ExtractInsert: {
+    case Operation::ExtractInsert: {
         u32 dst = GetRegister(opcode.src_a);
         u32 src = GetRegister(opcode.src_b);
 
@@ -92,7 +155,7 @@ bool MacroInterpreterImpl::Step(bool is_delay_slot) {
         ProcessResult(opcode.result_operation, opcode.dst, dst);
         break;
     }
-    case Macro::Operation::ExtractShiftLeftImmediate: {
+    case Operation::ExtractShiftLeftImmediate: {
         u32 dst = GetRegister(opcode.src_a);
         u32 src = GetRegister(opcode.src_b);
 
@@ -101,7 +164,7 @@ bool MacroInterpreterImpl::Step(bool is_delay_slot) {
         ProcessResult(opcode.result_operation, opcode.dst, result);
         break;
     }
-    case Macro::Operation::ExtractShiftLeftRegister: {
+    case Operation::ExtractShiftLeftRegister: {
         u32 dst = GetRegister(opcode.src_a);
         u32 src = GetRegister(opcode.src_b);
 
@@ -110,12 +173,12 @@ bool MacroInterpreterImpl::Step(bool is_delay_slot) {
         ProcessResult(opcode.result_operation, opcode.dst, result);
         break;
     }
-    case Macro::Operation::Read: {
+    case Operation::Read: {
         u32 result = Read(GetRegister(opcode.src_a) + opcode.immediate);
         ProcessResult(opcode.result_operation, opcode.dst, result);
         break;
     }
-    case Macro::Operation::Branch: {
+    case Operation::Branch: {
         ASSERT_MSG(!is_delay_slot, "Executing a branch in a delay slot is not valid");
         u32 value = GetRegister(opcode.src_a);
         bool taken = EvaluateBranchCondition(opcode.branch_condition, value);
@@ -128,7 +191,7 @@ bool MacroInterpreterImpl::Step(bool is_delay_slot) {
 
             delayed_pc = base_address + opcode.GetBranchTarget();
             // Execute one more instruction due to the delay slot.
-            return Step(true);
+            return Step(offset, true);
         }
         break;
     }
@@ -141,44 +204,51 @@ bool MacroInterpreterImpl::Step(bool is_delay_slot) {
     // cause an exit if it's executed inside a delay slot.
     if (opcode.is_exit && !is_delay_slot) {
         // Exit has a delay slot, execute the next instruction
-        Step(true);
+        Step(offset, true);
         return false;
     }
 
     return true;
 }
 
-u32 MacroInterpreterImpl::GetALUResult(Macro::ALUOperation operation, u32 src_a, u32 src_b) {
+MacroInterpreter::Opcode MacroInterpreter::GetOpcode(u32 offset) const {
+    const auto& macro_memory{maxwell3d.GetMacroMemory()};
+    ASSERT((pc % sizeof(u32)) == 0);
+    ASSERT((pc + offset) < macro_memory.size() * sizeof(u32));
+    return {macro_memory[offset + pc / sizeof(u32)]};
+}
+
+u32 MacroInterpreter::GetALUResult(ALUOperation operation, u32 src_a, u32 src_b) {
     switch (operation) {
-    case Macro::ALUOperation::Add: {
+    case ALUOperation::Add: {
         const u64 result{static_cast<u64>(src_a) + src_b};
         carry_flag = result > 0xffffffff;
         return static_cast<u32>(result);
     }
-    case Macro::ALUOperation::AddWithCarry: {
+    case ALUOperation::AddWithCarry: {
         const u64 result{static_cast<u64>(src_a) + src_b + (carry_flag ? 1ULL : 0ULL)};
         carry_flag = result > 0xffffffff;
         return static_cast<u32>(result);
     }
-    case Macro::ALUOperation::Subtract: {
+    case ALUOperation::Subtract: {
         const u64 result{static_cast<u64>(src_a) - src_b};
         carry_flag = result < 0x100000000;
         return static_cast<u32>(result);
     }
-    case Macro::ALUOperation::SubtractWithBorrow: {
+    case ALUOperation::SubtractWithBorrow: {
         const u64 result{static_cast<u64>(src_a) - src_b - (carry_flag ? 0ULL : 1ULL)};
         carry_flag = result < 0x100000000;
         return static_cast<u32>(result);
     }
-    case Macro::ALUOperation::Xor:
+    case ALUOperation::Xor:
         return src_a ^ src_b;
-    case Macro::ALUOperation::Or:
+    case ALUOperation::Or:
         return src_a | src_b;
-    case Macro::ALUOperation::And:
+    case ALUOperation::And:
         return src_a & src_b;
-    case Macro::ALUOperation::AndNot:
+    case ALUOperation::AndNot:
         return src_a & ~src_b;
-    case Macro::ALUOperation::Nand:
+    case ALUOperation::Nand:
         return ~(src_a & src_b);
 
     default:
@@ -187,43 +257,43 @@ u32 MacroInterpreterImpl::GetALUResult(Macro::ALUOperation operation, u32 src_a,
     }
 }
 
-void MacroInterpreterImpl::ProcessResult(Macro::ResultOperation operation, u32 reg, u32 result) {
+void MacroInterpreter::ProcessResult(ResultOperation operation, u32 reg, u32 result) {
     switch (operation) {
-    case Macro::ResultOperation::IgnoreAndFetch:
+    case ResultOperation::IgnoreAndFetch:
         // Fetch parameter and ignore result.
         SetRegister(reg, FetchParameter());
         break;
-    case Macro::ResultOperation::Move:
+    case ResultOperation::Move:
         // Move result.
         SetRegister(reg, result);
         break;
-    case Macro::ResultOperation::MoveAndSetMethod:
+    case ResultOperation::MoveAndSetMethod:
         // Move result and use as Method Address.
         SetRegister(reg, result);
         SetMethodAddress(result);
         break;
-    case Macro::ResultOperation::FetchAndSend:
+    case ResultOperation::FetchAndSend:
         // Fetch parameter and send result.
         SetRegister(reg, FetchParameter());
         Send(result);
         break;
-    case Macro::ResultOperation::MoveAndSend:
+    case ResultOperation::MoveAndSend:
         // Move and send result.
         SetRegister(reg, result);
         Send(result);
         break;
-    case Macro::ResultOperation::FetchAndSetMethod:
+    case ResultOperation::FetchAndSetMethod:
         // Fetch parameter and use result as Method Address.
         SetRegister(reg, FetchParameter());
         SetMethodAddress(result);
         break;
-    case Macro::ResultOperation::MoveAndSetMethodFetchAndSend:
+    case ResultOperation::MoveAndSetMethodFetchAndSend:
         // Move result and use as Method Address, then fetch and send parameter.
         SetRegister(reg, result);
         SetMethodAddress(result);
         Send(FetchParameter());
         break;
-    case Macro::ResultOperation::MoveAndSetMethodSend:
+    case ResultOperation::MoveAndSetMethodSend:
         // Move result and use as Method Address, then send bits 12:17 of result.
         SetRegister(reg, result);
         SetMethodAddress(result);
@@ -234,28 +304,16 @@ void MacroInterpreterImpl::ProcessResult(Macro::ResultOperation operation, u32 r
     }
 }
 
-bool MacroInterpreterImpl::EvaluateBranchCondition(Macro::BranchCondition cond, u32 value) const {
-    switch (cond) {
-    case Macro::BranchCondition::Zero:
-        return value == 0;
-    case Macro::BranchCondition::NotZero:
-        return value != 0;
-    }
-    UNREACHABLE();
-    return true;
+u32 MacroInterpreter::FetchParameter() {
+    ASSERT(next_parameter_index < num_parameters);
+    return parameters[next_parameter_index++];
 }
 
-Macro::Opcode MacroInterpreterImpl::GetOpcode() const {
-    ASSERT((pc % sizeof(u32)) == 0);
-    ASSERT(pc < code.size() * sizeof(u32));
-    return {code[pc / sizeof(u32)]};
-}
-
-u32 MacroInterpreterImpl::GetRegister(u32 register_id) const {
+u32 MacroInterpreter::GetRegister(u32 register_id) const {
     return registers.at(register_id);
 }
 
-void MacroInterpreterImpl::SetRegister(u32 register_id, u32 value) {
+void MacroInterpreter::SetRegister(u32 register_id, u32 value) {
     // Register 0 is hardwired as the zero register.
     // Ensure no writes to it actually occur.
     if (register_id == 0) {
@@ -265,24 +323,30 @@ void MacroInterpreterImpl::SetRegister(u32 register_id, u32 value) {
     registers.at(register_id) = value;
 }
 
-void MacroInterpreterImpl::SetMethodAddress(u32 address) {
+void MacroInterpreter::SetMethodAddress(u32 address) {
     method_address.raw = address;
 }
 
-void MacroInterpreterImpl::Send(u32 value) {
+void MacroInterpreter::Send(u32 value) {
     maxwell3d.CallMethodFromMME(method_address.address, value);
     // Increment the method address by the method increment.
     method_address.address.Assign(method_address.address.Value() +
                                   method_address.increment.Value());
 }
 
-u32 MacroInterpreterImpl::Read(u32 method) const {
+u32 MacroInterpreter::Read(u32 method) const {
     return maxwell3d.GetRegisterValue(method);
 }
 
-u32 MacroInterpreterImpl::FetchParameter() {
-    ASSERT(next_parameter_index < num_parameters);
-    return parameters[next_parameter_index++];
+bool MacroInterpreter::EvaluateBranchCondition(BranchCondition cond, u32 value) const {
+    switch (cond) {
+    case BranchCondition::Zero:
+        return value == 0;
+    case BranchCondition::NotZero:
+        return value != 0;
+    }
+    UNREACHABLE();
+    return true;
 }
 
 } // namespace Tegra

src/video_core/macro_interpreter.h

@@ -1,37 +1,44 @@
-// Copyright 2020 yuzu Emulator Project
+// Copyright 2018 yuzu Emulator Project
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
 #pragma once
+
 #include <array>
 #include <optional>
-#include <vector>
+
 #include "common/bit_field.h"
 #include "common/common_types.h"
-#include "video_core/macro/macro.h"
 
 namespace Tegra {
 namespace Engines {
 class Maxwell3D;
 }
 
-class MacroInterpreter final : public MacroEngine {
+class MacroInterpreter final {
 public:
     explicit MacroInterpreter(Engines::Maxwell3D& maxwell3d);
 
-protected:
-    std::unique_ptr<CachedMacro> Compile(const std::vector<u32>& code) override;
+    /**
+     * Executes the macro code with the specified input parameters.
+     * @param offset Offset to start execution at.
+     * @param parameters The parameters of the macro.
+     */
+    void Execute(u32 offset, std::size_t num_parameters, const u32* parameters);
 
 private:
-    Engines::Maxwell3D& maxwell3d;
-};
+    enum class ALUOperation : u32;
+    enum class BranchCondition : u32;
+    enum class ResultOperation : u32;
 
-class MacroInterpreterImpl : public CachedMacro {
-public:
-    MacroInterpreterImpl(Engines::Maxwell3D& maxwell3d, const std::vector<u32>& code);
-    void Execute(const std::vector<u32>& parameters, u32 method) override;
+    union Opcode;
+
+    union MethodAddress {
+        u32 raw;
+        BitField<0, 12, u32> address;
+        BitField<12, 6, u32> increment;
+    };
 
-private:
     /// Resets the execution engine state, zeroing registers, etc.
     void Reset();
 
@@ -42,20 +49,20 @@ private:
      * @param is_delay_slot Whether the current step is being executed due to a delay slot in a
      * previous instruction.
      */
-    bool Step(bool is_delay_slot);
+    bool Step(u32 offset, bool is_delay_slot);
 
     /// Calculates the result of an ALU operation. src_a OP src_b;
-    u32 GetALUResult(Macro::ALUOperation operation, u32 src_a, u32 src_b);
+    u32 GetALUResult(ALUOperation operation, u32 src_a, u32 src_b);
 
     /// Performs the result operation on the input result and stores it in the specified register
     /// (if necessary).
-    void ProcessResult(Macro::ResultOperation operation, u32 reg, u32 result);
+    void ProcessResult(ResultOperation operation, u32 reg, u32 result);
 
     /// Evaluates the branch condition and returns whether the branch should be taken or not.
-    bool EvaluateBranchCondition(Macro::BranchCondition cond, u32 value) const;
+    bool EvaluateBranchCondition(BranchCondition cond, u32 value) const;
 
     /// Reads an opcode at the current program counter location.
-    Macro::Opcode GetOpcode() const;
+    Opcode GetOpcode(u32 offset) const;
 
     /// Returns the specified register's value. Register 0 is hardcoded to always return 0.
     u32 GetRegister(u32 register_id) const;
@@ -82,11 +89,13 @@ private:
     /// Program counter to execute at after the delay slot is executed.
     std::optional<u32> delayed_pc;
 
+    static constexpr std::size_t NumMacroRegisters = 8;
+
     /// General purpose macro registers.
-    std::array<u32, Macro::NUM_MACRO_REGISTERS> registers = {};
+    std::array<u32, NumMacroRegisters> registers = {};
 
     /// Method address to use for the next Send instruction.
-    Macro::MethodAddress method_address = {};
+    MethodAddress method_address = {};
 
     /// Input parameters of the current macro.
     std::unique_ptr<u32[]> parameters;
@@ -96,7 +105,5 @@ private:
     u32 next_parameter_index = 0;
 
     bool carry_flag = false;
-    const std::vector<u32>& code;
 };
-
 } // namespace Tegra

src/video_core/renderer_opengl/gl_device.cpp

@@ -6,7 +6,6 @@
 #include <array>
 #include <cstddef>
 #include <cstring>
-#include <limits>
 #include <optional>
 #include <vector>
 
@@ -27,27 +26,24 @@ constexpr u32 ReservedUniformBlocks = 1;
 
 constexpr u32 NumStages = 5;
 
-constexpr std::array LimitUBOs = {
-    GL_MAX_VERTEX_UNIFORM_BLOCKS,          GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS,
-    GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS, GL_MAX_GEOMETRY_UNIFORM_BLOCKS,
-    GL_MAX_FRAGMENT_UNIFORM_BLOCKS,        GL_MAX_COMPUTE_UNIFORM_BLOCKS};
+constexpr std::array LimitUBOs = {GL_MAX_VERTEX_UNIFORM_BLOCKS, GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS,
+                                  GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS,
+                                  GL_MAX_GEOMETRY_UNIFORM_BLOCKS, GL_MAX_FRAGMENT_UNIFORM_BLOCKS};
 
 constexpr std::array LimitSSBOs = {
-    GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS,          GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS,
+    GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS, GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS,
     GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS, GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS,
-    GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS,        GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS};
+    GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS};
 
-constexpr std::array LimitSamplers = {GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS,
-                                      GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS,
-                                      GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS,
-                                      GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS,
-                                      GL_MAX_TEXTURE_IMAGE_UNITS,
-                                      GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS};
+constexpr std::array LimitSamplers = {
+    GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS,
+    GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS, GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS,
+    GL_MAX_TEXTURE_IMAGE_UNITS};
 
-constexpr std::array LimitImages = {
-    GL_MAX_VERTEX_IMAGE_UNIFORMS,          GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS,
-    GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS, GL_MAX_GEOMETRY_IMAGE_UNIFORMS,
-    GL_MAX_FRAGMENT_IMAGE_UNIFORMS,        GL_MAX_COMPUTE_IMAGE_UNIFORMS};
+constexpr std::array LimitImages = {GL_MAX_VERTEX_IMAGE_UNIFORMS,
+                                    GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS,
+                                    GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS,
+                                    GL_MAX_GEOMETRY_IMAGE_UNIFORMS, GL_MAX_FRAGMENT_IMAGE_UNIFORMS};
 
 template <typename T>
 T GetInteger(GLenum pname) {
@@ -89,13 +85,6 @@ u32 Extract(u32& base, u32& num, u32 amount, std::optional<GLenum> limit = {}) {
     return std::exchange(base, base + amount);
 }
 
-std::array<u32, Tegra::Engines::MaxShaderTypes> BuildMaxUniformBuffers() noexcept {
-    std::array<u32, Tegra::Engines::MaxShaderTypes> max;
-    std::transform(LimitUBOs.begin(), LimitUBOs.end(), max.begin(),
-                   [](GLenum pname) { return GetInteger<u32>(pname); });
-    return max;
-}
-
 std::array<Device::BaseBindings, Tegra::Engines::MaxShaderTypes> BuildBaseBindings() noexcept {
     std::array<Device::BaseBindings, Tegra::Engines::MaxShaderTypes> bindings;
 
@@ -144,7 +133,6 @@ std::array<Device::BaseBindings, Tegra::Engines::MaxShaderTypes> BuildBaseBindin
 }
 
 bool IsASTCSupported() {
-    static constexpr std::array targets = {GL_TEXTURE_2D, GL_TEXTURE_2D_ARRAY};
     static constexpr std::array formats = {
         GL_COMPRESSED_RGBA_ASTC_4x4_KHR,           GL_COMPRESSED_RGBA_ASTC_5x4_KHR,
         GL_COMPRESSED_RGBA_ASTC_5x5_KHR,           GL_COMPRESSED_RGBA_ASTC_6x5_KHR,
@@ -161,35 +149,25 @@ bool IsASTCSupported() {
         GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR,  GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR,
         GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR, GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR,
     };
-    static constexpr std::array required_support = {
-        GL_VERTEX_TEXTURE,   GL_TESS_CONTROL_TEXTURE, GL_TESS_EVALUATION_TEXTURE,
-        GL_GEOMETRY_TEXTURE, GL_FRAGMENT_TEXTURE,     GL_COMPUTE_TEXTURE,
-    };
-
-    for (const GLenum target : targets) {
-        for (const GLenum format : formats) {
-            for (const GLenum support : required_support) {
-                GLint value;
-                glGetInternalformativ(GL_TEXTURE_2D, format, support, 1, &value);
-                if (value != GL_FULL_SUPPORT) {
-                    return false;
-                }
-            }
-        }
-    }
-    return true;
+    return std::find_if_not(formats.begin(), formats.end(), [](GLenum format) {
+               GLint supported;
+               glGetInternalformativ(GL_TEXTURE_2D, format, GL_INTERNALFORMAT_SUPPORTED, 1,
+                                     &supported);
+               return supported == GL_TRUE;
+           }) == formats.end();
 }
 
 } // Anonymous namespace
 
-Device::Device()
-    : max_uniform_buffers{BuildMaxUniformBuffers()}, base_bindings{BuildBaseBindings()} {
+Device::Device() : base_bindings{BuildBaseBindings()} {
     const std::string_view vendor = reinterpret_cast<const char*>(glGetString(GL_VENDOR));
     const auto renderer = reinterpret_cast<const char*>(glGetString(GL_RENDERER));
     const std::vector extensions = GetExtensions();
 
     const bool is_nvidia = vendor == "NVIDIA Corporation";
     const bool is_amd = vendor == "ATI Technologies Inc.";
+    const bool is_intel = vendor == "Intel";
+    const bool is_intel_proprietary = is_intel && std::strstr(renderer, "Mesa") == nullptr;
 
     uniform_buffer_alignment = GetInteger<std::size_t>(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT);
     shader_storage_alignment = GetInteger<std::size_t>(GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT);
@@ -204,6 +182,7 @@ Device::Device()
     has_variable_aoffi = TestVariableAoffi();
     has_component_indexing_bug = is_amd;
     has_precise_bug = TestPreciseBug();
+    has_broken_compute = is_intel_proprietary;
     has_fast_buffer_sub_data = is_nvidia;
     use_assembly_shaders = Settings::values.use_assembly_shaders && GLAD_GL_NV_gpu_program5 &&
                            GLAD_GL_NV_compute_program5;
@@ -218,9 +197,7 @@ Device::Device()
 }
 
 Device::Device(std::nullptr_t) {
-    max_uniform_buffers.fill(std::numeric_limits<u32>::max());
-    uniform_buffer_alignment = 4;
-    shader_storage_alignment = 4;
+    uniform_buffer_alignment = 0;
     max_vertex_attributes = 16;
     max_varyings = 15;
     has_warp_intrinsics = true;
@@ -228,6 +205,9 @@ Device::Device(std::nullptr_t) {
     has_vertex_viewport_layer = true;
     has_image_load_formatted = true;
     has_variable_aoffi = true;
+    has_component_indexing_bug = false;
+    has_broken_compute = false;
+    has_precise_bug = false;
 }
 
 bool Device::TestVariableAoffi() {

src/video_core/renderer_opengl/gl_device.h

@@ -24,10 +24,6 @@ public:
     explicit Device();
     explicit Device(std::nullptr_t);
 
-    u32 GetMaxUniformBuffers(Tegra::Engines::ShaderType shader_type) const noexcept {
-        return max_uniform_buffers[static_cast<std::size_t>(shader_type)];
-    }
-
     const BaseBindings& GetBaseBindings(std::size_t stage_index) const noexcept {
         return base_bindings[stage_index];
     }
@@ -84,6 +80,10 @@ public:
         return has_precise_bug;
     }
 
+    bool HasBrokenCompute() const {
+        return has_broken_compute;
+    }
+
     bool HasFastBufferSubData() const {
         return has_fast_buffer_sub_data;
     }
@@ -96,8 +96,7 @@ private:
     static bool TestVariableAoffi();
     static bool TestPreciseBug();
 
-    std::array<u32, Tegra::Engines::MaxShaderTypes> max_uniform_buffers{};
-    std::array<BaseBindings, Tegra::Engines::MaxShaderTypes> base_bindings{};
+    std::array<BaseBindings, Tegra::Engines::MaxShaderTypes> base_bindings;
     std::size_t uniform_buffer_alignment{};
     std::size_t shader_storage_alignment{};
     u32 max_vertex_attributes{};
@@ -110,6 +109,7 @@ private:
     bool has_variable_aoffi{};
     bool has_component_indexing_bug{};
     bool has_precise_bug{};
+    bool has_broken_compute{};
     bool has_fast_buffer_sub_data{};
     bool use_assembly_shaders{};
 };

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -54,12 +54,6 @@ MICROPROFILE_DEFINE(OpenGL_PrimitiveAssembly, "OpenGL", "Prim Asmbl", MP_RGB(255
 
 namespace {
 
-constexpr std::size_t NUM_CONST_BUFFERS_PER_STAGE = 18;
-constexpr std::size_t NUM_CONST_BUFFERS_BYTES_PER_STAGE =
-    NUM_CONST_BUFFERS_PER_STAGE * Maxwell::MaxConstBufferSize;
-constexpr std::size_t TOTAL_CONST_BUFFER_BYTES =
-    NUM_CONST_BUFFERS_BYTES_PER_STAGE * Maxwell::MaxShaderStage;
-
 constexpr std::size_t NumSupportedVertexAttributes = 16;
 
 template <typename Engine, typename Entry>
@@ -110,9 +104,6 @@ RasterizerOpenGL::RasterizerOpenGL(Core::System& system, Core::Frontend::EmuWind
       screen_info{info}, program_manager{program_manager}, state_tracker{state_tracker} {
     CheckExtensions();
 
-    unified_uniform_buffer.Create();
-    glNamedBufferStorage(unified_uniform_buffer.handle, TOTAL_CONST_BUFFER_BYTES, nullptr, 0);
-
     if (device.UseAssemblyShaders()) {
         glCreateBuffers(static_cast<GLsizei>(staging_cbufs.size()), staging_cbufs.data());
         for (const GLuint cbuf : staging_cbufs) {
@@ -664,6 +655,10 @@ void RasterizerOpenGL::Draw(bool is_indexed, bool is_instanced) {
 }
 
 void RasterizerOpenGL::DispatchCompute(GPUVAddr code_addr) {
+    if (device.HasBrokenCompute()) {
+        return;
+    }
+
     buffer_cache.Acquire();
     current_cbuf = 0;
 
@@ -851,56 +846,34 @@ void RasterizerOpenGL::SetupDrawConstBuffers(std::size_t stage_index, const Shad
     MICROPROFILE_SCOPE(OpenGL_UBO);
     const auto& stages = system.GPU().Maxwell3D().state.shader_stages;
     const auto& shader_stage = stages[stage_index];
-    const auto& entries = shader->GetEntries();
-    const bool use_unified = entries.use_unified_uniforms;
-    const std::size_t base_unified_offset = stage_index * NUM_CONST_BUFFERS_BYTES_PER_STAGE;
 
-    const auto base_bindings = device.GetBaseBindings(stage_index);
-    u32 binding = device.UseAssemblyShaders() ? 0 : base_bindings.uniform_buffer;
-    for (const auto& entry : entries.const_buffers) {
-        const u32 index = entry.GetIndex();
-        const auto& buffer = shader_stage.const_buffers[index];
-        SetupConstBuffer(PARAMETER_LUT[stage_index], binding, buffer, entry, use_unified,
-                         base_unified_offset + index * Maxwell::MaxConstBufferSize);
-        ++binding;
-    }
-    if (use_unified) {
-        const u32 index = static_cast<u32>(base_bindings.shader_storage_buffer +
-                                           entries.global_memory_entries.size());
-        glBindBufferRange(GL_SHADER_STORAGE_BUFFER, index, unified_uniform_buffer.handle,
-                          base_unified_offset, NUM_CONST_BUFFERS_BYTES_PER_STAGE);
+    u32 binding =
+        device.UseAssemblyShaders() ? 0 : device.GetBaseBindings(stage_index).uniform_buffer;
+    for (const auto& entry : shader->GetEntries().const_buffers) {
+        const auto& buffer = shader_stage.const_buffers[entry.GetIndex()];
+        SetupConstBuffer(PARAMETER_LUT[stage_index], binding++, buffer, entry);
     }
 }
 
 void RasterizerOpenGL::SetupComputeConstBuffers(const Shader& kernel) {
     MICROPROFILE_SCOPE(OpenGL_UBO);
     const auto& launch_desc = system.GPU().KeplerCompute().launch_description;
-    const auto& entries = kernel->GetEntries();
-    const bool use_unified = entries.use_unified_uniforms;
 
     u32 binding = 0;
-    for (const auto& entry : entries.const_buffers) {
+    for (const auto& entry : kernel->GetEntries().const_buffers) {
         const auto& config = launch_desc.const_buffer_config[entry.GetIndex()];
         const std::bitset<8> mask = launch_desc.const_buffer_enable_mask.Value();
         Tegra::Engines::ConstBufferInfo buffer;
         buffer.address = config.Address();
         buffer.size = config.size;
         buffer.enabled = mask[entry.GetIndex()];
-        SetupConstBuffer(GL_COMPUTE_PROGRAM_PARAMETER_BUFFER_NV, binding, buffer, entry,
-                         use_unified, entry.GetIndex() * Maxwell::MaxConstBufferSize);
-        ++binding;
-    }
-    if (use_unified) {
-        const GLuint index = static_cast<GLuint>(entries.global_memory_entries.size());
-        glBindBufferRange(GL_SHADER_STORAGE_BUFFER, index, unified_uniform_buffer.handle, 0,
-                          NUM_CONST_BUFFERS_BYTES_PER_STAGE);
+        SetupConstBuffer(GL_COMPUTE_PROGRAM_PARAMETER_BUFFER_NV, binding++, buffer, entry);
     }
 }
 
 void RasterizerOpenGL::SetupConstBuffer(GLenum stage, u32 binding,
                                         const Tegra::Engines::ConstBufferInfo& buffer,
-                                        const ConstBufferEntry& entry, bool use_unified,
-                                        std::size_t unified_offset) {
+                                        const ConstBufferEntry& entry) {
     if (!buffer.enabled) {
         // Set values to zero to unbind buffers
         if (device.UseAssemblyShaders()) {
@@ -916,29 +889,20 @@ void RasterizerOpenGL::SetupConstBuffer(GLenum stage, u32 binding,
     // UBO alignment requirements.
     const std::size_t size = Common::AlignUp(GetConstBufferSize(buffer, entry), sizeof(GLvec4));
 
-    const bool fast_upload = !use_unified && device.HasFastBufferSubData();
-
-    const std::size_t alignment = use_unified ? 4 : device.GetUniformBufferAlignment();
-    const GPUVAddr gpu_addr = buffer.address;
-    auto [cbuf, offset] = buffer_cache.UploadMemory(gpu_addr, size, alignment, false, fast_upload);
-
-    if (device.UseAssemblyShaders()) {
-        UNIMPLEMENTED_IF(use_unified);
-        if (offset != 0) {
-            const GLuint staging_cbuf = staging_cbufs[current_cbuf++];
-            glCopyNamedBufferSubData(cbuf, staging_cbuf, offset, 0, size);
-            cbuf = staging_cbuf;
-            offset = 0;
-        }
-        glBindBufferRangeNV(stage, binding, cbuf, offset, size);
+    const auto alignment = device.GetUniformBufferAlignment();
+    auto [cbuf, offset] = buffer_cache.UploadMemory(buffer.address, size, alignment, false,
+                                                    device.HasFastBufferSubData());
+    if (!device.UseAssemblyShaders()) {
+        glBindBufferRange(GL_UNIFORM_BUFFER, binding, cbuf, offset, size);
         return;
     }
-
-    if (use_unified) {
-        glCopyNamedBufferSubData(cbuf, unified_uniform_buffer.handle, offset, unified_offset, size);
-    } else {
-        glBindBufferRange(GL_UNIFORM_BUFFER, binding, cbuf, offset, size);
+    if (offset != 0) {
+        const GLuint staging_cbuf = staging_cbufs[current_cbuf++];
+        glCopyNamedBufferSubData(cbuf, staging_cbuf, offset, 0, size);
+        cbuf = staging_cbuf;
+        offset = 0;
     }
+    glBindBufferRangeNV(stage, binding, cbuf, offset, size);
 }
 
 void RasterizerOpenGL::SetupDrawGlobalMemory(std::size_t stage_index, const Shader& shader) {
@@ -1060,26 +1024,6 @@ void RasterizerOpenGL::SyncViewport() {
     const auto& regs = gpu.regs;
 
     const bool dirty_viewport = flags[Dirty::Viewports];
-    const bool dirty_clip_control = flags[Dirty::ClipControl];
-
-    if (dirty_clip_control || flags[Dirty::FrontFace]) {
-        flags[Dirty::FrontFace] = false;
-
-        GLenum mode = MaxwellToGL::FrontFace(regs.front_face);
-        if (regs.screen_y_control.triangle_rast_flip != 0 &&
-            regs.viewport_transform[0].scale_y < 0.0f) {
-            switch (mode) {
-            case GL_CW:
-                mode = GL_CCW;
-                break;
-            case GL_CCW:
-                mode = GL_CW;
-                break;
-            }
-        }
-        glFrontFace(mode);
-    }
-
     if (dirty_viewport || flags[Dirty::ClipControl]) {
         flags[Dirty::ClipControl] = false;
 
@@ -1177,6 +1121,11 @@ void RasterizerOpenGL::SyncCullMode() {
             glDisable(GL_CULL_FACE);
         }
     }
+
+    if (flags[Dirty::FrontFace]) {
+        flags[Dirty::FrontFace] = false;
+        glFrontFace(MaxwellToGL::FrontFace(regs.front_face));
+    }
 }
 
 void RasterizerOpenGL::SyncPrimitiveRestart() {

src/video_core/renderer_opengl/gl_rasterizer.h

@@ -107,8 +107,7 @@ private:
 
     /// Configures a constant buffer.
     void SetupConstBuffer(GLenum stage, u32 binding, const Tegra::Engines::ConstBufferInfo& buffer,
-                          const ConstBufferEntry& entry, bool use_unified,
-                          std::size_t unified_offset);
+                          const ConstBufferEntry& entry);
 
     /// Configures the current global memory entries to use for the draw command.
     void SetupDrawGlobalMemory(std::size_t stage_index, const Shader& shader);
@@ -254,7 +253,6 @@ private:
         Tegra::Engines::Maxwell3D::Regs::MaxShaderProgram;
     std::array<GLuint, NUM_CONSTANT_BUFFERS> staging_cbufs{};
     std::size_t current_cbuf = 0;
-    OGLBuffer unified_uniform_buffer;
 
     /// Number of commands queued to the OpenGL driver. Reseted on flush.
     std::size_t num_queued_commands = 0;

src/video_core/renderer_opengl/gl_shader_cache.cpp

@@ -241,9 +241,8 @@ Shader CachedShader::CreateStageFromMemory(const ShaderParameters& params,
     entry.bindless_samplers = registry->GetBindlessSamplers();
     params.disk_cache.SaveEntry(std::move(entry));
 
-    return std::shared_ptr<CachedShader>(
-        new CachedShader(params.cpu_addr, size_in_bytes, std::move(registry),
-                         MakeEntries(params.device, ir, shader_type), std::move(program)));
+    return std::shared_ptr<CachedShader>(new CachedShader(
+        params.cpu_addr, size_in_bytes, std::move(registry), MakeEntries(ir), std::move(program)));
 }
 
 Shader CachedShader::CreateKernelFromMemory(const ShaderParameters& params, ProgramCode code) {
@@ -266,9 +265,8 @@ Shader CachedShader::CreateKernelFromMemory(const ShaderParameters& params, Prog
     entry.bindless_samplers = registry->GetBindlessSamplers();
     params.disk_cache.SaveEntry(std::move(entry));
 
-    return std::shared_ptr<CachedShader>(
-        new CachedShader(params.cpu_addr, size_in_bytes, std::move(registry),
-                         MakeEntries(params.device, ir, ShaderType::Compute), std::move(program)));
+    return std::shared_ptr<CachedShader>(new CachedShader(
+        params.cpu_addr, size_in_bytes, std::move(registry), MakeEntries(ir), std::move(program)));
 }
 
 Shader CachedShader::CreateFromCache(const ShaderParameters& params,
@@ -350,7 +348,7 @@ void ShaderCacheOpenGL::LoadDiskCache(const std::atomic_bool& stop_loading,
             PrecompiledShader shader;
             shader.program = std::move(program);
             shader.registry = std::move(registry);
-            shader.entries = MakeEntries(device, ir, entry.type);
+            shader.entries = MakeEntries(ir);
 
             std::scoped_lock lock{mutex};
             if (callback) {

src/video_core/renderer_opengl/gl_shader_decompiler.cpp

@@ -61,8 +61,8 @@ struct TextureDerivates {};
 using TextureArgument = std::pair<Type, Node>;
 using TextureIR = std::variant<TextureOffset, TextureDerivates, TextureArgument>;
 
-constexpr u32 MAX_CONSTBUFFER_SCALARS = static_cast<u32>(Maxwell::MaxConstBufferSize) / sizeof(u32);
-constexpr u32 MAX_CONSTBUFFER_ELEMENTS = MAX_CONSTBUFFER_SCALARS / sizeof(u32);
+constexpr u32 MAX_CONSTBUFFER_ELEMENTS =
+    static_cast<u32>(Maxwell::MaxConstBufferSize) / (4 * sizeof(float));
 
 constexpr std::string_view CommonDeclarations = R"(#define ftoi floatBitsToInt
 #define ftou floatBitsToUint
@@ -402,13 +402,6 @@ std::string FlowStackTopName(MetaStackClass stack) {
     return fmt::format("{}_flow_stack_top", GetFlowStackPrefix(stack));
 }
 
-bool UseUnifiedUniforms(const Device& device, const ShaderIR& ir, ShaderType stage) {
-    const u32 num_ubos = static_cast<u32>(ir.GetConstantBuffers().size());
-    // We waste one UBO for emulation
-    const u32 num_available_ubos = device.GetMaxUniformBuffers(stage) - 1;
-    return num_ubos > num_available_ubos;
-}
-
 struct GenericVaryingDescription {
     std::string name;
     u8 first_element = 0;
@@ -419,9 +412,8 @@ class GLSLDecompiler final {
 public:
     explicit GLSLDecompiler(const Device& device, const ShaderIR& ir, const Registry& registry,
                             ShaderType stage, std::string_view identifier, std::string_view suffix)
-        : device{device}, ir{ir}, registry{registry}, stage{stage}, identifier{identifier},
-          suffix{suffix}, header{ir.GetHeader()}, use_unified_uniforms{
-                                                      UseUnifiedUniforms(device, ir, stage)} {
+        : device{device}, ir{ir}, registry{registry}, stage{stage},
+          identifier{identifier}, suffix{suffix}, header{ir.GetHeader()} {
         if (stage != ShaderType::Compute) {
             transform_feedback = BuildTransformFeedback(registry.GetGraphicsInfo());
         }
@@ -626,9 +618,7 @@ private:
                 break;
             }
         }
-
-        if (stage != ShaderType::Geometry &&
-            (stage != ShaderType::Vertex || device.HasVertexViewportLayer())) {
+        if (stage != ShaderType::Vertex || device.HasVertexViewportLayer()) {
             if (ir.UsesLayer()) {
                 code.AddLine("int gl_Layer;");
             }
@@ -657,16 +647,6 @@ private:
         --code.scope;
         code.AddLine("}};");
         code.AddNewLine();
-
-        if (stage == ShaderType::Geometry) {
-            if (ir.UsesLayer()) {
-                code.AddLine("out int gl_Layer;");
-            }
-            if (ir.UsesViewportIndex()) {
-                code.AddLine("out int gl_ViewportIndex;");
-            }
-        }
-        code.AddNewLine();
     }
 
     void DeclareRegisters() {
@@ -854,24 +834,12 @@ private:
     }
 
     void DeclareConstantBuffers() {
-        if (use_unified_uniforms) {
-            const u32 binding = device.GetBaseBindings(stage).shader_storage_buffer +
-                                static_cast<u32>(ir.GetGlobalMemory().size());
-            code.AddLine("layout (std430, binding = {}) readonly buffer UnifiedUniforms {{",
-                         binding);
-            code.AddLine("    uint cbufs[];");
-            code.AddLine("}};");
-            code.AddNewLine();
-            return;
-        }
-
         u32 binding = device.GetBaseBindings(stage).uniform_buffer;
-        for (const auto [index, info] : ir.GetConstantBuffers()) {
-            const u32 num_elements = Common::AlignUp(info.GetSize(), 4) / 4;
-            const u32 size = info.IsIndirect() ? MAX_CONSTBUFFER_ELEMENTS : num_elements;
+        for (const auto& buffers : ir.GetConstantBuffers()) {
+            const auto index = buffers.first;
             code.AddLine("layout (std140, binding = {}) uniform {} {{", binding++,
                          GetConstBufferBlock(index));
-            code.AddLine("    uvec4 {}[{}];", GetConstBuffer(index), size);
+            code.AddLine("    uvec4 {}[{}];", GetConstBuffer(index), MAX_CONSTBUFFER_ELEMENTS);
             code.AddLine("}};");
             code.AddNewLine();
         }
@@ -1070,51 +1038,42 @@ private:
 
         if (const auto cbuf = std::get_if<CbufNode>(&*node)) {
             const Node offset = cbuf->GetOffset();
-            const u32 base_unified_offset = cbuf->GetIndex() * MAX_CONSTBUFFER_SCALARS;
-
             if (const auto immediate = std::get_if<ImmediateNode>(&*offset)) {
                 // Direct access
                 const u32 offset_imm = immediate->GetValue();
                 ASSERT_MSG(offset_imm % 4 == 0, "Unaligned cbuf direct access");
-                if (use_unified_uniforms) {
-                    return {fmt::format("cbufs[{}]", base_unified_offset + offset_imm / 4),
-                            Type::Uint};
-                } else {
-                    return {fmt::format("{}[{}][{}]", GetConstBuffer(cbuf->GetIndex()),
-                                        offset_imm / (4 * 4), (offset_imm / 4) % 4),
+                return {fmt::format("{}[{}][{}]", GetConstBuffer(cbuf->GetIndex()),
+                                    offset_imm / (4 * 4), (offset_imm / 4) % 4),
+                        Type::Uint};
+            }
+
+            if (std::holds_alternative<OperationNode>(*offset)) {
+                // Indirect access
+                const std::string final_offset = code.GenerateTemporary();
+                code.AddLine("uint {} = {} >> 2;", final_offset, Visit(offset).AsUint());
+
+                if (!device.HasComponentIndexingBug()) {
+                    return {fmt::format("{}[{} >> 2][{} & 3]", GetConstBuffer(cbuf->GetIndex()),
+                                        final_offset, final_offset),
                             Type::Uint};
                 }
+
+                // AMD's proprietary GLSL compiler emits ill code for variable component access.
+                // To bypass this driver bug generate 4 ifs, one per each component.
+                const std::string pack = code.GenerateTemporary();
+                code.AddLine("uvec4 {} = {}[{} >> 2];", pack, GetConstBuffer(cbuf->GetIndex()),
+                             final_offset);
+
+                const std::string result = code.GenerateTemporary();
+                code.AddLine("uint {};", result);
+                for (u32 swizzle = 0; swizzle < 4; ++swizzle) {
+                    code.AddLine("if (({} & 3) == {}) {} = {}{};", final_offset, swizzle, result,
+                                 pack, GetSwizzle(swizzle));
+                }
+                return {result, Type::Uint};
             }
 
-            // Indirect access
-            if (use_unified_uniforms) {
-                return {fmt::format("cbufs[{} + ({} >> 2)]", base_unified_offset,
-                                    Visit(offset).AsUint()),
-                        Type::Uint};
-            }
-
-            const std::string final_offset = code.GenerateTemporary();
-            code.AddLine("uint {} = {} >> 2;", final_offset, Visit(offset).AsUint());
-
-            if (!device.HasComponentIndexingBug()) {
-                return {fmt::format("{}[{} >> 2][{} & 3]", GetConstBuffer(cbuf->GetIndex()),
-                                    final_offset, final_offset),
-                        Type::Uint};
-            }
-
-            // AMD's proprietary GLSL compiler emits ill code for variable component access.
-            // To bypass this driver bug generate 4 ifs, one per each component.
-            const std::string pack = code.GenerateTemporary();
-            code.AddLine("uvec4 {} = {}[{} >> 2];", pack, GetConstBuffer(cbuf->GetIndex()),
-                         final_offset);
-
-            const std::string result = code.GenerateTemporary();
-            code.AddLine("uint {};", result);
-            for (u32 swizzle = 0; swizzle < 4; ++swizzle) {
-                code.AddLine("if (({} & 3) == {}) {} = {}{};", final_offset, swizzle, result, pack,
-                             GetSwizzle(swizzle));
-            }
-            return {result, Type::Uint};
+            UNREACHABLE_MSG("Unmanaged offset node type");
         }
 
         if (const auto gmem = std::get_if<GmemNode>(&*node)) {
@@ -2751,7 +2710,6 @@ private:
     const std::string_view identifier;
     const std::string_view suffix;
     const Header header;
-    const bool use_unified_uniforms;
     std::unordered_map<u8, VaryingTFB> transform_feedback;
 
     ShaderWriter code;
@@ -2947,7 +2905,7 @@ void GLSLDecompiler::DecompileAST() {
 
 } // Anonymous namespace
 
-ShaderEntries MakeEntries(const Device& device, const ShaderIR& ir, ShaderType stage) {
+ShaderEntries MakeEntries(const VideoCommon::Shader::ShaderIR& ir) {
     ShaderEntries entries;
     for (const auto& cbuf : ir.GetConstantBuffers()) {
         entries.const_buffers.emplace_back(cbuf.second.GetMaxOffset(), cbuf.second.IsIndirect(),
@@ -2968,7 +2926,6 @@ ShaderEntries MakeEntries(const Device& device, const ShaderIR& ir, ShaderType s
         entries.clip_distances = (clip_distances[i] ? 1U : 0U) << i;
     }
     entries.shader_length = ir.GetLength();
-    entries.use_unified_uniforms = UseUnifiedUniforms(device, ir, stage);
     return entries;
 }
 

src/video_core/renderer_opengl/gl_shader_decompiler.h

@@ -53,13 +53,11 @@ struct ShaderEntries {
     std::vector<GlobalMemoryEntry> global_memory_entries;
     std::vector<SamplerEntry> samplers;
     std::vector<ImageEntry> images;
-    std::size_t shader_length{};
     u32 clip_distances{};
-    bool use_unified_uniforms{};
+    std::size_t shader_length{};
 };
 
-ShaderEntries MakeEntries(const Device& device, const VideoCommon::Shader::ShaderIR& ir,
-                          Tegra::Engines::ShaderType stage);
+ShaderEntries MakeEntries(const VideoCommon::Shader::ShaderIR& ir);
 
 std::string DecompileShader(const Device& device, const VideoCommon::Shader::ShaderIR& ir,
                             const VideoCommon::Shader::Registry& registry,

src/video_core/renderer_opengl/gl_texture_cache.cpp

@@ -404,7 +404,8 @@ View CachedSurface::CreateViewInner(const ViewParams& view_key, const bool is_pr
 
 CachedSurfaceView::CachedSurfaceView(CachedSurface& surface, const ViewParams& params,
                                      bool is_proxy)
-    : VideoCommon::ViewBase(params), surface{surface}, format{surface.internal_format},
+    : VideoCommon::ViewBase(params), surface{surface},
+      format{GetFormatTuple(surface.GetSurfaceParams().pixel_format).internal_format},
       target{GetTextureTarget(params.target)}, is_proxy{is_proxy} {
     if (!is_proxy) {
         main_view = CreateTextureView();

src/video_core/renderer_vulkan/fixed_pipeline_state.cpp

@@ -71,7 +71,8 @@ void FixedPipelineState::Rasterizer::Fill(const Maxwell& regs) noexcept {
     const u32 topology_index = static_cast<u32>(regs.draw.topology.Value());
 
     u32 packed_front_face = PackFrontFace(regs.front_face);
-    if (regs.screen_y_control.triangle_rast_flip != 0) {
+    if (regs.screen_y_control.triangle_rast_flip != 0 &&
+        regs.viewport_transform[0].scale_y > 0.0f) {
         // Flip front face
         packed_front_face = 1 - packed_front_face;
     }

src/video_core/renderer_vulkan/maxwell_to_vk.cpp

@@ -149,7 +149,7 @@ struct FormatTuple {
     {VK_FORMAT_R16_SFLOAT, Attachable | Storage},               // R16F
     {VK_FORMAT_R16_UNORM, Attachable | Storage},                // R16U
     {VK_FORMAT_UNDEFINED},                                      // R16S
-    {VK_FORMAT_R16_UINT, Attachable | Storage},                 // R16UI
+    {VK_FORMAT_UNDEFINED},                                      // R16UI
     {VK_FORMAT_UNDEFINED},                                      // R16I
     {VK_FORMAT_R16G16_UNORM, Attachable | Storage},             // RG16
     {VK_FORMAT_R16G16_SFLOAT, Attachable | Storage},            // RG16F

src/video_core/renderer_vulkan/vk_device.cpp

@@ -73,79 +73,76 @@ VkFormatFeatureFlags GetFormatFeatures(VkFormatProperties properties, FormatType
 
 std::unordered_map<VkFormat, VkFormatProperties> GetFormatProperties(
     vk::PhysicalDevice physical, const vk::InstanceDispatch& dld) {
-    static constexpr std::array formats{
-        VK_FORMAT_A8B8G8R8_UNORM_PACK32,
-        VK_FORMAT_A8B8G8R8_UINT_PACK32,
-        VK_FORMAT_A8B8G8R8_SNORM_PACK32,
-        VK_FORMAT_A8B8G8R8_SRGB_PACK32,
-        VK_FORMAT_B5G6R5_UNORM_PACK16,
-        VK_FORMAT_A2B10G10R10_UNORM_PACK32,
-        VK_FORMAT_A1R5G5B5_UNORM_PACK16,
-        VK_FORMAT_R32G32B32A32_SFLOAT,
-        VK_FORMAT_R32G32B32A32_UINT,
-        VK_FORMAT_R32G32_SFLOAT,
-        VK_FORMAT_R32G32_UINT,
-        VK_FORMAT_R16G16B16A16_UINT,
-        VK_FORMAT_R16G16B16A16_SNORM,
-        VK_FORMAT_R16G16B16A16_UNORM,
-        VK_FORMAT_R16G16_UNORM,
-        VK_FORMAT_R16G16_SNORM,
-        VK_FORMAT_R16G16_SFLOAT,
-        VK_FORMAT_R16_UNORM,
-        VK_FORMAT_R16_UINT,
-        VK_FORMAT_R8G8B8A8_SRGB,
-        VK_FORMAT_R8G8_UNORM,
-        VK_FORMAT_R8G8_SNORM,
-        VK_FORMAT_R8G8_UINT,
-        VK_FORMAT_R8_UNORM,
-        VK_FORMAT_R8_UINT,
-        VK_FORMAT_B10G11R11_UFLOAT_PACK32,
-        VK_FORMAT_R32_SFLOAT,
-        VK_FORMAT_R32_UINT,
-        VK_FORMAT_R32_SINT,
-        VK_FORMAT_R16_SFLOAT,
-        VK_FORMAT_R16G16B16A16_SFLOAT,
-        VK_FORMAT_B8G8R8A8_UNORM,
-        VK_FORMAT_B8G8R8A8_SRGB,
-        VK_FORMAT_R4G4B4A4_UNORM_PACK16,
-        VK_FORMAT_D32_SFLOAT,
-        VK_FORMAT_D16_UNORM,
-        VK_FORMAT_D16_UNORM_S8_UINT,
-        VK_FORMAT_D24_UNORM_S8_UINT,
-        VK_FORMAT_D32_SFLOAT_S8_UINT,
-        VK_FORMAT_BC1_RGBA_UNORM_BLOCK,
-        VK_FORMAT_BC2_UNORM_BLOCK,
-        VK_FORMAT_BC3_UNORM_BLOCK,
-        VK_FORMAT_BC4_UNORM_BLOCK,
-        VK_FORMAT_BC5_UNORM_BLOCK,
-        VK_FORMAT_BC5_SNORM_BLOCK,
-        VK_FORMAT_BC7_UNORM_BLOCK,
-        VK_FORMAT_BC6H_UFLOAT_BLOCK,
-        VK_FORMAT_BC6H_SFLOAT_BLOCK,
-        VK_FORMAT_BC1_RGBA_SRGB_BLOCK,
-        VK_FORMAT_BC2_SRGB_BLOCK,
-        VK_FORMAT_BC3_SRGB_BLOCK,
-        VK_FORMAT_BC7_SRGB_BLOCK,
-        VK_FORMAT_ASTC_4x4_SRGB_BLOCK,
-        VK_FORMAT_ASTC_8x8_SRGB_BLOCK,
-        VK_FORMAT_ASTC_8x5_SRGB_BLOCK,
-        VK_FORMAT_ASTC_5x4_SRGB_BLOCK,
-        VK_FORMAT_ASTC_5x5_UNORM_BLOCK,
-        VK_FORMAT_ASTC_5x5_SRGB_BLOCK,
-        VK_FORMAT_ASTC_10x8_UNORM_BLOCK,
-        VK_FORMAT_ASTC_10x8_SRGB_BLOCK,
-        VK_FORMAT_ASTC_6x6_UNORM_BLOCK,
-        VK_FORMAT_ASTC_6x6_SRGB_BLOCK,
-        VK_FORMAT_ASTC_10x10_UNORM_BLOCK,
-        VK_FORMAT_ASTC_10x10_SRGB_BLOCK,
-        VK_FORMAT_ASTC_12x12_UNORM_BLOCK,
-        VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
-        VK_FORMAT_ASTC_8x6_UNORM_BLOCK,
-        VK_FORMAT_ASTC_8x6_SRGB_BLOCK,
-        VK_FORMAT_ASTC_6x5_UNORM_BLOCK,
-        VK_FORMAT_ASTC_6x5_SRGB_BLOCK,
-        VK_FORMAT_E5B9G9R9_UFLOAT_PACK32,
-    };
+    static constexpr std::array formats{VK_FORMAT_A8B8G8R8_UNORM_PACK32,
+                                        VK_FORMAT_A8B8G8R8_UINT_PACK32,
+                                        VK_FORMAT_A8B8G8R8_SNORM_PACK32,
+                                        VK_FORMAT_A8B8G8R8_SRGB_PACK32,
+                                        VK_FORMAT_B5G6R5_UNORM_PACK16,
+                                        VK_FORMAT_A2B10G10R10_UNORM_PACK32,
+                                        VK_FORMAT_A1R5G5B5_UNORM_PACK16,
+                                        VK_FORMAT_R32G32B32A32_SFLOAT,
+                                        VK_FORMAT_R32G32B32A32_UINT,
+                                        VK_FORMAT_R32G32_SFLOAT,
+                                        VK_FORMAT_R32G32_UINT,
+                                        VK_FORMAT_R16G16B16A16_UINT,
+                                        VK_FORMAT_R16G16B16A16_SNORM,
+                                        VK_FORMAT_R16G16B16A16_UNORM,
+                                        VK_FORMAT_R16G16_UNORM,
+                                        VK_FORMAT_R16G16_SNORM,
+                                        VK_FORMAT_R16G16_SFLOAT,
+                                        VK_FORMAT_R16_UNORM,
+                                        VK_FORMAT_R8G8B8A8_SRGB,
+                                        VK_FORMAT_R8G8_UNORM,
+                                        VK_FORMAT_R8G8_SNORM,
+                                        VK_FORMAT_R8G8_UINT,
+                                        VK_FORMAT_R8_UNORM,
+                                        VK_FORMAT_R8_UINT,
+                                        VK_FORMAT_B10G11R11_UFLOAT_PACK32,
+                                        VK_FORMAT_R32_SFLOAT,
+                                        VK_FORMAT_R32_UINT,
+                                        VK_FORMAT_R32_SINT,
+                                        VK_FORMAT_R16_SFLOAT,
+                                        VK_FORMAT_R16G16B16A16_SFLOAT,
+                                        VK_FORMAT_B8G8R8A8_UNORM,
+                                        VK_FORMAT_B8G8R8A8_SRGB,
+                                        VK_FORMAT_R4G4B4A4_UNORM_PACK16,
+                                        VK_FORMAT_D32_SFLOAT,
+                                        VK_FORMAT_D16_UNORM,
+                                        VK_FORMAT_D16_UNORM_S8_UINT,
+                                        VK_FORMAT_D24_UNORM_S8_UINT,
+                                        VK_FORMAT_D32_SFLOAT_S8_UINT,
+                                        VK_FORMAT_BC1_RGBA_UNORM_BLOCK,
+                                        VK_FORMAT_BC2_UNORM_BLOCK,
+                                        VK_FORMAT_BC3_UNORM_BLOCK,
+                                        VK_FORMAT_BC4_UNORM_BLOCK,
+                                        VK_FORMAT_BC5_UNORM_BLOCK,
+                                        VK_FORMAT_BC5_SNORM_BLOCK,
+                                        VK_FORMAT_BC7_UNORM_BLOCK,
+                                        VK_FORMAT_BC6H_UFLOAT_BLOCK,
+                                        VK_FORMAT_BC6H_SFLOAT_BLOCK,
+                                        VK_FORMAT_BC1_RGBA_SRGB_BLOCK,
+                                        VK_FORMAT_BC2_SRGB_BLOCK,
+                                        VK_FORMAT_BC3_SRGB_BLOCK,
+                                        VK_FORMAT_BC7_SRGB_BLOCK,
+                                        VK_FORMAT_ASTC_4x4_SRGB_BLOCK,
+                                        VK_FORMAT_ASTC_8x8_SRGB_BLOCK,
+                                        VK_FORMAT_ASTC_8x5_SRGB_BLOCK,
+                                        VK_FORMAT_ASTC_5x4_SRGB_BLOCK,
+                                        VK_FORMAT_ASTC_5x5_UNORM_BLOCK,
+                                        VK_FORMAT_ASTC_5x5_SRGB_BLOCK,
+                                        VK_FORMAT_ASTC_10x8_UNORM_BLOCK,
+                                        VK_FORMAT_ASTC_10x8_SRGB_BLOCK,
+                                        VK_FORMAT_ASTC_6x6_UNORM_BLOCK,
+                                        VK_FORMAT_ASTC_6x6_SRGB_BLOCK,
+                                        VK_FORMAT_ASTC_10x10_UNORM_BLOCK,
+                                        VK_FORMAT_ASTC_10x10_SRGB_BLOCK,
+                                        VK_FORMAT_ASTC_12x12_UNORM_BLOCK,
+                                        VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
+                                        VK_FORMAT_ASTC_8x6_UNORM_BLOCK,
+                                        VK_FORMAT_ASTC_8x6_SRGB_BLOCK,
+                                        VK_FORMAT_ASTC_6x5_UNORM_BLOCK,
+                                        VK_FORMAT_ASTC_6x5_SRGB_BLOCK,
+                                        VK_FORMAT_E5B9G9R9_UFLOAT_PACK32};
     std::unordered_map<VkFormat, VkFormatProperties> format_properties;
     for (const auto format : formats) {
         format_properties.emplace(format, physical.GetFormatProperties(format));

src/video_core/renderer_vulkan/vk_pipeline_cache.cpp

@@ -312,9 +312,7 @@ VKPipelineCache::DecompileShaders(const GraphicsPipelineCacheKey& key) {
         ASSERT(point_size != 0.0f);
     }
     for (std::size_t i = 0; i < Maxwell::NumVertexAttributes; ++i) {
-        const auto& attribute = fixed_state.vertex_input.attributes[i];
-        specialization.enabled_attributes[i] = attribute.enabled.Value() != 0;
-        specialization.attribute_types[i] = attribute.Type();
+        specialization.attribute_types[i] = fixed_state.vertex_input.attributes[i].Type();
     }
     specialization.ndc_minus_one_to_one = fixed_state.rasterizer.ndc_minus_one_to_one;
 

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -877,10 +877,14 @@ void RasterizerVulkan::SetupVertexArrays(FixedPipelineState::VertexInput& vertex
 
     for (std::size_t index = 0; index < Maxwell::NumVertexAttributes; ++index) {
         const auto& attrib = regs.vertex_attrib_format[index];
-        if (attrib.IsConstant()) {
+        if (!attrib.IsValid()) {
             vertex_input.SetAttribute(index, false, 0, 0, {}, {});
             continue;
         }
+
+        [[maybe_unused]] const auto& buffer = regs.vertex_array[attrib.buffer];
+        ASSERT(buffer.IsEnabled());
+
         vertex_input.SetAttribute(index, true, attrib.buffer, attrib.offset, attrib.type.Value(),
                                   attrib.size.Value());
     }

src/video_core/renderer_vulkan/vk_shader_decompiler.cpp

@@ -741,10 +741,8 @@ private:
             if (!IsGenericAttribute(index)) {
                 continue;
             }
+
             const u32 location = GetGenericAttributeLocation(index);
-            if (!IsAttributeEnabled(location)) {
-                continue;
-            }
             const auto type_descriptor = GetAttributeType(location);
             Id type;
             if (IsInputAttributeArray()) {
@@ -988,10 +986,6 @@ private:
         return stage == ShaderType::TesselationControl;
     }
 
-    bool IsAttributeEnabled(u32 location) const {
-        return stage != ShaderType::Vertex || specialization.enabled_attributes[location];
-    }
-
     u32 GetNumInputVertices() const {
         switch (stage) {
         case ShaderType::Geometry:
@@ -1207,20 +1201,16 @@ private:
                 UNIMPLEMENTED_MSG("Unmanaged FrontFacing element={}", element);
                 return {v_float_zero, Type::Float};
             default:
-                if (!IsGenericAttribute(attribute)) {
-                    break;
+                if (IsGenericAttribute(attribute)) {
+                    const u32 location = GetGenericAttributeLocation(attribute);
+                    const auto type_descriptor = GetAttributeType(location);
+                    const Type type = type_descriptor.type;
+                    const Id attribute_id = input_attributes.at(attribute);
+                    const std::vector elements = {element};
+                    const Id pointer = ArrayPass(type_descriptor.scalar, attribute_id, elements);
+                    return {OpLoad(GetTypeDefinition(type), pointer), type};
                 }
-                const u32 location = GetGenericAttributeLocation(attribute);
-                if (!IsAttributeEnabled(location)) {
-                    // Disabled attributes (also known as constant attributes) always return zero.
-                    return {v_float_zero, Type::Float};
-                }
-                const auto type_descriptor = GetAttributeType(location);
-                const Type type = type_descriptor.type;
-                const Id attribute_id = input_attributes.at(attribute);
-                const std::vector elements = {element};
-                const Id pointer = ArrayPass(type_descriptor.scalar, attribute_id, elements);
-                return {OpLoad(GetTypeDefinition(type), pointer), type};
+                break;
             }
             UNIMPLEMENTED_MSG("Unhandled input attribute: {}", static_cast<u32>(attribute));
             return {v_float_zero, Type::Float};

src/video_core/renderer_vulkan/vk_shader_decompiler.h

@@ -88,8 +88,7 @@ struct Specialization final {
     u32 shared_memory_size{};
 
     // Graphics specific
-    std::optional<float> point_size;
-    std::bitset<Maxwell::NumVertexAttributes> enabled_attributes;
+    std::optional<float> point_size{};
     std::array<Maxwell::VertexAttribute::Type, Maxwell::NumVertexAttributes> attribute_types{};
     bool ndc_minus_one_to_one{};
 };

src/video_core/shader/decode/other.cpp

@@ -83,7 +83,7 @@ u32 ShaderIR::DecodeOther(NodeBlock& bb, u32 pc) {
                 return Operation(OperationCode::YNegate);
             case SystemVariable::InvocationInfo:
                 LOG_WARNING(HW_GPU, "S2R instruction with InvocationInfo is incomplete");
-                return Immediate(0x00ff'0000U);
+                return Immediate(0U);
             case SystemVariable::WscaleFactorXY:
                 UNIMPLEMENTED_MSG("S2R WscaleFactorXY is not implemented");
                 return Immediate(0U);

src/video_core/texture_cache/format_lookup_table.cpp

@@ -41,7 +41,7 @@ struct Table {
     ComponentType alpha_component;
     bool is_srgb;
 };
-constexpr std::array<Table, 78> DefinitionTable = {{
+constexpr std::array<Table, 77> DefinitionTable = {{
     {TextureFormat::A8R8G8B8, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::ABGR8U},
     {TextureFormat::A8R8G8B8, C, SNORM, SNORM, SNORM, SNORM, PixelFormat::ABGR8S},
     {TextureFormat::A8R8G8B8, C, UINT, UINT, UINT, UINT, PixelFormat::ABGR8UI},
@@ -98,7 +98,6 @@ constexpr std::array<Table, 78> DefinitionTable = {{
     {TextureFormat::ZF32, C, FLOAT, FLOAT, FLOAT, FLOAT, PixelFormat::Z32F},
     {TextureFormat::Z16, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::Z16},
     {TextureFormat::S8Z24, C, UINT, UNORM, UNORM, UNORM, PixelFormat::S8Z24},
-    {TextureFormat::G24R8, C, UINT, UNORM, UNORM, UNORM, PixelFormat::S8Z24},
     {TextureFormat::ZF32_X24S8, C, FLOAT, UINT, UNORM, UNORM, PixelFormat::Z32FS8},
 
     {TextureFormat::DXT1, C, UNORM, UNORM, UNORM, UNORM, PixelFormat::DXT1},

src/video_core/texture_cache/texture_cache.h

@@ -14,7 +14,6 @@
 #include <unordered_map>
 #include <vector>
 
-#include <boost/container/small_vector.hpp>
 #include <boost/icl/interval_map.hpp>
 #include <boost/range/iterator_range.hpp>
 
@@ -54,7 +53,6 @@ using RenderTargetConfig = Tegra::Engines::Maxwell3D::Regs::RenderTargetConfig;
 
 template <typename TSurface, typename TView>
 class TextureCache {
-    using VectorSurface = boost::container::small_vector<TSurface, 1>;
 
 public:
     void InvalidateRegion(VAddr addr, std::size_t size) {
@@ -310,20 +308,18 @@ public:
         dst_surface.first->MarkAsModified(true, Tick());
     }
 
-    TSurface TryFindFramebufferSurface(VAddr addr) const {
+    TSurface TryFindFramebufferSurface(VAddr addr) {
         if (!addr) {
             return nullptr;
         }
         const VAddr page = addr >> registry_page_bits;
-        const auto it = registry.find(page);
-        if (it == registry.end()) {
-            return nullptr;
+        std::vector<TSurface>& list = registry[page];
+        for (auto& surface : list) {
+            if (surface->GetCpuAddr() == addr) {
+                return surface;
+            }
         }
-        const auto& list = it->second;
-        const auto found = std::find_if(list.begin(), list.end(), [addr](const auto& surface) {
-            return surface->GetCpuAddr() == addr;
-        });
-        return found != list.end() ? *found : nullptr;
+        return nullptr;
     }
 
     u64 Tick() {
@@ -502,7 +498,7 @@ private:
      * @param untopological Indicates to the recycler that the texture has no way
      *                      to match the overlaps due to topological reasons.
      **/
-    RecycleStrategy PickStrategy(VectorSurface& overlaps, const SurfaceParams& params,
+    RecycleStrategy PickStrategy(std::vector<TSurface>& overlaps, const SurfaceParams& params,
                                  const GPUVAddr gpu_addr, const MatchTopologyResult untopological) {
         if (Settings::IsGPULevelExtreme()) {
             return RecycleStrategy::Flush;
@@ -542,8 +538,9 @@ private:
      * @param untopological     Indicates to the recycler that the texture has no way to match the
      *                          overlaps due to topological reasons.
      **/
-    std::pair<TSurface, TView> RecycleSurface(VectorSurface& overlaps, const SurfaceParams& params,
-                                              const GPUVAddr gpu_addr, const bool preserve_contents,
+    std::pair<TSurface, TView> RecycleSurface(std::vector<TSurface>& overlaps,
+                                              const SurfaceParams& params, const GPUVAddr gpu_addr,
+                                              const bool preserve_contents,
                                               const MatchTopologyResult untopological) {
         const bool do_load = preserve_contents && Settings::IsGPULevelExtreme();
         for (auto& surface : overlaps) {
@@ -653,65 +650,47 @@ private:
      * @param params   The parameters on the new surface.
      * @param gpu_addr The starting address of the new surface.
      **/
-    std::optional<std::pair<TSurface, TView>> TryReconstructSurface(VectorSurface& overlaps,
+    std::optional<std::pair<TSurface, TView>> TryReconstructSurface(std::vector<TSurface>& overlaps,
                                                                     const SurfaceParams& params,
-                                                                    GPUVAddr gpu_addr) {
+                                                                    const GPUVAddr gpu_addr) {
         if (params.target == SurfaceTarget::Texture3D) {
-            return std::nullopt;
+            return {};
         }
-        const auto test_modified = [](TSurface& surface) { return surface->IsModified(); };
+        bool modified = false;
         TSurface new_surface = GetUncachedSurface(gpu_addr, params);
-
-        if (std::none_of(overlaps.begin(), overlaps.end(), test_modified)) {
-            LoadSurface(new_surface);
-            for (const auto& surface : overlaps) {
-                Unregister(surface);
-            }
-            Register(new_surface);
-            return {{new_surface, new_surface->GetMainView()}};
-        }
-
-        std::size_t passed_tests = 0;
+        u32 passed_tests = 0;
         for (auto& surface : overlaps) {
             const SurfaceParams& src_params = surface->GetSurfaceParams();
-            const auto mipmap_layer{new_surface->GetLayerMipmap(surface->GetGpuAddr())};
+            if (src_params.is_layered || src_params.num_levels > 1) {
+                // We send this cases to recycle as they are more complex to handle
+                return {};
+            }
+            const std::size_t candidate_size = surface->GetSizeInBytes();
+            auto mipmap_layer{new_surface->GetLayerMipmap(surface->GetGpuAddr())};
             if (!mipmap_layer) {
                 continue;
             }
-            const auto [base_layer, base_mipmap] = *mipmap_layer;
-            if (new_surface->GetMipmapSize(base_mipmap) != surface->GetMipmapSize(0)) {
+            const auto [layer, mipmap] = *mipmap_layer;
+            if (new_surface->GetMipmapSize(mipmap) != candidate_size) {
                 continue;
             }
-            ++passed_tests;
-
-            // Copy all mipmaps and layers
-            const u32 block_width = params.GetDefaultBlockWidth();
-            const u32 block_height = params.GetDefaultBlockHeight();
-            for (u32 mipmap = base_mipmap; mipmap < base_mipmap + src_params.num_levels; ++mipmap) {
-                const u32 width = SurfaceParams::IntersectWidth(src_params, params, 0, mipmap);
-                const u32 height = SurfaceParams::IntersectHeight(src_params, params, 0, mipmap);
-                if (width < block_width || height < block_height) {
-                    // Current APIs forbid copying small compressed textures, avoid errors
-                    break;
-                }
-                const CopyParams copy_params(0, 0, 0, 0, 0, base_layer, 0, mipmap, width, height,
-                                             src_params.depth);
-                ImageCopy(surface, new_surface, copy_params);
-            }
+            modified |= surface->IsModified();
+            // Now we got all the data set up
+            const u32 width = SurfaceParams::IntersectWidth(src_params, params, 0, mipmap);
+            const u32 height = SurfaceParams::IntersectHeight(src_params, params, 0, mipmap);
+            const CopyParams copy_params(0, 0, 0, 0, 0, layer, 0, mipmap, width, height, 1);
+            passed_tests++;
+            ImageCopy(surface, new_surface, copy_params);
         }
         if (passed_tests == 0) {
-            return std::nullopt;
-        }
-        if (Settings::IsGPULevelExtreme() && passed_tests != overlaps.size()) {
+            return {};
             // In Accurate GPU all tests should pass, else we recycle
-            return std::nullopt;
+        } else if (Settings::IsGPULevelExtreme() && passed_tests != overlaps.size()) {
+            return {};
         }
-
-        const bool modified = std::any_of(overlaps.begin(), overlaps.end(), test_modified);
         for (const auto& surface : overlaps) {
             Unregister(surface);
         }
-
         new_surface->MarkAsModified(modified, Tick());
         Register(new_surface);
         return {{new_surface, new_surface->GetMainView()}};
@@ -729,7 +708,7 @@ private:
      * @param preserve_contents Indicates that the new surface should be loaded from memory or
      *                          left blank.
      */
-    std::optional<std::pair<TSurface, TView>> Manage3DSurfaces(VectorSurface& overlaps,
+    std::optional<std::pair<TSurface, TView>> Manage3DSurfaces(std::vector<TSurface>& overlaps,
                                                                const SurfaceParams& params,
                                                                const GPUVAddr gpu_addr,
                                                                const VAddr cpu_addr,
@@ -831,7 +810,7 @@ private:
             TSurface& current_surface = iter->second;
             const auto topological_result = current_surface->MatchesTopology(params);
             if (topological_result != MatchTopologyResult::FullMatch) {
-                VectorSurface overlaps{current_surface};
+                std::vector<TSurface> overlaps{current_surface};
                 return RecycleSurface(overlaps, params, gpu_addr, preserve_contents,
                                       topological_result);
             }
@@ -889,9 +868,12 @@ private:
             // two things either the candidate surface is a supertexture of the overlap
             // or they don't match in any known way.
             if (!current_surface->IsInside(gpu_addr, gpu_addr + candidate_size)) {
-                const std::optional view = TryReconstructSurface(overlaps, params, gpu_addr);
-                if (view) {
-                    return *view;
+                if (current_surface->GetGpuAddr() == gpu_addr) {
+                    std::optional<std::pair<TSurface, TView>> view =
+                        TryReconstructSurface(overlaps, params, gpu_addr);
+                    if (view) {
+                        return *view;
+                    }
                 }
                 return RecycleSurface(overlaps, params, gpu_addr, preserve_contents,
                                       MatchTopologyResult::FullMatch);
@@ -1144,25 +1126,23 @@ private:
         }
     }
 
-    VectorSurface GetSurfacesInRegion(const VAddr cpu_addr, const std::size_t size) {
+    std::vector<TSurface> GetSurfacesInRegion(const VAddr cpu_addr, const std::size_t size) {
         if (size == 0) {
             return {};
         }
         const VAddr cpu_addr_end = cpu_addr + size;
+        VAddr start = cpu_addr >> registry_page_bits;
         const VAddr end = (cpu_addr_end - 1) >> registry_page_bits;
-        VectorSurface surfaces;
-        for (VAddr start = cpu_addr >> registry_page_bits; start <= end; ++start) {
-            const auto it = registry.find(start);
-            if (it == registry.end()) {
-                continue;
-            }
-            for (auto& surface : it->second) {
-                if (surface->IsPicked() || !surface->Overlaps(cpu_addr, cpu_addr_end)) {
-                    continue;
+        std::vector<TSurface> surfaces;
+        while (start <= end) {
+            std::vector<TSurface>& list = registry[start];
+            for (auto& surface : list) {
+                if (!surface->IsPicked() && surface->Overlaps(cpu_addr, cpu_addr_end)) {
+                    surface->MarkAsPicked(true);
+                    surfaces.push_back(surface);
                 }
-                surface->MarkAsPicked(true);
-                surfaces.push_back(surface);
             }
+            start++;
         }
         for (auto& surface : surfaces) {
             surface->MarkAsPicked(false);

src/yuzu/configuration/config.cpp

@@ -533,8 +533,6 @@ void Config::ReadDebuggingValues() {
     Settings::values.quest_flag = ReadSetting(QStringLiteral("quest_flag"), false).toBool();
     Settings::values.disable_cpu_opt =
         ReadSetting(QStringLiteral("disable_cpu_opt"), false).toBool();
-    Settings::values.disable_macro_jit =
-        ReadSetting(QStringLiteral("disable_macro_jit"), false).toBool();
 
     qt_config->endGroup();
 }
@@ -1013,7 +1011,6 @@ void Config::SaveDebuggingValues() {
     WriteSetting(QStringLiteral("dump_nso"), Settings::values.dump_nso, false);
     WriteSetting(QStringLiteral("quest_flag"), Settings::values.quest_flag, false);
     WriteSetting(QStringLiteral("disable_cpu_opt"), Settings::values.disable_cpu_opt, false);
-    WriteSetting(QStringLiteral("disable_macro_jit"), Settings::values.disable_macro_jit, false);
 
     qt_config->endGroup();
 }

src/yuzu/configuration/configure_debug.cpp

@@ -39,8 +39,6 @@ void ConfigureDebug::SetConfiguration() {
     ui->disable_cpu_opt->setChecked(Settings::values.disable_cpu_opt);
     ui->enable_graphics_debugging->setEnabled(!Core::System::GetInstance().IsPoweredOn());
     ui->enable_graphics_debugging->setChecked(Settings::values.renderer_debug);
-    ui->disable_macro_jit->setEnabled(!Core::System::GetInstance().IsPoweredOn());
-    ui->disable_macro_jit->setChecked(Settings::values.disable_macro_jit);
 }
 
 void ConfigureDebug::ApplyConfiguration() {
@@ -53,7 +51,6 @@ void ConfigureDebug::ApplyConfiguration() {
     Settings::values.quest_flag = ui->quest_flag->isChecked();
     Settings::values.disable_cpu_opt = ui->disable_cpu_opt->isChecked();
     Settings::values.renderer_debug = ui->enable_graphics_debugging->isChecked();
-    Settings::values.disable_macro_jit = ui->disable_macro_jit->isChecked();
     Debugger::ToggleConsole();
     Log::Filter filter;
     filter.ParseFilterString(Settings::values.log_filter);

src/yuzu/configuration/configure_debug.ui

@@ -148,19 +148,6 @@
         </property>
        </widget>
       </item>
-      <item>
-       <widget class="QCheckBox" name="disable_macro_jit">
-        <property name="enabled">
-         <bool>true</bool>
-        </property>
-        <property name="whatsThis">
-         <string>When checked, it disables the macro Just In Time compiler. Enabled this makes games run slower</string>
-        </property>
-        <property name="text">
-         <string>Disable Macro JIT</string>
-        </property>
-       </widget>
-      </item>
      </layout>
     </widget>
    </item>

src/yuzu/configuration/configure_input_player.cpp

@@ -480,9 +480,7 @@ void ConfigureInputPlayer::RestoreDefaults() {
             SetAnalogButton(params, analogs_param[analog_id], analog_sub_buttons[sub_button_id]);
         }
     }
-
     UpdateButtonLabels();
-    ApplyConfiguration();
 }
 
 void ConfigureInputPlayer::ClearAll() {
@@ -507,7 +505,6 @@ void ConfigureInputPlayer::ClearAll() {
     }
 
     UpdateButtonLabels();
-    ApplyConfiguration();
 }
 
 void ConfigureInputPlayer::UpdateButtonLabels() {

src/yuzu_cmd/config.cpp

@@ -432,8 +432,6 @@ void Config::ReadValues() {
     Settings::values.quest_flag = sdl2_config->GetBoolean("Debugging", "quest_flag", false);
     Settings::values.disable_cpu_opt =
         sdl2_config->GetBoolean("Debugging", "disable_cpu_opt", false);
-    Settings::values.disable_macro_jit =
-        sdl2_config->GetBoolean("Debugging", "disable_macro_jit", false);
 
     const auto title_list = sdl2_config->Get("AddOns", "title_ids", "");
     std::stringstream ss(title_list);

src/yuzu_cmd/default_ini.h

@@ -291,8 +291,6 @@ quest_flag =
 # Determines whether or not JIT CPU optimizations are enabled
 # false: Optimizations Enabled, true: Optimizations Disabled
 disable_cpu_opt =
-# Enables/Disables the macro JIT compiler
-disable_macro_jit=false
 
 [WebService]
 # Whether or not to enable telemetry