DolphinLibretro: defer Auto Load State until the EmuThread is live

RetroArch's Auto Load State calls retro_unserialize between
retro_load_game and the first retro_run. In the libretro fork the
EmuThread is launched lazily from inside retro_run, so at auto-load
time the core's HW, Memory, PowerPC, FIFO and video subsystems are
uninitialised. RunOnCPUThread falls back to inline execution when the
core state is not Running, so State::DoState runs on the frontend
thread against null/garbage pointers and segfaults.

Buffer any savestate delivered before the EmuThread is live in a new
Libretro::g_pending_load_state, and drain it from retro_run inside
the existing one-shot launch block, after the IsRunningOrStarting
wait and the memory-map registration. At that point the execution
environment matches a manual Load State.

Also guard retro_serialize and retro_serialize_size against the same
uninitialised state with an early return.

Closes #322.

Author: dbartholomae

Source/Core/DolphinLibretro/Common/Globals.cpp

@@ -4,6 +4,7 @@ namespace Libretro
 {
 retro_environment_t environ_cb = nullptr;
 bool g_emuthread_launched = false;
+std::vector<unsigned char> g_pending_load_state;
 std::vector<Gecko::GeckoCode> g_gecko_codes;
 std::vector<ActionReplay::ARCode> g_ar_codes;
 

Source/Core/DolphinLibretro/Common/Globals.h

@@ -11,6 +11,8 @@ namespace Libretro
 {
 extern retro_environment_t environ_cb;
 extern bool g_emuthread_launched;
+// Savestate buffered by retro_unserialize() before the EmuThread was alive
+extern std::vector<unsigned char> g_pending_load_state;
 extern std::vector<Gecko::GeckoCode> g_gecko_codes;
 extern std::vector<ActionReplay::ARCode> g_ar_codes;
 

Source/Core/DolphinLibretro/Main.cpp

@@ -271,6 +271,22 @@ void retro_run(void)
       struct retro_memory_map mmap = {descs, num_descs};
       Libretro::environ_cb(RETRO_ENVIRONMENT_SET_MEMORY_MAPS, &mmap);
     }
+
+    if (!Libretro::g_pending_load_state.empty())
+    {
+      auto pending = std::move(Libretro::g_pending_load_state);
+      Libretro::g_pending_load_state.clear();
+      AsyncRequests* ar = AsyncRequests::GetInstance();
+      if (system.IsDualCoreMode())
+        ar->SetPassthrough(true);
+      Core::RunOnCPUThread(system, [&] {
+        u8* ptr = reinterpret_cast<u8*>(pending.data());
+        PointerWrap p(&ptr, pending.size(), PointerWrap::Mode::Read);
+        State::DoState(system, p);
+      }, true);
+      if (system.IsDualCoreMode())
+        ar->SetPassthrough(false);
+    }
   }
 
   if(!Libretro::g_emuthread_launched)
@@ -462,6 +478,9 @@ void retro_run(void)
 
 size_t retro_serialize_size(void)
 {
+  if (!Libretro::g_emuthread_launched)
+    return 0;
+
   size_t size = 0;
 
   Core::System& system = Core::System::GetInstance();
@@ -483,6 +502,9 @@ size_t retro_serialize_size(void)
 
 bool retro_serialize(void* data, size_t size)
 {
+  if (!Libretro::g_emuthread_launched)
+    return false;
+
   Core::System& system = Core::System::GetInstance();
   AsyncRequests* ar = AsyncRequests::GetInstance();
 
@@ -502,6 +524,13 @@ bool retro_serialize(void* data, size_t size)
 }
 bool retro_unserialize(const void* data, size_t size)
 {
+  if (!Libretro::g_emuthread_launched)
+  {
+    const auto* bytes = static_cast<const unsigned char*>(data);
+    Libretro::g_pending_load_state.assign(bytes, bytes + size);
+    return true;
+  }
+
   Core::System& system = Core::System::GetInstance();
   AsyncRequests* ar = AsyncRequests::GetInstance();