VERY experimental Nintendo Switch 2 emulator
C++
kernel: convert miscellaneous
Liam767059b6204e
diff --git a/src/core/hle/kernel/k_synchronization_object.cpp b/src/core/hle/kernel/k_synchronization_object.cppindex 40fd0c0388..dd912a82d1 100644--- a/src/core/hle/kernel/k_synchronization_object.cpp+++ b/src/core/hle/kernel/k_synchronization_object.cpp@@ -71,26 +71,26 @@ void KSynchronizationObject::Finalize() {KAutoObject::Finalize();}-Result KSynchronizationObject::Wait(KernelCore& kernel_ctx, s32* out_index,+Result KSynchronizationObject::Wait(KernelCore& kernel, s32* out_index,KSynchronizationObject** objects, const s32 num_objects,s64 timeout) {// Allocate space on stack for thread nodes.std::vector<ThreadListNode> thread_nodes(num_objects);// Prepare for wait.- KThread* thread = GetCurrentThreadPointer(kernel_ctx);+ KThread* thread = GetCurrentThreadPointer(kernel);KHardwareTimer* timer{};- ThreadQueueImplForKSynchronizationObjectWait wait_queue(kernel_ctx, objects,- thread_nodes.data(), num_objects);+ ThreadQueueImplForKSynchronizationObjectWait wait_queue(kernel, objects, thread_nodes.data(),+ num_objects);{// Setup the scheduling lock and sleep.- KScopedSchedulerLockAndSleep slp(kernel_ctx, std::addressof(timer), thread, timeout);+ KScopedSchedulerLockAndSleep slp(kernel, std::addressof(timer), thread, timeout);// Check if the thread should terminate.if (thread->IsTerminationRequested()) {slp.CancelSleep();- return ResultTerminationRequested;+ R_THROW(ResultTerminationRequested);}// Check if any of the objects are already signaled.@@ -100,21 +100,21 @@ Result KSynchronizationObject::Wait(KernelCore& kernel_ctx, s32* out_index,if (objects[i]->IsSignaled()) {*out_index = i;slp.CancelSleep();- return ResultSuccess;+ R_THROW(ResultSuccess);}}// Check if the timeout is zero.if (timeout == 0) {slp.CancelSleep();- return ResultTimedOut;+ R_THROW(ResultTimedOut);}// Check if waiting was canceled.if (thread->IsWaitCancelled()) {slp.CancelSleep();thread->ClearWaitCancelled();- return ResultCancelled;+ R_THROW(ResultCancelled);}// Add the waiters.@@ -141,7 +141,7 @@ Result KSynchronizationObject::Wait(KernelCore& kernel_ctx, s32* out_index,*out_index = thread->GetSyncedIndex();// Get the wait result.- return thread->GetWaitResult();+ R_RETURN(thread->GetWaitResult());}KSynchronizationObject::KSynchronizationObject(KernelCore& kernel_)@@ -158,7 +158,7 @@ void KSynchronizationObject::NotifyAvailable(Result result) {}// Iterate over each thread.- for (auto* cur_node = thread_list_head; cur_node != nullptr; cur_node = cur_node->next) {+ for (auto* cur_node = m_thread_list_head; cur_node != nullptr; cur_node = cur_node->next) {cur_node->thread->NotifyAvailable(this, result);}}@@ -169,7 +169,7 @@ std::vector<KThread*> KSynchronizationObject::GetWaitingThreadsForDebugging() co// If debugging, dump the list of waiters.{KScopedSchedulerLock lock(kernel);- for (auto* cur_node = thread_list_head; cur_node != nullptr; cur_node = cur_node->next) {+ for (auto* cur_node = m_thread_list_head; cur_node != nullptr; cur_node = cur_node->next) {threads.emplace_back(cur_node->thread);}}diff --git a/src/core/hle/kernel/k_synchronization_object.h b/src/core/hle/kernel/k_synchronization_object.hindex 8d8122ab72..d55a2673df 100644--- a/src/core/hle/kernel/k_synchronization_object.h+++ b/src/core/hle/kernel/k_synchronization_object.h@@ -24,31 +24,30 @@ public:KThread* thread{};};- [[nodiscard]] static Result Wait(KernelCore& kernel, s32* out_index,- KSynchronizationObject** objects, const s32 num_objects,- s64 timeout);+ static Result Wait(KernelCore& kernel, s32* out_index, KSynchronizationObject** objects,+ const s32 num_objects, s64 timeout);void Finalize() override;- [[nodiscard]] virtual bool IsSignaled() const = 0;+ virtual bool IsSignaled() const = 0;- [[nodiscard]] std::vector<KThread*> GetWaitingThreadsForDebugging() const;+ std::vector<KThread*> GetWaitingThreadsForDebugging() const;void LinkNode(ThreadListNode* node_) {// Link the node to the list.- if (thread_list_tail == nullptr) {- thread_list_head = node_;+ if (m_thread_list_tail == nullptr) {+ m_thread_list_head = node_;} else {- thread_list_tail->next = node_;+ m_thread_list_tail->next = node_;}- thread_list_tail = node_;+ m_thread_list_tail = node_;}void UnlinkNode(ThreadListNode* node_) {// Unlink the node from the list.ThreadListNode* prev_ptr =- reinterpret_cast<ThreadListNode*>(std::addressof(thread_list_head));+ reinterpret_cast<ThreadListNode*>(std::addressof(m_thread_list_head));ThreadListNode* prev_val = nullptr;ThreadListNode *prev, *tail_prev;@@ -59,8 +58,8 @@ public:prev_val = prev_ptr;} while (prev_ptr != node_);- if (thread_list_tail == node_) {- thread_list_tail = tail_prev;+ if (m_thread_list_tail == node_) {+ m_thread_list_tail = tail_prev;}prev->next = node_->next;@@ -78,8 +77,8 @@ protected:}private:- ThreadListNode* thread_list_head{};- ThreadListNode* thread_list_tail{};+ ThreadListNode* m_thread_list_head{};+ ThreadListNode* m_thread_list_tail{};};} // namespace Kerneldiff --git a/src/core/hle/kernel/k_transfer_memory.cpp b/src/core/hle/kernel/k_transfer_memory.cppindex faa5c73b5c..c25cc2e39d 100644--- a/src/core/hle/kernel/k_transfer_memory.cpp+++ b/src/core/hle/kernel/k_transfer_memory.cpp@@ -16,18 +16,18 @@ KTransferMemory::~KTransferMemory() = default;Result KTransferMemory::Initialize(VAddr address_, std::size_t size_,Svc::MemoryPermission owner_perm_) {// Set members.- owner = GetCurrentProcessPointer(kernel);+ m_owner = GetCurrentProcessPointer(kernel);// TODO(bunnei): Lock for transfer memory// Set remaining tracking members.- owner->Open();- owner_perm = owner_perm_;- address = address_;- size = size_;- is_initialized = true;+ m_owner->Open();+ m_owner_perm = owner_perm_;+ m_address = address_;+ m_size = size_;+ m_is_initialized = true;- return ResultSuccess;+ R_SUCCEED();}void KTransferMemory::Finalize() {diff --git a/src/core/hle/kernel/k_transfer_memory.h b/src/core/hle/kernel/k_transfer_memory.hindex 85d508ee75..9a37bd903f 100644--- a/src/core/hle/kernel/k_transfer_memory.h+++ b/src/core/hle/kernel/k_transfer_memory.h@@ -31,33 +31,33 @@ public:void Finalize() override;bool IsInitialized() const override {- return is_initialized;+ return m_is_initialized;}uintptr_t GetPostDestroyArgument() const override {- return reinterpret_cast<uintptr_t>(owner);+ return reinterpret_cast<uintptr_t>(m_owner);}static void PostDestroy(uintptr_t arg);KProcess* GetOwner() const override {- return owner;+ return m_owner;}VAddr GetSourceAddress() const {- return address;+ return m_address;}size_t GetSize() const {- return is_initialized ? size : 0;+ return m_is_initialized ? m_size : 0;}private:- KProcess* owner{};- VAddr address{};- Svc::MemoryPermission owner_perm{};- size_t size{};- bool is_initialized{};+ KProcess* m_owner{};+ VAddr m_address{};+ Svc::MemoryPermission m_owner_perm{};+ size_t m_size{};+ bool m_is_initialized{};};} // namespace Kerneldiff --git a/src/core/hle/kernel/physical_core.cpp b/src/core/hle/kernel/physical_core.cppindex 3044922ac2..2e0c361294 100644--- a/src/core/hle/kernel/physical_core.cpp+++ b/src/core/hle/kernel/physical_core.cpp@@ -10,14 +10,14 @@namespace Kernel {-PhysicalCore::PhysicalCore(std::size_t core_index_, Core::System& system_, KScheduler& scheduler_)- : core_index{core_index_}, system{system_}, scheduler{scheduler_} {+PhysicalCore::PhysicalCore(std::size_t core_index, Core::System& system, KScheduler& scheduler)+ : m_core_index{core_index}, m_system{system}, m_scheduler{scheduler} {#if defined(ARCHITECTURE_x86_64) || defined(ARCHITECTURE_arm64)// TODO(bunnei): Initialization relies on a core being available. We may later replace this with// a 32-bit instance of Dynarmic. This should be abstracted out to a CPU manager.auto& kernel = system.Kernel();- arm_interface = std::make_unique<Core::ARM_Dynarmic_64>(- system, kernel.IsMulticore(), kernel.GetExclusiveMonitor(), core_index);+ m_arm_interface = std::make_unique<Core::ARM_Dynarmic_64>(+ system, kernel.IsMulticore(), kernel.GetExclusiveMonitor(), m_core_index);#else#error Platform not supported yet.#endif@@ -25,13 +25,13 @@ PhysicalCore::PhysicalCore(std::size_t core_index_, Core::System& system_, KSchePhysicalCore::~PhysicalCore() = default;-void PhysicalCore::Initialize([[maybe_unused]] bool is_64_bit) {+void PhysicalCore::Initialize(bool is_64_bit) {#if defined(ARCHITECTURE_x86_64) || defined(ARCHITECTURE_arm64)- auto& kernel = system.Kernel();+ auto& kernel = m_system.Kernel();if (!is_64_bit) {// We already initialized a 64-bit core, replace with a 32-bit one.- arm_interface = std::make_unique<Core::ARM_Dynarmic_32>(- system, kernel.IsMulticore(), kernel.GetExclusiveMonitor(), core_index);+ m_arm_interface = std::make_unique<Core::ARM_Dynarmic_32>(+ m_system, kernel.IsMulticore(), kernel.GetExclusiveMonitor(), m_core_index);}#else#error Platform not supported yet.@@ -39,31 +39,30 @@ void PhysicalCore::Initialize([[maybe_unused]] bool is_64_bit) {}void PhysicalCore::Run() {- arm_interface->Run();- arm_interface->ClearExclusiveState();+ m_arm_interface->Run();+ m_arm_interface->ClearExclusiveState();}void PhysicalCore::Idle() {- std::unique_lock lk{guard};- on_interrupt.wait(lk, [this] { return is_interrupted; });+ std::unique_lock lk{m_guard};+ m_on_interrupt.wait(lk, [this] { return m_is_interrupted; });}bool PhysicalCore::IsInterrupted() const {- return is_interrupted;+ return m_is_interrupted;}void PhysicalCore::Interrupt() {- std::unique_lock lk{guard};- is_interrupted = true;- arm_interface->SignalInterrupt();- on_interrupt.notify_all();+ std::unique_lock lk{m_guard};+ m_is_interrupted = true;+ m_arm_interface->SignalInterrupt();+ m_on_interrupt.notify_all();}void PhysicalCore::ClearInterrupt() {- std::unique_lock lk{guard};- is_interrupted = false;- arm_interface->ClearInterrupt();- on_interrupt.notify_all();+ std::unique_lock lk{m_guard};+ m_is_interrupted = false;+ m_arm_interface->ClearInterrupt();}} // namespace Kerneldiff --git a/src/core/hle/kernel/physical_core.h b/src/core/hle/kernel/physical_core.hindex fb8e7933ed..5cb398fdc9 100644--- a/src/core/hle/kernel/physical_core.h+++ b/src/core/hle/kernel/physical_core.h@@ -47,46 +47,38 @@ public:bool IsInterrupted() const;bool IsInitialized() const {- return arm_interface != nullptr;+ return m_arm_interface != nullptr;}Core::ARM_Interface& ArmInterface() {- return *arm_interface;+ return *m_arm_interface;}const Core::ARM_Interface& ArmInterface() const {- return *arm_interface;- }-- bool IsMainCore() const {- return core_index == 0;- }-- bool IsSystemCore() const {- return core_index == 3;+ return *m_arm_interface;}std::size_t CoreIndex() const {- return core_index;+ return m_core_index;}Kernel::KScheduler& Scheduler() {- return scheduler;+ return m_scheduler;}const Kernel::KScheduler& Scheduler() const {- return scheduler;+ return m_scheduler;}private:- const std::size_t core_index;- Core::System& system;- Kernel::KScheduler& scheduler;-- std::mutex guard;- std::condition_variable on_interrupt;- std::unique_ptr<Core::ARM_Interface> arm_interface;- bool is_interrupted{};+ const std::size_t m_core_index;+ Core::System& m_system;+ Kernel::KScheduler& m_scheduler;++ std::mutex m_guard;+ std::condition_variable m_on_interrupt;+ std::unique_ptr<Core::ARM_Interface> m_arm_interface;+ bool m_is_interrupted{};};} // namespace Kerneldiff --git a/src/core/hle/kernel/slab_helpers.h b/src/core/hle/kernel/slab_helpers.hindex 0228ce1888..b9f5066dea 100644--- a/src/core/hle/kernel/slab_helpers.h+++ b/src/core/hle/kernel/slab_helpers.h@@ -132,7 +132,7 @@ protected:template <typename Derived, typename Base>class KAutoObjectWithSlabHeapAndContainer : public Base {- static_assert(std::is_base_of<KAutoObjectWithList, Base>::value);+ static_assert(std::is_base_of_v<KAutoObjectWithList, Base>);private:static Derived* Allocate(KernelCore& kernel) {@@ -144,18 +144,18 @@ private:}public:- KAutoObjectWithSlabHeapAndContainer(KernelCore& kernel_) : Base(kernel_), kernel(kernel_) {}+ KAutoObjectWithSlabHeapAndContainer(KernelCore& kernel_) : Base(kernel_) {}virtual ~KAutoObjectWithSlabHeapAndContainer() {}virtual void Destroy() override {const bool is_initialized = this->IsInitialized();uintptr_t arg = 0;if (is_initialized) {- kernel.ObjectListContainer().Unregister(this);+ Base::kernel.ObjectListContainer().Unregister(this);arg = this->GetPostDestroyArgument();this->Finalize();}- Free(kernel, static_cast<Derived*>(this));+ Free(Base::kernel, static_cast<Derived*>(this));if (is_initialized) {Derived::PostDestroy(arg);}@@ -169,7 +169,7 @@ public:}size_t GetSlabIndex() const {- return SlabHeap<Derived>(kernel).GetObjectIndex(static_cast<const Derived*>(this));+ return SlabHeap<Derived>(Base::kernel).GetObjectIndex(static_cast<const Derived*>(this));}public:@@ -209,9 +209,6 @@ public:static size_t GetNumRemaining(KernelCore& kernel) {return kernel.SlabHeap<Derived>().GetNumRemaining();}--protected:- KernelCore& kernel;};} // namespace Kernel