nvhost_ctrl: Stub out IocCtrlEventKill

src/CMakeLists.txt

@@ -32,7 +32,6 @@ if (MSVC)
     # /Zc:externConstexpr - Allow extern constexpr variables to have external linkage, like the standard mandates
     # /Zc:inline          - Let codegen omit inline functions in object files
     # /Zc:throwingNew     - Let codegen assume `operator new` (without std::nothrow) will never return null
-    # /GT                 - Supports fiber safety for data allocated using static thread-local storage
     add_compile_options(
         /MP
         /Zi
@@ -45,7 +44,6 @@ if (MSVC)
         /Zc:externConstexpr
         /Zc:inline
         /Zc:throwingNew
-        /GT
 
         # External headers diagnostics
         /experimental:external  # Enables the external headers options. This option isn't required in Visual Studio 2019 version 16.10 and later
@@ -71,10 +69,6 @@ if (MSVC)
         /we5038 # data member 'member1' will be initialized after data member 'member2'
     )
 
-    if (ARCHITECTURE_x86_64)
-        add_compile_options(/QIntel-jcc-erratum)
-    endif()
-
     # /GS- - No stack buffer overflow checks
     add_compile_options("$<$<CONFIG:Release>:/GS->")
 

src/common/logging/backend.cpp

@@ -6,7 +6,6 @@
 #include <chrono>
 #include <climits>
 #include <exception>
-#include <stop_token>
 #include <thread>
 #include <vector>
 
@@ -187,10 +186,6 @@ public:
         initialization_in_progress_suppress_logging = false;
     }
 
-    static void Start() {
-        instance->StartBackendThread();
-    }
-
     Impl(const Impl&) = delete;
     Impl& operator=(const Impl&) = delete;
 
@@ -206,7 +201,7 @@ public:
     }
 
     void PushEntry(Class log_class, Level log_level, const char* filename, unsigned int line_num,
-                   const char* function, std::string&& message) {
+                   const char* function, std::string message) {
         if (!filter.CheckMessage(log_class, log_level))
             return;
         const Entry& entry =
@@ -216,41 +211,40 @@ public:
 
 private:
     Impl(const std::filesystem::path& file_backend_filename, const Filter& filter_)
-        : filter{filter_}, file_backend{file_backend_filename} {}
+        : filter{filter_}, file_backend{file_backend_filename}, backend_thread{std::thread([this] {
+              Common::SetCurrentThreadName("yuzu:Log");
+              Entry entry;
+              const auto write_logs = [this, &entry]() {
+                  ForEachBackend([&entry](Backend& backend) { backend.Write(entry); });
+              };
+              while (true) {
+                  entry = message_queue.PopWait();
+                  if (entry.final_entry) {
+                      break;
+                  }
+                  write_logs();
+              }
+              // Drain the logging queue. Only writes out up to MAX_LOGS_TO_WRITE to prevent a
+              // case where a system is repeatedly spamming logs even on close.
+              int max_logs_to_write = filter.IsDebug() ? INT_MAX : 100;
+              while (max_logs_to_write-- && message_queue.Pop(entry)) {
+                  write_logs();
+              }
+          })} {}
 
     ~Impl() {
         StopBackendThread();
     }
 
-    void StartBackendThread() {
-        backend_thread = std::thread([this] {
-            Common::SetCurrentThreadName("yuzu:Log");
-            Entry entry;
-            const auto write_logs = [this, &entry]() {
-                ForEachBackend([&entry](Backend& backend) { backend.Write(entry); });
-            };
-            while (!stop.stop_requested()) {
-                entry = message_queue.PopWait(stop.get_token());
-                if (entry.filename != nullptr) {
-                    write_logs();
-                }
-            }
-            // Drain the logging queue. Only writes out up to MAX_LOGS_TO_WRITE to prevent a
-            // case where a system is repeatedly spamming logs even on close.
-            int max_logs_to_write = filter.IsDebug() ? INT_MAX : 100;
-            while (max_logs_to_write-- && message_queue.Pop(entry)) {
-                write_logs();
-            }
-        });
-    }
-
     void StopBackendThread() {
-        stop.request_stop();
+        Entry stop_entry{};
+        stop_entry.final_entry = true;
+        message_queue.Push(stop_entry);
         backend_thread.join();
     }
 
     Entry CreateEntry(Class log_class, Level log_level, const char* filename, unsigned int line_nr,
-                      const char* function, std::string&& message) const {
+                      const char* function, std::string message) const {
         using std::chrono::duration_cast;
         using std::chrono::microseconds;
         using std::chrono::steady_clock;
@@ -263,6 +257,7 @@ private:
             .line_num = line_nr,
             .function = function,
             .message = std::move(message),
+            .final_entry = false,
         };
     }
 
@@ -283,9 +278,8 @@ private:
     ColorConsoleBackend color_console_backend{};
     FileBackend file_backend;
 
-    std::stop_source stop;
     std::thread backend_thread;
-    MPSCQueue<Entry, true> message_queue{};
+    MPSCQueue<Entry> message_queue{};
     std::chrono::steady_clock::time_point time_origin{std::chrono::steady_clock::now()};
 };
 } // namespace
@@ -294,10 +288,6 @@ void Initialize() {
     Impl::Initialize();
 }
 
-void Start() {
-    Impl::Start();
-}
-
 void DisableLoggingInTests() {
     initialization_in_progress_suppress_logging = true;
 }

src/common/logging/backend.h

@@ -14,8 +14,6 @@ class Filter;
 /// Initializes the logging system. This should be the first thing called in main.
 void Initialize();
 
-void Start();
-
 void DisableLoggingInTests();
 
 /**

src/common/logging/log_entry.h

@@ -22,6 +22,7 @@ struct Entry {
     unsigned int line_num = 0;
     std::string function;
     std::string message;
+    bool final_entry = false;
 };
 
 } // namespace Common::Log

src/core/file_sys/control_metadata.cpp

@@ -9,7 +9,7 @@
 
 namespace FileSys {
 
-const std::array<const char*, 16> LANGUAGE_NAMES{{
+const std::array<const char*, 15> LANGUAGE_NAMES{{
     "AmericanEnglish",
     "BritishEnglish",
     "Japanese",
@@ -25,7 +25,6 @@ const std::array<const char*, 16> LANGUAGE_NAMES{{
     "Korean",
     "Taiwanese",
     "Chinese",
-    "BrazilianPortuguese",
 }};
 
 std::string LanguageEntry::GetApplicationName() const {

src/core/file_sys/control_metadata.h

@@ -88,12 +88,11 @@ enum class Language : u8 {
     Korean = 12,
     Taiwanese = 13,
     Chinese = 14,
-    BrazilianPortuguese = 15,
 
     Default = 255,
 };
 
-extern const std::array<const char*, 16> LANGUAGE_NAMES;
+extern const std::array<const char*, 15> LANGUAGE_NAMES;
 
 // A class representing the format used by NX metadata files, typically named Control.nacp.
 // These store application name, dev name, title id, and other miscellaneous data.

src/core/hle/kernel/k_scheduler.h

@@ -49,11 +49,6 @@ public:
     /// Gets the current running thread
     [[nodiscard]] KThread* GetCurrentThread() const;
 
-    /// Gets the idle thread
-    [[nodiscard]] KThread* GetIdleThread() const {
-        return idle_thread;
-    }
-
     /// Returns true if the scheduler is idle
     [[nodiscard]] bool IsIdle() const {
         return GetCurrentThread() == idle_thread;

src/core/hle/kernel/svc.cpp

@@ -886,24 +886,7 @@ static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, Handle
         *result = out_ticks;
         return ResultSuccess;
     }
-    case GetInfoType::IdleTickCount: {
-        if (handle == 0) {
-            LOG_ERROR(Kernel_SVC, "Thread handle does not exist, handle=0x{:08X}",
-                      static_cast<Handle>(handle));
-            return ResultInvalidHandle;
-        }
 
-        if (info_sub_id != 0xFFFFFFFFFFFFFFFF && info_sub_id != system.CurrentCoreIndex()) {
-            LOG_ERROR(Kernel_SVC, "Core is not the current core, got {}", info_sub_id);
-            return ResultInvalidCombination;
-        }
-
-        const auto& scheduler = *system.Kernel().CurrentScheduler();
-        const auto* const idle_thread = scheduler.GetIdleThread();
-
-        *result = idle_thread->GetCpuTime();
-        return ResultSuccess;
-    }
     default:
         LOG_ERROR(Kernel_SVC, "Unimplemented svcGetInfo id=0x{:016X}", info_id);
         return ResultInvalidEnumValue;

src/core/hle/result.h

@@ -206,7 +206,7 @@ public:
         return result;
     }
 
-    ResultVal(const ResultVal& o) noexcept : result_code(o.result_code) {
+    ResultVal(const ResultVal& o) : result_code(o.result_code) {
         if (!o.empty()) {
             new (&object) T(o.object);
         }
@@ -224,7 +224,7 @@ public:
         }
     }
 
-    ResultVal& operator=(const ResultVal& o) noexcept {
+    ResultVal& operator=(const ResultVal& o) {
         if (this == &o) {
             return *this;
         }
@@ -244,26 +244,6 @@ public:
         return *this;
     }
 
-    ResultVal& operator=(ResultVal&& o) noexcept {
-        if (this == &o) {
-            return *this;
-        }
-        if (!empty()) {
-            if (!o.empty()) {
-                object = std::move(o.object);
-            } else {
-                object.~T();
-            }
-        } else {
-            if (!o.empty()) {
-                new (&object) T(std::move(o.object));
-            }
-        }
-        result_code = o.result_code;
-
-        return *this;
-    }
-
     /**
      * Replaces the current result with a new constructed result value in-place. The code must not
      * be an error code.
@@ -349,8 +329,8 @@ template <typename T, typename... Args>
  * copy or move constructing.
  */
 template <typename Arg>
-[[nodiscard]] ResultVal<std::remove_cvref_t<Arg>> MakeResult(Arg&& arg) {
-    return ResultVal<std::remove_cvref_t<Arg>>::WithCode(ResultSuccess, std::forward<Arg>(arg));
+[[nodiscard]] ResultVal<std::remove_reference_t<Arg>> MakeResult(Arg&& arg) {
+    return ResultVal<std::remove_reference_t<Arg>>::WithCode(ResultSuccess, std::forward<Arg>(arg));
 }
 
 /**

src/core/hle/service/ns/language.cpp

@@ -277,25 +277,6 @@ constexpr ApplicationLanguagePriorityList priority_list_simplified_chinese = {{
     ApplicationLanguage::Korean,
 }};
 
-constexpr ApplicationLanguagePriorityList priority_list_brazilian_portuguese = {{
-    ApplicationLanguage::BrazilianPortuguese,
-    ApplicationLanguage::Portuguese,
-    ApplicationLanguage::LatinAmericanSpanish,
-    ApplicationLanguage::AmericanEnglish,
-    ApplicationLanguage::BritishEnglish,
-    ApplicationLanguage::Japanese,
-    ApplicationLanguage::French,
-    ApplicationLanguage::German,
-    ApplicationLanguage::Spanish,
-    ApplicationLanguage::Italian,
-    ApplicationLanguage::Dutch,
-    ApplicationLanguage::CanadianFrench,
-    ApplicationLanguage::Russian,
-    ApplicationLanguage::Korean,
-    ApplicationLanguage::SimplifiedChinese,
-    ApplicationLanguage::TraditionalChinese,
-}};
-
 const ApplicationLanguagePriorityList* GetApplicationLanguagePriorityList(
     const ApplicationLanguage lang) {
     switch (lang) {
@@ -329,8 +310,6 @@ const ApplicationLanguagePriorityList* GetApplicationLanguagePriorityList(
         return &priority_list_traditional_chinese;
     case ApplicationLanguage::SimplifiedChinese:
         return &priority_list_simplified_chinese;
-    case ApplicationLanguage::BrazilianPortuguese:
-        return &priority_list_brazilian_portuguese;
     default:
         return nullptr;
     }
@@ -360,6 +339,7 @@ std::optional<ApplicationLanguage> ConvertToApplicationLanguage(
     case Set::LanguageCode::FR_CA:
         return ApplicationLanguage::CanadianFrench;
     case Set::LanguageCode::PT:
+    case Set::LanguageCode::PT_BR:
         return ApplicationLanguage::Portuguese;
     case Set::LanguageCode::RU:
         return ApplicationLanguage::Russian;
@@ -371,8 +351,6 @@ std::optional<ApplicationLanguage> ConvertToApplicationLanguage(
     case Set::LanguageCode::ZH_CN:
     case Set::LanguageCode::ZH_HANS:
         return ApplicationLanguage::SimplifiedChinese;
-    case Set::LanguageCode::PT_BR:
-        return ApplicationLanguage::BrazilianPortuguese;
     default:
         return std::nullopt;
     }
@@ -410,8 +388,6 @@ std::optional<Set::LanguageCode> ConvertToLanguageCode(const ApplicationLanguage
         return Set::LanguageCode::ZH_HANT;
     case ApplicationLanguage::SimplifiedChinese:
         return Set::LanguageCode::ZH_HANS;
-    case ApplicationLanguage::BrazilianPortuguese:
-        return Set::LanguageCode::PT_BR;
     default:
         return std::nullopt;
     }

src/core/hle/service/ns/language.h

@@ -30,7 +30,6 @@ enum class ApplicationLanguage : u8 {
     Korean,
     TraditionalChinese,
     SimplifiedChinese,
-    BrazilianPortuguese,
     Count
 };
 using ApplicationLanguagePriorityList =

src/core/hle/service/nvdrv/devices/nvhost_ctrl.cpp

@@ -38,6 +38,8 @@ NvResult nvhost_ctrl::Ioctl1(DeviceFD fd, Ioctl command, const std::vector<u8>&
             return IocCtrlEventRegister(input, output);
         case 0x20:
             return IocCtrlEventUnregister(input, output);
+        case 0x21:
+            return IocCtrlEventKill(input, output);
         }
         break;
     default:
@@ -221,4 +223,22 @@ NvResult nvhost_ctrl::IocCtrlClearEventWait(const std::vector<u8>& input, std::v
     return NvResult::Success;
 }
 
+NvResult nvhost_ctrl::IocCtrlEventKill(const std::vector<u8>& input, std::vector<u8>& output) {
+    IocCtrlEventKillParams params{};
+    std::memcpy(&params, input.data(), sizeof(params));
+
+    LOG_WARNING(Service_NVDRV, "called, user_events={}", params.user_events);
+
+    for (u32 event_id = 0; event_id < MaxNvEvents; ++event_id) {
+        if ((params.user_events & (1ULL << (int)event_id)) != 0) {
+            if (!events_interface.registered[event_id]) {
+                continue;
+            }
+            events_interface.UnregisterEvent(event_id);
+        }
+    }
+
+    return NvResult::Success;
+}
+
 } // namespace Service::Nvidia::Devices

src/core/hle/service/nvdrv/devices/nvhost_ctrl.h

@@ -119,16 +119,17 @@ private:
     static_assert(sizeof(IocCtrlEventUnregisterParams) == 4,
                   "IocCtrlEventUnregisterParams is incorrect size");
 
-    struct IocCtrlEventKill {
+    struct IocCtrlEventKillParams {
         u64_le user_events{};
     };
-    static_assert(sizeof(IocCtrlEventKill) == 8, "IocCtrlEventKill is incorrect size");
+    static_assert(sizeof(IocCtrlEventKillParams) == 8, "IocCtrlEventKillParams is incorrect size");
 
     NvResult NvOsGetConfigU32(const std::vector<u8>& input, std::vector<u8>& output);
     NvResult IocCtrlEventWait(const std::vector<u8>& input, std::vector<u8>& output, bool is_async);
     NvResult IocCtrlEventRegister(const std::vector<u8>& input, std::vector<u8>& output);
     NvResult IocCtrlEventUnregister(const std::vector<u8>& input, std::vector<u8>& output);
     NvResult IocCtrlClearEventWait(const std::vector<u8>& input, std::vector<u8>& output);
+    NvResult IocCtrlEventKill(const std::vector<u8>& input, std::vector<u8>& output);
 
     EventInterface& events_interface;
     SyncpointManager& syncpoint_manager;

src/shader_recompiler/backend/spirv/emit_spirv_image.cpp

@@ -355,22 +355,11 @@ Id EmitImageSampleExplicitLod(EmitContext& ctx, IR::Inst* inst, const IR::Value&
 Id EmitImageSampleDrefImplicitLod(EmitContext& ctx, IR::Inst* inst, const IR::Value& index,
                                   Id coords, Id dref, Id bias_lc, const IR::Value& offset) {
     const auto info{inst->Flags<IR::TextureInstInfo>()};
-    if (ctx.stage == Stage::Fragment) {
-        const ImageOperands operands(ctx, info.has_bias != 0, false, info.has_lod_clamp != 0,
-                                     bias_lc, offset);
-        return Emit(&EmitContext::OpImageSparseSampleDrefImplicitLod,
-                    &EmitContext::OpImageSampleDrefImplicitLod, ctx, inst, ctx.F32[1],
-                    Texture(ctx, info, index), coords, dref, operands.MaskOptional(),
-                    operands.Span());
-    } else {
-        // Implicit lods in compute behave on hardware as if sampling from LOD 0.
-        // This check is to ensure all drivers behave this way.
-        const Id lod{ctx.Const(0.0f)};
-        const ImageOperands operands(ctx, false, true, false, lod, offset);
-        return Emit(&EmitContext::OpImageSparseSampleDrefExplicitLod,
-                    &EmitContext::OpImageSampleDrefExplicitLod, ctx, inst, ctx.F32[1],
-                    Texture(ctx, info, index), coords, dref, operands.Mask(), operands.Span());
-    }
+    const ImageOperands operands(ctx, info.has_bias != 0, false, info.has_lod_clamp != 0, bias_lc,
+                                 offset);
+    return Emit(&EmitContext::OpImageSparseSampleDrefImplicitLod,
+                &EmitContext::OpImageSampleDrefImplicitLod, ctx, inst, ctx.F32[1],
+                Texture(ctx, info, index), coords, dref, operands.MaskOptional(), operands.Span());
 }
 
 Id EmitImageSampleDrefExplicitLod(EmitContext& ctx, IR::Inst* inst, const IR::Value& index,

src/video_core/renderer_opengl/gl_device.cpp

@@ -181,21 +181,6 @@ Device::Device() {
         LOG_ERROR(Render_OpenGL, "Assembly shaders enabled but not supported");
         shader_backend = Settings::ShaderBackend::GLSL;
     }
-
-    if (shader_backend == Settings::ShaderBackend::GLSL && is_nvidia &&
-        !Settings::values.renderer_debug) {
-        const std::string_view driver_version = version.substr(13);
-        const int version_major =
-            std::atoi(driver_version.substr(0, driver_version.find(".")).data());
-
-        if (version_major >= 495) {
-            LOG_WARNING(Render_OpenGL, "NVIDIA drivers 495 and later causes significant problems "
-                                       "with yuzu. Forcing GLASM as a mitigation.");
-            shader_backend = Settings::ShaderBackend::GLASM;
-            use_assembly_shaders = true;
-        }
-    }
-
     // Blocks AMD and Intel OpenGL drivers on Windows from using asynchronous shader compilation.
     use_asynchronous_shaders = Settings::values.use_asynchronous_shaders.GetValue() &&
                                !(is_amd || (is_intel && !is_linux));

src/yuzu/CMakeLists.txt

@@ -299,11 +299,6 @@ if (YUZU_USE_BUNDLED_QT)
     copy_yuzu_Qt5_deps(yuzu)
 endif()
 
-if (ENABLE_SDL2)
-    target_link_libraries(yuzu PRIVATE SDL2)
-    target_compile_definitions(yuzu PRIVATE HAVE_SDL2)
-endif()
-
 if (MSVC)
     include(CopyYuzuSDLDeps)
     include(CopyYuzuFFmpegDeps)

src/yuzu/configuration/configure_dialog.cpp

@@ -81,11 +81,8 @@ ConfigureDialog::ConfigureDialog(QWidget* parent, HotkeyRegistry& registry,
     SetConfiguration();
     PopulateSelectionList();
 
-    connect(ui->tabWidget, &QTabWidget::currentChanged, this, [this](int index) {
-        if (index != -1) {
-            debug_tab_tab->SetCurrentIndex(0);
-        }
-    });
+    connect(ui->tabWidget, &QTabWidget::currentChanged, this,
+            [this]() { debug_tab_tab->SetCurrentIndex(0); });
     connect(ui_tab.get(), &ConfigureUi::LanguageChanged, this, &ConfigureDialog::OnLanguageChanged);
     connect(ui->selectorList, &QListWidget::itemSelectionChanged, this,
             &ConfigureDialog::UpdateVisibleTabs);

src/yuzu/configuration/configure_per_game.cpp

@@ -66,7 +66,7 @@ ConfigurePerGame::ConfigurePerGame(QWidget* parent, u64 title_id, const std::str
     ui->tabWidget->addTab(system_tab.get(), tr("System"));
     ui->tabWidget->addTab(cpu_tab.get(), tr("CPU"));
     ui->tabWidget->addTab(graphics_tab.get(), tr("Graphics"));
-    ui->tabWidget->addTab(graphics_advanced_tab.get(), tr("Adv. Graphics"));
+    ui->tabWidget->addTab(graphics_advanced_tab.get(), tr("GraphicsAdvanced"));
     ui->tabWidget->addTab(audio_tab.get(), tr("Audio"));
 
     setFocusPolicy(Qt::ClickFocus);

src/yuzu/configuration/configure_per_game.ui

@@ -2,6 +2,14 @@
 <ui version="4.0">
  <class>ConfigurePerGame</class>
  <widget class="QDialog" name="ConfigurePerGame">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>900</width>
+    <height>630</height>
+   </rect>
+  </property>
   <property name="minimumSize">
    <size>
     <width>900</width>

src/yuzu/main.cpp

@@ -66,10 +66,6 @@ static FileSys::VirtualFile VfsDirectoryCreateFileWrapper(const FileSys::Virtual
 #include <QUrl>
 #include <QtConcurrent/QtConcurrent>
 
-#ifdef HAVE_SDL2
-#include <SDL.h> // For SDL ScreenSaver functions
-#endif
-
 #include <fmt/format.h>
 #include "common/detached_tasks.h"
 #include "common/fs/fs.h"
@@ -291,16 +287,6 @@ GMainWindow::GMainWindow()
 
     ui->action_Fullscreen->setChecked(false);
 
-#if defined(HAVE_SDL2) && !defined(_WIN32)
-    SDL_InitSubSystem(SDL_INIT_VIDEO);
-    // SDL disables the screen saver by default, and setting the hint
-    // SDL_HINT_VIDEO_ALLOW_SCREENSAVER doesn't seem to work, so we just enable the screen saver
-    // for now.
-    SDL_EnableScreenSaver();
-#endif
-
-    Common::Log::Start();
-
     QStringList args = QApplication::arguments();
 
     if (args.size() < 2) {
@@ -371,9 +357,8 @@ GMainWindow::GMainWindow()
 
 GMainWindow::~GMainWindow() {
     // will get automatically deleted otherwise
-    if (render_window->parent() == nullptr) {
+    if (render_window->parent() == nullptr)
         delete render_window;
-    }
 }
 
 void GMainWindow::RegisterMetaTypes() {
@@ -1238,16 +1223,12 @@ void GMainWindow::OnDisplayTitleBars(bool show) {
 void GMainWindow::PreventOSSleep() {
 #ifdef _WIN32
     SetThreadExecutionState(ES_CONTINUOUS | ES_SYSTEM_REQUIRED | ES_DISPLAY_REQUIRED);
-#elif defined(HAVE_SDL2)
-    SDL_DisableScreenSaver();
 #endif
 }
 
 void GMainWindow::AllowOSSleep() {
 #ifdef _WIN32
     SetThreadExecutionState(ES_CONTINUOUS);
-#elif defined(HAVE_SDL2)
-    SDL_EnableScreenSaver();
 #endif
 }