thread_state.h

 
#pragma once
 
#include <array>
#include <atomic>
#include <string>
 
#include <rex/platform.h>
#include <rex/types.h>
#include <rex/kernel/heap.h>
#include <rex/ppc/context.h>
 
namespace rex {
namespace kernel {
class TitleRuntime;
}  // namespace kernel
}  // namespace rex
 
namespace rex::kernel {

struct DPCSaveArea {
  std::array<PPCRegister, 32> fpr{};
  u32 csr = 0;
  std::array<PPCVRegister, 128> vr{};
  PPCVSCRRegister vscr;
};
 
class REX_KERNEL_API ThreadState {
 public:
  ThreadState(u32 thread_id, u32 stack_base, u32 pcr_address, GuestAddressSpace* memory,
              TitleRuntime* runtime);
  ~ThreadState();
 
  GuestAddressSpace* GetAddressSpace() const { return memory_; }

  void RequestStop() { stop_requested_.store(true, std::memory_order_release); }
 
  bool IsStopRequested() const { return stop_requested_.load(std::memory_order_acquire); }

  void ClearStop() { stop_requested_.store(false, std::memory_order_release); }
  ::PPCContext* GetContext() const { return context_; }
 
  u32 GetThreadID() const { return thread_id_; }

  TitleRuntime* GetRuntime() const { return runtime_; }
 
  DPCSaveArea& GetDPCSaveArea() { return dpc_save_area_; }

  char*& GetStrtokContext() { return strtok_context_; }

  static void Bind(ThreadState* state);
  static ThreadState* Get();
  static u32 GetBoundThreadID();
 
 private:
  GuestAddressSpace* memory_;
  TitleRuntime* runtime_;
 
  u32 thread_id_ = 0;
 
  alignas(64)::PPCContext context_storage_{};
  ::PPCContext* context_ = &context_storage_;
  DPCSaveArea dpc_save_area_;
  char* strtok_context_ = nullptr;
  std::atomic<bool> stop_requested_{false};
};
 
namespace detail {

[[noreturn]] REX_KERNEL_API void AbortNoRuntime();
 
}  // namespace detail

inline TitleRuntime& GetCurrent() {
  ThreadState* state = ThreadState::Get();
  if (state == nullptr || state->GetRuntime() == nullptr) [[unlikely]] {
    detail::AbortNoRuntime();
  }
  return *state->GetRuntime();
}
 
}  // namespace rex::kernel