FEXCore: Moves SignalThread/SignalEvent to Frontend

FEXCore/include/FEXCore/Core/SignalDelegator.h

@@ -15,14 +15,6 @@ namespace FEXCore {
 namespace Core {
   struct InternalThreadState;
 
-  enum class SignalEvent {
-    Nothing, // If the guest uses our signal we need to know it was errant on our end
-    Pause,
-    Stop,
-    Return,
-    ReturnRT,
-  };
-
   enum SignalNumber {
 #ifndef _WIN32
     FAULT_SIGSEGV = SIGSEGV,
@@ -78,14 +70,6 @@ class SignalDelegator {
     return Config;
   }
 
-  /**
-   * @brief Signals a thread with a specific core event.
-   *
-   * @param Thread Which thread to signal.
-   * @param Event Which event to signal the event with.
-   */
-  virtual void SignalThread(FEXCore::Core::InternalThreadState* Thread, Core::SignalEvent Event) = 0;
-
 protected:
   SignalDelegatorConfig Config;
 };

FEXCore/include/FEXCore/Debug/InternalThreadState.h

@@ -88,7 +88,6 @@ struct InternalThreadState : public FEXCore::Allocator::FEXAllocOperators {
   } RunningEvents;
 
   FEXCore::Context::Context* CTX;
-  std::atomic<SignalEvent> SignalReason {SignalEvent::Nothing};
 
   NonMovableUniquePtr<FEXCore::Threads::Thread> ExecutionThread;
   bool StartPaused {false};

Source/Tools/CommonTools/DummyHandlers.h

@@ -25,8 +25,6 @@ class DummySyscallHandler : public FEXCore::HLE::SyscallHandler, public FEXCore:
 
 class DummySignalDelegator final : public FEXCore::SignalDelegator, public FEXCore::Allocator::FEXAllocOperators {
 public:
-  void SignalThread(FEXCore::Core::InternalThreadState* Thread, FEXCore::Core::SignalEvent Event) override {}
-
   FEXCore::Core::InternalThreadState* GetBackingTLSThread() {
     return GetTLSThread();
   }

Source/Tools/LinuxEmulation/LinuxSyscalls/SignalDelegator.cpp

@@ -422,10 +422,11 @@ bool SignalDelegator::HandleSIGILL(FEXCore::Core::InternalThreadState* Thread, i
 }
 
 bool SignalDelegator::HandleSignalPause(FEXCore::Core::InternalThreadState* Thread, int Signal, void* info, void* ucontext) {
-  FEXCore::Core::SignalEvent SignalReason = Thread->SignalReason.load();
+  auto ThreadObject = FEX::HLE::ThreadManager::GetStateObjectFromFEXCoreThread(Thread);
+  SignalEvent SignalReason = ThreadObject->SignalReason.load();
   auto Frame = Thread->CurrentFrame;
 
-  if (SignalReason == FEXCore::Core::SignalEvent::Pause) {
+  if (SignalReason == SignalEvent::Pause) {
     // Store our thread state so we can come back to this
     StoreThreadState(Thread, Signal, ucontext);
 
@@ -446,11 +447,11 @@ bool SignalDelegator::HandleSignalPause(FEXCore::Core::InternalThreadState* Thre
     // We use this to track if it is safe to clear cache
     ++Thread->CurrentFrame->SignalHandlerRefCounter;
 
-    Thread->SignalReason.store(FEXCore::Core::SignalEvent::Nothing);
+    ThreadObject->SignalReason.store(SignalEvent::Nothing);
     return true;
   }
 
-  if (SignalReason == FEXCore::Core::SignalEvent::Stop) {
+  if (SignalReason == SignalEvent::Stop) {
     // Our thread is stopping
     // We don't care about anything at this point
     // Set the stack to our starting location when we entered the core and get out safely
@@ -479,31 +480,30 @@ bool SignalDelegator::HandleSignalPause(FEXCore::Core::InternalThreadState* Thre
       FEX::HLE::_SyscallHandler->TM.IncrementIdleRefCount();
     }
 
-    Thread->SignalReason.store(FEXCore::Core::SignalEvent::Nothing);
+    ThreadObject->SignalReason.store(SignalEvent::Nothing);
     return true;
   }
 
-  if (SignalReason == FEXCore::Core::SignalEvent::Return || SignalReason == FEXCore::Core::SignalEvent::ReturnRT) {
-    RestoreThreadState(Thread, ucontext,
-                       SignalReason == FEXCore::Core::SignalEvent::ReturnRT ? RestoreType::TYPE_REALTIME : RestoreType::TYPE_NONREALTIME);
+  if (SignalReason == SignalEvent::Return || SignalReason == SignalEvent::ReturnRT) {
+    RestoreThreadState(Thread, ucontext, SignalReason == SignalEvent::ReturnRT ? RestoreType::TYPE_REALTIME : RestoreType::TYPE_NONREALTIME);
 
     // Ref count our faults
     // We use this to track if it is safe to clear cache
     --Thread->CurrentFrame->SignalHandlerRefCounter;
 
-    Thread->SignalReason.store(FEXCore::Core::SignalEvent::Nothing);
+    ThreadObject->SignalReason.store(SignalEvent::Nothing);
     return true;
   }
   return false;
 }
 
-void SignalDelegator::SignalThread(FEXCore::Core::InternalThreadState* Thread, FEXCore::Core::SignalEvent Event) {
-  auto ThreadObject = static_cast<const FEX::HLE::ThreadStateObject*>(Thread->FrontendPtr);
-  if (Event == FEXCore::Core::SignalEvent::Pause && Thread->RunningEvents.Running.load() == false) {
+void SignalDelegator::SignalThread(FEXCore::Core::InternalThreadState* Thread, SignalEvent Event) {
+  auto ThreadObject = FEX::HLE::ThreadManager::GetStateObjectFromFEXCoreThread(Thread);
+  if (Event == SignalEvent::Pause && Thread->RunningEvents.Running.load() == false) {
     // Skip signaling a thread if it is already paused.
     return;
   }
-  Thread->SignalReason.store(Event);
+  ThreadObject->SignalReason.store(Event);
   FHU::Syscalls::tgkill(ThreadObject->ThreadInfo.PID, ThreadObject->ThreadInfo.TID, SignalDelegator::SIGNAL_FOR_PAUSE);
 }
 

Source/Tools/LinuxEmulation/LinuxSyscalls/SignalDelegator.h

@@ -124,7 +124,13 @@ class SignalDelegator final : public FEXCore::SignalDelegator, public FEXCore::A
     FEX_UNREACHABLE;
   }
 
-  void SignalThread(FEXCore::Core::InternalThreadState* Thread, FEXCore::Core::SignalEvent Event) override;
+  /**
+   * @brief Signals a thread with a specific core event.
+   *
+   * @param Thread Which thread to signal.
+   * @param Event Which event to signal the event with.
+   */
+  void SignalThread(FEXCore::Core::InternalThreadState* Thread, SignalEvent Event);
 
   FEXCore::ArchHelpers::Arm64::UnalignedHandlerType GetUnalignedHandlerType() const {
     return UnalignedHandlerType;

Source/Tools/LinuxEmulation/LinuxSyscalls/ThreadManager.cpp

@@ -42,7 +42,7 @@ void ThreadManager::DestroyThread(FEX::HLE::ThreadStateObject* Thread, bool Need
 
 void ThreadManager::StopThread(FEX::HLE::ThreadStateObject* Thread) {
   if (Thread->Thread->RunningEvents.Running.exchange(false)) {
-    SignalDelegation->SignalThread(Thread->Thread, FEXCore::Core::SignalEvent::Stop);
+    SignalDelegation->SignalThread(Thread->Thread, SignalEvent::Stop);
   }
 }
 
@@ -74,7 +74,7 @@ void ThreadManager::NotifyPause() {
   // Tell all the threads that they should pause
   std::lock_guard lk(ThreadCreationMutex);
   for (auto& Thread : Threads) {
-    SignalDelegation->SignalThread(Thread->Thread, FEXCore::Core::SignalEvent::Pause);
+    SignalDelegation->SignalThread(Thread->Thread, SignalEvent::Pause);
   }
 }
 
@@ -87,7 +87,7 @@ void ThreadManager::Run() {
   // Spin up all the threads
   std::lock_guard lk(ThreadCreationMutex);
   for (auto& Thread : Threads) {
-    Thread->Thread->SignalReason.store(FEXCore::Core::SignalEvent::Return);
+    Thread->SignalReason.store(SignalEvent::Return);
   }
 
   for (auto& Thread : Threads) {

Source/Tools/LinuxEmulation/LinuxSyscalls/ThreadManager.h

@@ -22,6 +22,14 @@ namespace FEX::HLE {
 class SyscallHandler;
 class SignalDelegator;
 
+enum class SignalEvent : uint32_t {
+  Nothing, // If the guest uses our signal we need to know it was errant on our end
+  Pause,
+  Stop,
+  Return,
+  ReturnRT,
+};
+
 struct ThreadStateObject : public FEXCore::Allocator::FEXAllocOperators {
   FEXCore::Core::InternalThreadState* Thread;
 
@@ -58,6 +66,9 @@ struct ThreadStateObject : public FEXCore::Allocator::FEXAllocOperators {
 
   // personality emulation.
   uint32_t persona {};
+
+  // Thread signaling information
+  std::atomic<SignalEvent> SignalReason {SignalEvent::Nothing};
 };
 
 class ThreadManager final {