spirv: nuke spv_opt

Signed-off-by: lizzie <lizzie@eden-emu.dev>

.gitmodules

@@ -68,9 +68,6 @@
 [submodule "Vulkan-Utility-Libraries"]
 	path = externals/Vulkan-Utility-Libraries
 	url = https://github.com/KhronosGroup/Vulkan-Utility-Libraries.git
-[submodule "externals/spirv-tools"]
-	path = externals/spirv-tools
-	url = https://github.com/KhronosGroup/SPIRV-Tools.git
 [submodule "externals/SPIRV-Headers"]
 	path = externals/SPIRV-Headers
 	url = https://github.com/KhronosGroup/SPIRV-Headers

src/citron/configuration/shared_translation.cpp

@@ -246,8 +246,6 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QWidget* parent) {
         Settings, renderer_force_max_clock, tr("Force maximum clocks (Vulkan only)"),
         tr("Runs work in the background while waiting for graphics commands to keep the GPU from "
            "lowering its clock speed."));
-    INSERT(Settings, optimize_spirv_output, tr("SPIR-V Shader Optimization"),
-           tr("Optimizes SPIR-V shaders for potentially better performance."));
     INSERT(Settings, max_anisotropy, tr("Anisotropic Filtering:"),
            tr("Controls the quality of texture rendering at oblique angles.\nIt's a light setting "
               "and safe to set at 16x on most GPUs."));

src/common/settings.h

@@ -607,10 +607,6 @@ struct Values {
     Setting<bool> disable_buffer_reorder{linkage, false, "disable_buffer_reorder",
                                          Category::RendererDebug};
 
-    SwitchableSetting<SpirvShaderOptimization> optimize_spirv_output{
-        linkage, SpirvShaderOptimization::Auto, "optimize_spirv_output",
-        Category::RendererAdvanced};
-
     // System
     SwitchableSetting<Language, true> language_index{linkage,
                                                      Language::EnglishAmerican,

src/shader_recompiler/CMakeLists.txt

@@ -193,7 +193,7 @@ add_library(shader_recompiler STATIC
     varying_state.h
 )
 
-target_link_libraries(shader_recompiler PUBLIC common fmt::fmt sirit SPIRV-Tools-opt)
+target_link_libraries(shader_recompiler PUBLIC common fmt::fmt sirit)
 
 if (MSVC)
     target_compile_options(shader_recompiler PRIVATE

src/shader_recompiler/backend/spirv/emit_spirv.cpp

@@ -8,7 +8,6 @@
 #include <utility>
 #include <vector>
 
-#include <spirv-tools/optimizer.hpp>
 #include "common/settings.h"
 
 #include "common/logging.h"
@@ -22,16 +21,6 @@
 namespace Shader::Backend::SPIRV {
 namespace {
 
-thread_local std::unique_ptr<spvtools::Optimizer> thread_optimizer;
-
-spvtools::Optimizer& GetThreadOptimizer() {
-    if (!thread_optimizer) {
-        thread_optimizer = std::make_unique<spvtools::Optimizer>(SPV_ENV_VULKAN_1_3);
-        thread_optimizer->RegisterPerformancePasses();
-    }
-    return *thread_optimizer;
-}
-
 template <class Func>
 struct FuncTraits {};
 
@@ -497,8 +486,7 @@ void PatchPhiNodes(IR::Program& program, EmitContext& ctx) {
 }
 } // Anonymous namespace
 
-std::vector<u32> EmitSPIRV(const Profile& profile, const RuntimeInfo& runtime_info,
+std::vector<u32> EmitSPIRV(const Profile& profile, const RuntimeInfo& runtime_info, IR::Program& program, Bindings& bindings) {
-                           IR::Program& program, Bindings& bindings, bool optimize) {
     EmitContext ctx{profile, runtime_info, program, bindings};
     const Id main{DefineMain(ctx, program)};
     DefineEntryPoint(program, ctx, main);
@@ -510,22 +498,7 @@ std::vector<u32> EmitSPIRV(const Profile& profile, const RuntimeInfo& runtime_in
     SetupCapabilities(profile, program.info, ctx);
     SetupTransformFeedbackCapabilities(ctx, main);
     PatchPhiNodes(program, ctx);
-
+    return ctx.Assemble();
-    std::vector<u32> spirv = ctx.Assemble();
-    if (optimize) {
-        // Use thread-local optimizer instead of creating a new one
-        auto& spv_opt = GetThreadOptimizer();
-        spv_opt.SetMessageConsumer([](spv_message_level_t, const char*, const spv_position_t&, const char* m) { LOG_ERROR(HW_GPU, "spirv-opt: {}", m); });
-        spvtools::OptimizerOptions opt_options;
-        opt_options.set_run_validator(false);
-        std::vector<u32> result{};
-        if (!spv_opt.Run(spirv.data(), spirv.size(), &result, opt_options)) {
-            LOG_ERROR(HW_GPU, "Failed to optimize SPIRV output, continuing without optimization");
-            return spirv;
-        }
-        return result;
-    }
-    return spirv;
 }
 
 Id EmitPhi(EmitContext& ctx, IR::Inst* inst) {

src/shader_recompiler/backend/spirv/emit_spirv.h

@@ -30,14 +30,11 @@ constexpr u32 RESCALING_LAYOUT_WORDS_OFFSET = offsetof(RescalingLayout, rescalin
 constexpr u32 RESCALING_LAYOUT_DOWN_FACTOR_OFFSET = offsetof(RescalingLayout, down_factor);
 constexpr u32 RENDERAREA_LAYOUT_OFFSET = offsetof(RenderAreaLayout, render_area);
 
-[[nodiscard]] std::vector<u32> EmitSPIRV(const Profile& profile, const RuntimeInfo& runtime_info,
+[[nodiscard]] std::vector<u32> EmitSPIRV(const Profile& profile, const RuntimeInfo& runtime_info, IR::Program& program, Bindings& bindings);
-                                         IR::Program& program, Bindings& bindings,
-                                         bool optimize = false);
 
-[[nodiscard]] inline std::vector<u32> EmitSPIRV(const Profile& profile, IR::Program& program,
+[[nodiscard]] inline std::vector<u32> EmitSPIRV(const Profile& profile, IR::Program& program) {
-                                                bool optimize = false) {
     Bindings binding;
-    return EmitSPIRV(profile, {}, program, binding, optimize);
+    return EmitSPIRV(profile, {}, program, binding);
 }
 
 } // namespace Shader::Backend::SPIRV

src/video_core/renderer_vulkan/vk_pipeline_cache.cpp

@@ -755,9 +755,7 @@ std::unique_ptr<GraphicsPipeline> PipelineCache::CreateGraphicsPipeline(
 
         const auto runtime_info{MakeRuntimeInfo(programs, key, program, previous_stage)};
         ConvertLegacyToGeneric(program, runtime_info);
-        const bool optimize = Settings::values.optimize_spirv_output.GetValue() ==
+        std::vector<u32> code = EmitSPIRV(profile, runtime_info, program, binding);
-                              Settings::SpirvShaderOptimization::Auto;
-        std::vector<u32> code = EmitSPIRV(profile, runtime_info, program, binding, optimize);
         // Reserve space to reduce allocations during shader compilation
         code.reserve(std::max<size_t>(code.size(), 16 * 1024 / sizeof(u32)));
         device.SaveShader(code);
@@ -861,9 +859,7 @@ std::unique_ptr<ComputePipeline> PipelineCache::CreateComputePipeline(
     }
 
     auto program{TranslateProgram(pools.inst, pools.block, env, cfg, host_info)};
-    bool optimize = Settings::values.optimize_spirv_output.GetValue() ==
+    std::vector<u32> code = EmitSPIRV(profile, program);
-                    Settings::SpirvShaderOptimization::Auto;
-    std::vector<u32> code = EmitSPIRV(profile, program, optimize);
     // Reserve space to reduce allocations during shader compilation
     code.reserve(std::max<size_t>(code.size(), 16 * 1024 / sizeof(u32)));
     device.SaveShader(code);