Add #ifdef declarations for NON_MATCHING code

6 files changed, 30 insertions, 10 deletions

diff --git a/src/KingSystem/Utils/Thread/ManagedTask.cpp b/src/KingSystem/Utils/Thread/ManagedTask.cpp
index 8a0f3dfd..7018ed37 100644
--- a/src/KingSystem/Utils/Thread/ManagedTask.cpp
+++ b/src/KingSystem/Utils/Thread/ManagedTask.cpp
@@ -83,7 +83,8 @@ void ManagedTask::attachHandle(ManagedTaskHandle* handle, TaskQueueBase* queue)
     mHandle = handle;
 }
 
-// NON_MATCHING: switch
+// switch
+#ifdef NON_MATCHING
 void ManagedTask::detachHandle() {
     TaskQueueLock lock;
     lock.lock(mQueue);
@@ -102,5 +103,6 @@ void ManagedTask::detachHandle() {
         }
     }
 }
+#endif
 
 }  // namespace ksys::util
diff --git a/src/KingSystem/Utils/Thread/MessageDispatcher.cpp b/src/KingSystem/Utils/Thread/MessageDispatcher.cpp
index c6c2baad..236fdd2e 100644
--- a/src/KingSystem/Utils/Thread/MessageDispatcher.cpp
+++ b/src/KingSystem/Utils/Thread/MessageDispatcher.cpp
@@ -239,7 +239,8 @@ bool MessageDispatcher::Queues::sendMessageOnProcessingThread(const MesTransceiv
     return mMainQueue.addMessage(message);
 }
 
-// NON_MATCHING: branching: deduplicated Message destructor call
+// branching: deduplicated Message destructor call
+#ifdef NON_MATCHING
 bool MessageDispatcher::sendMessageOnProcessingThread(const MesTransceiverId& src,
                                                       const MesTransceiverId& dest,
                                                       const MessageType& type, void* user_data,
@@ -248,6 +249,7 @@ bool MessageDispatcher::sendMessageOnProcessingThread(const MesTransceiverId& sr
         return false;
     return mQueues->sendMessageOnProcessingThread(src, dest, type, user_data, ack);
 }
+#endif
 
 struct AddMessageContext : IMessageBrokerRegister::IForEachContext {
     AddMessageContext(MessageQueue* queue, Message* message) : queue(queue), message(message) {}
@@ -331,7 +333,8 @@ void MessageDispatcher::Queues::process() {
     mIsProcessing = false;
 }
 
-// NON_MATCHING: regalloc
+// regalloc
+#ifdef NON_MATCHING
 void MessageDispatcher::update() {
     mUpdateEndEvent.resetSignal();
     mProcessingThread = sead::ThreadMgr::instance()->getCurrentThread();
@@ -342,5 +345,6 @@ void MessageDispatcher::update() {
     mProcessingThread = nullptr;
     mUpdateEndEvent.setSignal();
 }
+#endif
 
 }  // namespace ksys
diff --git a/src/KingSystem/Utils/Thread/Task.cpp b/src/KingSystem/Utils/Thread/Task.cpp
index e2ba464f..71cf18f5 100644
--- a/src/KingSystem/Utils/Thread/Task.cpp
+++ b/src/KingSystem/Utils/Thread/Task.cpp
@@ -34,7 +34,8 @@ void Task::deleteDelegate_() {
     }
 }
 
-// NON_MATCHING: mDelegate2 = nullptr store
+// mDelegate2 = nullptr store
+#ifdef NON_MATCHING
 void Task::finalize_() {
     if (mStatus == Status::Finalized)
         return;
@@ -47,6 +48,7 @@ void Task::finalize_() {
     mRemoveCallback = nullptr;
     mStatus = Status::Finalized;
 }
+#endif
 
 bool Task::setDelegate(const TaskDelegateSetter& setter) {
     mDelegate = setter.getDelegate();
@@ -56,7 +58,8 @@ bool Task::setDelegate(const TaskDelegateSetter& setter) {
     return onSetDelegate_(setter);
 }
 
-// NON_MATCHING: branching
+// branching
+#ifdef NON_MATCHING
 bool Task::submitRequest(TaskRequest& request) {
     // Processing this request is impossible if there is no thread *and* no queue!
     if (request.mThread == nullptr && request.mQueue == nullptr)
@@ -114,6 +117,7 @@ bool Task::submitRequest(TaskRequest& request) {
     }
     return push_ok || b;
 }
+#endif
 
 bool Task::canSubmitRequest() const {
     const bool run_finished_on_current_thread =
diff --git a/src/KingSystem/Utils/Thread/TaskMgr.cpp b/src/KingSystem/Utils/Thread/TaskMgr.cpp
index b5eec563..f8aa6f2c 100644
--- a/src/KingSystem/Utils/Thread/TaskMgr.cpp
+++ b/src/KingSystem/Utils/Thread/TaskMgr.cpp
@@ -80,7 +80,8 @@ void TaskMgr::submitRequest(TaskMgrRequest& request) {
         request.task = nullptr;
 }
 
-// NON_MATCHING: reorderings
+// reorderings
+#ifdef NON_MATCHING
 bool TaskMgr::fetchIdleTaskForRequest_(TaskMgrRequest& request, bool retry_until_success) {
     if (!hasTasks())
         return false;
@@ -108,6 +109,7 @@ bool TaskMgr::fetchIdleTaskForRequest_(TaskMgrRequest& request, bool retry_until
     request.task = task;
     return true;
 }
+#endif
 
 void TaskMgr::freeTask(ManagedTask* task) {
     auto lock = sead::makeScopedLock(mCS2);
@@ -155,7 +157,8 @@ bool TaskMgr::trySubmitRequest(TaskMgrRequest& request) {
     return ok;
 }
 
-// NON_MATCHING: the factory invoke function pointer is loaded earlier in the original code
+// the factory invoke function pointer is loaded earlier in the original code
+#ifdef NON_MATCHING
 void TaskMgr::init(s32 num_tasks, sead::Heap* heap, ManagedTaskFactory& factory) {
     if (!heap->isFreeable())
         mFlags.reset(Flag::HeapIsFreeable);
@@ -177,6 +180,7 @@ void TaskMgr::init(s32 num_tasks, sead::Heap* heap, ManagedTaskFactory& factory)
 
     factory(&mTask);
 }
+#endif
 
 bool TaskMgr::hasTasks() const {
     return mTasks.size() > 0;
diff --git a/src/KingSystem/Utils/Thread/TaskQueueBase.cpp b/src/KingSystem/Utils/Thread/TaskQueueBase.cpp
index 49e91f24..8c220ebb 100644
--- a/src/KingSystem/Utils/Thread/TaskQueueBase.cpp
+++ b/src/KingSystem/Utils/Thread/TaskQueueBase.cpp
@@ -234,7 +234,8 @@ void TaskQueueBase::blockTasks(u8 id) {
         mLanes[id].blocked = true;
 }
 
-// NON_MATCHING: the while (!areAllThreadsPaused()) loop generates weird code in the original
+// the while (!areAllThreadsPaused()) loop generates weird code in the original
+#ifdef NON_MATCHING
 void TaskQueueBase::blockTasksAndReloadThreads(u8 id) {
     blockTasks(id);
 
@@ -257,6 +258,7 @@ void TaskQueueBase::blockTasksAndReloadThreads(u8 id) {
             thread.resume();
     }
 }
+#endif
 
 void TaskQueueBase::unblockTasks(u8 id) {
     if (mLanes[id].blocked) {
@@ -407,7 +409,8 @@ void TaskQueueBase::removeTask(Task* task, bool b) {
     unlock();
 }
 
-// NON_MATCHING: regalloc inside the task lambda + reorderings for the loop counters.
+// regalloc inside the task lambda + reorderings for the loop counters.
+#ifdef NON_MATCHING
 void TaskQueueBase::fetchTask(Task** out_task) {
     lock();
 
@@ -481,5 +484,6 @@ void TaskQueueBase::fetchTask(Task** out_task) {
 
     unlock();
 }
+#endif
 
 }  // namespace ksys::util
diff --git a/src/KingSystem/Utils/Thread/TaskThread.cpp b/src/KingSystem/Utils/Thread/TaskThread.cpp
index 27dcd4e9..be24952b 100644
--- a/src/KingSystem/Utils/Thread/TaskThread.cpp
+++ b/src/KingSystem/Utils/Thread/TaskThread.cpp
@@ -136,8 +136,9 @@ bool TaskThread::isLookingForTask() const {
     return mFlags.isOn(Flag::IsLookingForTask);
 }
 
-// NON_MATCHING: branching for `if (mTaskQueue->getNumActiveTasks() == 0)`:
+// branching for `if (mTaskQueue->getNumActiveTasks() == 0)`:
 // Clang got rid of the branch and merged the two mFlags writes
+#ifdef NON_MATCHING
 void TaskThread::calc_(sead::MessageQueue::Element msg) {
     if (mFlags.isOn(Flag::Paused)) {
         if (msg != cMessage_Resume)
@@ -239,6 +240,7 @@ void TaskThread::calc_(sead::MessageQueue::Element msg) {
     mFlags.reset(Flag::IsActive);
     mFlags.reset(Flag::IsLookingForTask);
 }
+#endif
 
 bool TaskThread::receivedPauseMsg() const {
     return mMessageQueue.peek(sead::MessageQueue::BlockType::NonBlocking) == cMessage_Pause;