diff -upr pcsx2-main.org/3rdparty/wxwidgets3.0/CMakeLists.txt pcsx2-main/3rdparty/wxwidgets3.0/CMakeLists.txt
--- pcsx2-main.org/3rdparty/wxwidgets3.0/CMakeLists.txt	2022-05-11 09:38:42.000000000 +0900
+++ pcsx2-main/3rdparty/wxwidgets3.0/CMakeLists.txt	2022-05-16 22:22:59.907250000 +0900
@@ -1,9 +1,9 @@
 if(UNIX)
 set(wxUnixSources
+   src/unix/fswatcher_kqueue.cpp
    src/unix/appunix.cpp
    src/unix/dir.cpp
    src/unix/evtloopunix.cpp
-   src/unix/epolldispatcher.cpp
    src/unix/threadpsx.cpp
    src/unix/utilsunx.cpp
    src/unix/wakeuppipe.cpp
diff -upr pcsx2-main.org/3rdparty/wxwidgets3.0/include/nogui/wx/setup.h pcsx2-main/3rdparty/wxwidgets3.0/include/nogui/wx/setup.h
--- pcsx2-main.org/3rdparty/wxwidgets3.0/include/nogui/wx/setup.h	2022-05-11 09:38:42.000000000 +0900
+++ pcsx2-main/3rdparty/wxwidgets3.0/include/nogui/wx/setup.h	2022-05-16 22:24:30.379741000 +0900
@@ -553,7 +553,7 @@
 #define HAVE_SYS_SELECT_H 1
 
 /* Define if you have abi::__forced_unwind in your <cxxabi.h>. */
-#define HAVE_ABI_FORCEDUNWIND 1
+/*#define HAVE_ABI_FORCEDUNWIND 1*/
 
 /* Define if fdopen is available.  */
 #define HAVE_FDOPEN 1
diff -uprN pcsx2-main.org/3rdparty/wxwidgets3.0/src/unix/fswatcher_kqueue.cpp pcsx2-main/3rdparty/wxwidgets3.0/src/unix/fswatcher_kqueue.cpp
--- pcsx2-main.org/3rdparty/wxwidgets3.0/src/unix/fswatcher_kqueue.cpp	1970-01-01 09:00:00.000000000 +0900
+++ pcsx2-main/3rdparty/wxwidgets3.0/src/unix/fswatcher_kqueue.cpp	2022-05-15 20:13:00.474795000 +0900
@@ -0,0 +1,459 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        src/unix/fswatcher_kqueue.cpp
+// Purpose:     kqueue-based wxFileSystemWatcher implementation
+// Author:      Bartosz Bekier
+// Created:     2009-05-26
+// Copyright:   (c) 2009 Bartosz Bekier <bartosz.bekier@gmail.com>
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+// For compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
+
+#ifdef __BORLANDC__
+    #pragma hdrstop
+#endif
+
+#if wxUSE_FSWATCHER
+
+#include "wx/fswatcher.h"
+
+#ifdef wxHAS_KQUEUE
+
+#include <inttypes.h>
+#include <sys/types.h>
+#include <sys/event.h>
+#include <sys/param.h>
+
+#include "wx/dynarray.h"
+#include "wx/evtloop.h"
+#include "wx/evtloopsrc.h"
+
+#include "wx/private/fswatcher.h"
+
+namespace
+{
+
+// NetBSD is different as it uses intptr_t as type of kevent struct udata field
+// for some reason, instead of "void*" as all the other platforms using kqueue.
+#ifdef __NetBSD__
+    inline intptr_t ToUdata(void* d) { return reinterpret_cast<intptr_t>(d); }
+    inline void* FromUdata(intptr_t d) { return reinterpret_cast<void*>(d); }
+#else
+    inline void* ToUdata(void* d) { return d; }
+    inline void* FromUdata(void* d) { return d; }
+#endif
+
+} // anonymous namespace
+
+// ============================================================================
+// wxFSWSourceHandler helper class
+// ============================================================================
+
+class wxFSWatcherImplKqueue;
+
+/**
+ * Handler for handling i/o from inotify descriptor
+ */
+class wxFSWSourceHandler : public wxEventLoopSourceHandler
+{
+public:
+    wxFSWSourceHandler(wxFSWatcherImplKqueue* service) :
+        m_service(service)
+    {  }
+
+    virtual void OnReadWaiting();
+    virtual void OnWriteWaiting();
+    virtual void OnExceptionWaiting();
+
+protected:
+    wxFSWatcherImplKqueue* m_service;
+};
+
+// ============================================================================
+// wxFSWatcherImpl implementation & helper wxFSWSourceHandler implementation
+// ============================================================================
+
+/**
+ * Helper class encapsulating inotify mechanism
+ */
+class wxFSWatcherImplKqueue : public wxFSWatcherImpl
+{
+public:
+    wxFSWatcherImplKqueue(wxFileSystemWatcherBase* watcher) :
+        wxFSWatcherImpl(watcher),
+        m_source(NULL),
+        m_kfd(-1)
+    {
+        m_handler = new wxFSWSourceHandler(this);
+    }
+
+    virtual ~wxFSWatcherImplKqueue()
+    {
+        // we close kqueue only if initialized before
+        if (IsOk())
+        {
+            Close();
+        }
+
+        delete m_handler;
+    }
+
+    bool Init()
+    {
+        wxCHECK_MSG( !IsOk(), false,
+                     "Kqueue appears to be already initialized" );
+
+        wxEventLoopBase *loop = wxEventLoopBase::GetActive();
+        wxCHECK_MSG( loop, false, "File system watcher needs an active loop" );
+
+        // create kqueue
+        m_kfd = kqueue();
+        if (m_kfd == -1)
+        {
+            wxLogSysError(_("Unable to create kqueue instance"));
+            return false;
+        }
+
+        // create source
+        m_source = loop->AddSourceForFD(m_kfd, m_handler, wxEVENT_SOURCE_INPUT);
+
+        return m_source != NULL;
+    }
+
+    void Close()
+    {
+        wxCHECK_RET( IsOk(),
+                    "Kqueue not initialized or invalid kqueue descriptor" );
+
+        if ( close(m_kfd) != 0 )
+        {
+            wxLogSysError(_("Error closing kqueue instance"));
+        }
+
+        wxDELETE(m_source);
+    }
+
+    virtual bool DoAdd(wxSharedPtr<wxFSWatchEntryKq> watch)
+    {
+        wxCHECK_MSG( IsOk(), false,
+                    "Kqueue not initialized or invalid kqueue descriptor" );
+
+        struct kevent event;
+        int action = EV_ADD | EV_ENABLE | EV_CLEAR | EV_ERROR;
+        int flags = Watcher2NativeFlags(watch->GetFlags());
+        EV_SET( &event, watch->GetFileDescriptor(), EVFILT_VNODE, action,
+                flags, 0, ToUdata(watch.get()) );
+
+        // TODO more error conditions according to man
+        // TODO best deal with the error here
+        int ret = kevent(m_kfd, &event, 1, NULL, 0, NULL);
+        if (ret == -1)
+        {
+            wxLogSysError(_("Unable to add kqueue watch"));
+            return false;
+        }
+
+        return true;
+    }
+
+    virtual bool DoRemove(wxSharedPtr<wxFSWatchEntryKq> watch)
+    {
+        wxCHECK_MSG( IsOk(), false,
+                    "Kqueue not initialized or invalid kqueue descriptor" );
+
+        // TODO more error conditions according to man
+        // XXX closing file descriptor removes the watch. The logic resides in
+        // the watch which is not nice, but effective and simple
+        if ( !watch->Close() )
+        {
+            wxLogSysError(_("Unable to remove kqueue watch"));
+            return false;
+        }
+
+        return true;
+    }
+
+    virtual bool RemoveAll()
+    {
+        wxFSWatchEntries::iterator it = m_watches.begin();
+        for ( ; it != m_watches.end(); ++it )
+        {
+            (void) DoRemove(it->second);
+        }
+        m_watches.clear();
+        return true;
+    }
+
+    // return true if there was no error, false on error
+    bool ReadEvents()
+    {
+        wxCHECK_MSG( IsOk(), false,
+                    "Kqueue not initialized or invalid kqueue descriptor" );
+
+        // read events
+        do
+        {
+            struct kevent event;
+            struct timespec timeout = {0, 0};
+            int ret = kevent(m_kfd, NULL, 0, &event, 1, &timeout);
+            if (ret == -1)
+            {
+                wxLogSysError(_("Unable to get events from kqueue"));
+                return false;
+            }
+            else if (ret == 0)
+            {
+                return true;
+            }
+
+            // we have event, so process it
+            ProcessNativeEvent(event);
+        }
+        while (true);
+
+        // when ret>0 we still have events, when ret<=0 we return
+        wxFAIL_MSG( "Never reached" );
+        return true;
+    }
+
+    bool IsOk() const
+    {
+        return m_source != NULL;
+    }
+
+protected:
+    // returns all new dirs/files present in the immediate level of the dir
+    // pointed by watch.GetPath(). "new" means created between the last time
+    // the state of watch was computed and now
+    void FindChanges(wxFSWatchEntryKq& watch,
+                     wxArrayString& changedFiles,
+                     wxArrayInt& changedFlags)
+    {
+        wxFSWatchEntryKq::wxDirState old = watch.GetLastState();
+        watch.RefreshState();
+        wxFSWatchEntryKq::wxDirState curr = watch.GetLastState();
+
+        // iterate over old/curr file lists and compute changes
+        wxArrayString::iterator oit = old.files.begin();
+        wxArrayString::iterator cit = curr.files.begin();
+        for ( ; oit != old.files.end() && cit != curr.files.end(); )
+        {
+            if ( *cit == *oit )
+            {
+                ++cit;
+                ++oit;
+            }
+            else if ( *cit <= *oit )
+            {
+                changedFiles.push_back(*cit);
+                changedFlags.push_back(wxFSW_EVENT_CREATE);
+                ++cit;
+            }
+            else // ( *cit > *oit )
+            {
+                changedFiles.push_back(*oit);
+                changedFlags.push_back(wxFSW_EVENT_DELETE);
+                ++oit;
+            }
+        }
+
+        // border conditions
+        if ( oit == old.files.end() )
+        {
+            for ( ; cit != curr.files.end(); ++cit )
+            {
+                changedFiles.push_back( *cit );
+                changedFlags.push_back(wxFSW_EVENT_CREATE);
+            }
+        }
+        else if ( cit == curr.files.end() )
+        {
+            for ( ; oit != old.files.end(); ++oit )
+            {
+                changedFiles.push_back( *oit );
+                changedFlags.push_back(wxFSW_EVENT_DELETE);
+            }
+        }
+
+        wxASSERT( changedFiles.size() == changedFlags.size() );
+
+#if 0
+        wxLogTrace(wxTRACE_FSWATCHER, "Changed files:");
+        wxArrayString::iterator it = changedFiles.begin();
+        wxArrayInt::iterator it2 = changedFlags.begin();
+        for ( ; it != changedFiles.end(); ++it, ++it2)
+        {
+            wxString action = (*it2 == wxFSW_EVENT_CREATE) ?
+                                "created" : "deleted";
+            wxLogTrace(wxTRACE_FSWATCHER, wxString::Format("File: '%s' %s",
+                        *it, action));
+        }
+#endif
+    }
+
+    void ProcessNativeEvent(const struct kevent& e)
+    {
+        void* const udata = FromUdata(e.udata);
+
+        wxASSERT_MSG(udata, "Null user data associated with kevent!");
+        wxLogTrace(wxTRACE_FSWATCHER, "Event: ident=%" PRIuPTR ", filter=%hd, flags=%hu, "
+#if __FreeBSD_version >= 1200033
+                   "fflags=%u, data=%" PRId64 ", user_data=%p",
+#else
+                   "fflags=%u, data=%" PRIdPTR ", user_data=%p",
+#endif
+                   e.ident, e.filter, e.flags, e.fflags, e.data, udata);
+
+        // for ease of use
+        wxFSWatchEntryKq& w = *(static_cast<wxFSWatchEntry*>(udata));
+        int nflags = e.fflags;
+
+        // clear ignored flags
+        nflags &= ~NOTE_REVOKE;
+
+        // TODO ignore events we didn't ask for + refactor this cascade ifs
+        // check for events
+        while ( nflags )
+        {
+            // when monitoring dir, this means create/delete
+            const wxString basepath = w.GetPath();
+            if ( nflags & NOTE_WRITE && wxDirExists(basepath) )
+            {
+                // NOTE_LINK is set when the dir was created, but we
+                // don't care - we look for new names in directory
+                // regardless of type. Also, clear all this, because
+                // it cannot mean more by itself
+                nflags &= ~(NOTE_WRITE | NOTE_ATTRIB | NOTE_LINK);
+
+                wxArrayString changedFiles;
+                wxArrayInt changedFlags;
+                FindChanges(w, changedFiles, changedFlags);
+
+                wxArrayString::iterator it = changedFiles.begin();
+                wxArrayInt::iterator changeType = changedFlags.begin();
+                for ( ; it != changedFiles.end(); ++it, ++changeType )
+                {
+                    const wxString fullpath = w.GetPath() +
+                                                wxFileName::GetPathSeparator() +
+                                                  *it;
+                    const wxFileName path(wxDirExists(fullpath)
+                                            ? wxFileName::DirName(fullpath)
+                                            : wxFileName::FileName(fullpath));
+
+                    wxFileSystemWatcherEvent event(*changeType, path, path);
+                    SendEvent(event);
+                }
+            }
+            else if ( nflags & NOTE_RENAME )
+            {
+                // CHECK it'd be only possible to detect name if we had
+                // parent files listing which we could confront with now and
+                // still we couldn't be sure we have the right name...
+                nflags &= ~NOTE_RENAME;
+                wxFileSystemWatcherEvent event(wxFSW_EVENT_RENAME,
+                                        basepath, wxFileName());
+                SendEvent(event);
+            }
+            else if ( nflags & NOTE_WRITE || nflags & NOTE_EXTEND )
+            {
+                nflags &= ~(NOTE_WRITE | NOTE_EXTEND);
+                wxFileSystemWatcherEvent event(wxFSW_EVENT_MODIFY,
+                                        basepath, basepath);
+                SendEvent(event);
+            }
+            else if ( nflags & NOTE_DELETE )
+            {
+                nflags &= ~(NOTE_DELETE);
+                wxFileSystemWatcherEvent event(wxFSW_EVENT_DELETE,
+                                        basepath, basepath);
+                SendEvent(event);
+            }
+            else if ( nflags & NOTE_ATTRIB )
+            {
+                nflags &= ~(NOTE_ATTRIB);
+                wxFileSystemWatcherEvent event(wxFSW_EVENT_ACCESS,
+                                        basepath, basepath);
+                SendEvent(event);
+            }
+
+            // clear any flags that won't mean anything by themselves
+            nflags &= ~(NOTE_LINK);
+        }
+    }
+
+    void SendEvent(wxFileSystemWatcherEvent& evt)
+    {
+        m_watcher->GetOwner()->ProcessEvent(evt);
+    }
+
+    static int Watcher2NativeFlags(int WXUNUSED(flags))
+    {
+        // TODO: it would be better to only subscribe to what we need
+        return NOTE_DELETE | NOTE_WRITE | NOTE_EXTEND |
+               NOTE_ATTRIB | NOTE_LINK | NOTE_RENAME |
+               NOTE_REVOKE;
+    }
+
+    wxFSWSourceHandler* m_handler;        // handler for kqueue event source
+    wxEventLoopSource* m_source;          // our event loop source
+
+    // descriptor created by kqueue()
+    int m_kfd;
+};
+
+
+// once we get signaled to read, actuall event reading occurs
+void wxFSWSourceHandler::OnReadWaiting()
+{
+    wxLogTrace(wxTRACE_FSWATCHER, "--- OnReadWaiting ---");
+    m_service->ReadEvents();
+}
+
+void wxFSWSourceHandler::OnWriteWaiting()
+{
+    wxFAIL_MSG("We never write to kqueue descriptor.");
+}
+
+void wxFSWSourceHandler::OnExceptionWaiting()
+{
+    wxFAIL_MSG("We never receive exceptions on kqueue descriptor.");
+}
+
+
+// ============================================================================
+// wxKqueueFileSystemWatcher implementation
+// ============================================================================
+
+wxKqueueFileSystemWatcher::wxKqueueFileSystemWatcher()
+    : wxFileSystemWatcherBase()
+{
+    Init();
+}
+
+wxKqueueFileSystemWatcher::wxKqueueFileSystemWatcher(const wxFileName& path,
+                                                     int events)
+    : wxFileSystemWatcherBase()
+{
+    if (!Init())
+    {
+        wxDELETE(m_service);
+        return;
+    }
+
+    Add(path, events);
+}
+
+wxKqueueFileSystemWatcher::~wxKqueueFileSystemWatcher()
+{
+}
+
+bool wxKqueueFileSystemWatcher::Init()
+{
+    m_service = new wxFSWatcherImplKqueue(this);
+    return m_service->Init();
+}
+
+#endif // wxHAS_KQUEUE
+
+#endif // wxUSE_FSWATCHER
diff -upr pcsx2-main.org/3rdparty/wxwidgets3.0/UsewxWidgets.cmake pcsx2-main/3rdparty/wxwidgets3.0/UsewxWidgets.cmake
--- pcsx2-main.org/3rdparty/wxwidgets3.0/UsewxWidgets.cmake	2022-05-11 09:38:42.000000000 +0900
+++ pcsx2-main/3rdparty/wxwidgets3.0/UsewxWidgets.cmake	2022-05-16 22:24:56.037066000 +0900
@@ -11,7 +11,7 @@ if(UNIX)
    if(APPLE)
       add_definitions(-D__DARWIN__)
    else()
-       add_definitions(-D__LINUX__)
+       add_definitions(-D__BSD__)
    endif()
 elseif(WIN32)
    add_definitions(-D__WINDOWS__)
diff -upr pcsx2-main.org/CMakeLists.txt pcsx2-main/CMakeLists.txt
--- pcsx2-main.org/CMakeLists.txt	2022-05-11 09:38:42.000000000 +0900
+++ pcsx2-main/CMakeLists.txt	2022-05-16 22:26:29.476091000 +0900
@@ -42,7 +42,8 @@ write_svnrev_h()
 set(CMAKE_BUILD_PO FALSE)
 if (LIBRETRO)
     set(BUILD_REPLAY_LOADERS FALSE)
-    add_definitions(-D__LIBRETRO__ -DDISABLE_RECORDING -DwxUSE_GUI=0)
+    #include_directories(/usr/local/include/wx-3.0)
+    add_definitions(-D__LIBRETRO__ -DDISABLE_RECORDING -DwxUSE_GUI=0 -I/usr/local/include/gtk-3.0 -D__USE_ISOC11)
 endif()
 
 if(NOT NO_TRANSLATION)
diff -upr pcsx2-main.org/common/include/Utilities/EventSource.inl pcsx2-main/common/include/Utilities/EventSource.inl
--- pcsx2-main.org/common/include/Utilities/EventSource.inl	2022-05-11 09:38:42.000000000 +0900
+++ pcsx2-main/common/include/Utilities/EventSource.inl	2022-05-16 22:36:01.124088000 +0900
@@ -58,9 +58,9 @@ __fi void EventSource<ListenerType>::_Di
         try {
             (*iter)->DispatchEvent(evtparams);
         } catch (Exception::RuntimeError &ex) {
-		log_cb(RETRO_LOG_ERROR, "Ignoring runtime error thrown from event listener: %s\n", ex.FormatDiagnosticMessage().c_str());
+		log_cb(RETRO_LOG_ERROR, "Ignoring runtime error thrown from event listener: \n");
         } catch (BaseException &ex) {
-            log_cb(RETRO_LOG_ERROR, "Ignoring non-runtime BaseException thrown from event listener: %s\n", ex.FormatDiagnosticMessage().c_str());
+            log_cb(RETRO_LOG_ERROR, "Ignoring non-runtime BaseException thrown from event listener: \n");
         }
         ++iter;
     }
diff -upr pcsx2-main.org/common/include/Utilities/Exceptions.h pcsx2-main/common/include/Utilities/Exceptions.h
--- pcsx2-main.org/common/include/Utilities/Exceptions.h	2022-05-11 09:38:42.000000000 +0900
+++ pcsx2-main/common/include/Utilities/Exceptions.h	2022-05-16 22:39:15.252937000 +0900
@@ -36,7 +36,6 @@ void pxTrap(void);
     {                                                                              \
         try {                                                                      \
             log_cb(RETRO_LOG_ERROR, "Unhandled BaseException in %s (ignored!):\n", funcname);  \
-            log_cb(RETRO_LOG_ERROR, "%s\n", ex.FormatDiagnosticMessage());                           \
         } catch (...) {                                                            \
             fprintf(stderr, "ERROR: (out of memory?)\n");                          \
         }                                                                          \
diff -upr pcsx2-main.org/common/include/Utilities/General.h pcsx2-main/common/include/Utilities/General.h
--- pcsx2-main.org/common/include/Utilities/General.h	2022-05-11 09:38:42.000000000 +0900
+++ pcsx2-main/common/include/Utilities/General.h	2022-05-16 22:30:02.637450000 +0900
@@ -221,4 +221,4 @@ void MemProtectStatic(u8 (&arr)[size], c
 
 // Safe version of Munmap -- NULLs the pointer variable immediately after free'ing it.
 #define SafeSysMunmap(ptr, size) \
-    ((void)(HostSys::Munmap((uptr)(ptr), size), (ptr) = NULL))
+    ((void)(HostSys::Munmap((uptr)(ptr), size), (ptr) = 0))
diff -upr pcsx2-main.org/libretro/language_injector.cpp pcsx2-main/libretro/language_injector.cpp
--- pcsx2-main.org/libretro/language_injector.cpp	2022-05-11 09:38:42.000000000 +0900
+++ pcsx2-main/libretro/language_injector.cpp	2022-05-16 23:15:25.984685000 +0900
@@ -190,7 +190,7 @@ namespace LanguageInjector
 		wxString description;
 		wxString bios_file = wxString(bios_path.c_str());
 		if (!IsBIOS(bios_file, description)) {
-			log_cb(RETRO_LOG_INFO, "Invalid BIOS file: %s \n", bios_path);
+			log_cb(RETRO_LOG_INFO, "Invalid BIOS file:  \n");
 			return;
 		}
 		std::string bios_descr = (std::string)description;
@@ -223,7 +223,7 @@ namespace LanguageInjector
 				return bios_language[i];
 			}
 		}
-		return { NULL, NULL, NULL, NULL };
+		return { NULL, NULL, 0, 0 };
 
 	}
 
diff -upr pcsx2-main.org/libretro/main.cpp pcsx2-main/libretro/main.cpp
--- pcsx2-main.org/libretro/main.cpp	2022-05-11 09:38:42.000000000 +0900
+++ pcsx2-main/libretro/main.cpp	2022-05-16 23:03:19.089789000 +0900
@@ -576,7 +576,7 @@ read_m3u_file(const wxFileName& m3u_file
 	wxTextFile m3u_data;
 	if (!m3u_data.Open(m3u_file.GetFullPath()))
 	{
-		log_cb(RETRO_LOG_ERROR, "M3U file \"%s\" cannot be read", m3u_file.GetFullPath().c_str());
+		log_cb(RETRO_LOG_ERROR, "M3U file \"\" cannot be read");
 		return result;
 	}
 
@@ -588,7 +588,7 @@ read_m3u_file(const wxFileName& m3u_file
 	wxString line = m3u_data.GetFirstLine();
 	if (line.StartsWith(utf8_bom))
 	{
-		log_cb(RETRO_LOG_WARN, "M3U file \"%s\" contains UTF-8 BOM", m3u_file.GetFullPath().c_str());
+		log_cb(RETRO_LOG_WARN, "M3U file \"\" contains UTF-8 BOM");
 		line.erase(0, utf8_bom.length());
 	}
 
@@ -600,19 +600,19 @@ read_m3u_file(const wxFileName& m3u_file
 			discFile.Normalize();
 			if (discFile.Exists())
 			{
-				log_cb(RETRO_LOG_DEBUG, "Found disc image in M3U file, %s", discFile.GetFullPath());
+				log_cb(RETRO_LOG_DEBUG, "Found disc image in M3U file, ");
 				result.push_back(discFile.GetFullPath());
 			}
 			else
 			{
 				wxString full_path = discFile.GetFullPath();
-				log_cb(RETRO_LOG_WARN, "File specified in the M3U file \"%s\" was not found:\n%s", m3u_file.GetFullPath().c_str(), full_path.c_str());
+				log_cb(RETRO_LOG_WARN, "File specified in the M3U file \"\" was not found:\n");
 			}
 		}
 	}
 
 	if (result.empty())
-		log_cb(RETRO_LOG_ERROR, "No paths found in the M3U file \"%s\"", m3u_file.GetFullPath().c_str());
+		log_cb(RETRO_LOG_ERROR, "No paths found in the M3U file \"\"");
 
 	return result;
 }
@@ -767,7 +767,7 @@ bool retro_load_game(const struct retro_
 
 		if (!fp)
 		{
-			log_cb(RETRO_LOG_ERROR, "Could not open File: %s\n", game_paths[0]);
+			log_cb(RETRO_LOG_ERROR, "Could not open File: \n");
 			return false;
 		}
 
diff -upr pcsx2-main.org/pcsx2/CDVD/CDVDisoReader.cpp pcsx2-main/pcsx2/CDVD/CDVDisoReader.cpp
--- pcsx2-main.org/pcsx2/CDVD/CDVDisoReader.cpp	2022-05-11 09:38:42.000000000 +0900
+++ pcsx2-main/pcsx2/CDVD/CDVDisoReader.cpp	2022-05-16 23:10:51.079606000 +0900
@@ -59,7 +59,7 @@ s32 CALLBACK ISOopen(const char* pTitle)
 	}
 	catch (BaseException& ex)
 	{
-		log_cb(RETRO_LOG_ERROR, "%s\n", ex.FormatDiagnosticMessage());
+		log_cb(RETRO_LOG_ERROR, "\n");
 		return -1;
 	}
 
diff -upr pcsx2-main.org/pcsx2/System.cpp pcsx2-main/pcsx2/System.cpp
--- pcsx2-main.org/pcsx2/System.cpp	2022-05-11 09:38:42.000000000 +0900
+++ pcsx2-main/pcsx2/System.cpp	2022-05-16 23:08:48.880361000 +0900
@@ -165,13 +165,13 @@ CpuInitializer< CpuType >::CpuInitialize
 	}
 	catch( Exception::RuntimeError& ex )
 	{
-		log_cb(RETRO_LOG_ERROR, "CPU provider error:\n\t%s\n", ex.FormatDiagnosticMessage().c_str() );
+		log_cb(RETRO_LOG_ERROR, "CPU provider error:\n\t\n" );
 		MyCpu = nullptr;
 		ExThrown = ScopedExcept(ex.Clone());
 	}
 	catch( std::runtime_error& ex )
 	{
-		log_cb(RETRO_LOG_ERROR, "CPU provider error (STL Exception)\n\tDetails:%s\n", fromUTF8( ex.what() ).c_str() );
+		log_cb(RETRO_LOG_ERROR, "CPU provider error (STL Exception)\n\tDetails:\n" );
 		MyCpu = nullptr;
 		ExThrown = ScopedExcept(new Exception::RuntimeError(ex));
 	}
@@ -347,7 +347,7 @@ SysCpuProviderPack::SysCpuProviderPack()
 	catch( Exception::RuntimeError& ex )
 	{
 		m_RecExceptionEE = ScopedExcept(ex.Clone());
-		log_cb(RETRO_LOG_ERROR, "EE Recompiler Reservation Failed:\n%s\n", ex.FormatDiagnosticMessage().c_str() );
+		log_cb(RETRO_LOG_ERROR, "EE Recompiler Reservation Failed:\n\n" );
 		recCpu.Shutdown();
 	}
 
@@ -357,7 +357,7 @@ SysCpuProviderPack::SysCpuProviderPack()
 	catch( Exception::RuntimeError& ex )
 	{
 		m_RecExceptionIOP = ScopedExcept(ex.Clone());
-		log_cb(RETRO_LOG_ERROR, "IOP Recompiler Reservation Failed:\n%s\n", ex.FormatDiagnosticMessage().c_str() );
+		log_cb(RETRO_LOG_ERROR, "IOP Recompiler Reservation Failed:\n\n" );
 		psxRec.Shutdown();
 	}
 
diff -upr pcsx2-main.org/plugins/GS/Renderers/SW/GSRasterizer.h pcsx2-main/plugins/GS/Renderers/SW/GSRasterizer.h
--- pcsx2-main.org/plugins/GS/Renderers/SW/GSRasterizer.h	2022-05-11 09:38:42.000000000 +0900
+++ pcsx2-main/plugins/GS/Renderers/SW/GSRasterizer.h	2022-05-16 23:23:29.873799000 +0900
@@ -21,6 +21,7 @@
 
 #pragma once
 
+#include <vector>
 #include "Pcsx2Types.h"
 
 #include "../../GS.h"