Fix boot hangs from BIOS-only CD search and IOP module loading paths

ps2xIOP/CMakeLists.txt

@@ -12,15 +12,19 @@ add_library(ps2_iop STATIC
     src/emulator/core/iop_cpu.cpp
     src/emulator/core/iop_kernel.cpp
     src/emulator/core/iop_memory.cpp
+    src/emulator/core/iop_sio2.cpp
+    src/emulator/core/iop_spu2.cpp
     src/emulator/services/iop_module_loader.cpp
     src/emulator/services/iop_rpc.cpp
     src/emulator/imports/iop_cdvd.cpp
+    src/emulator/imports/iop_dmacman.cpp
     src/emulator/imports/iop_heaplib.cpp
     src/emulator/imports/iop_imports.cpp
     src/emulator/imports/iop_intrman.cpp
     src/emulator/imports/iop_ioman.cpp
     src/emulator/imports/iop_loadcore.cpp
     src/emulator/imports/iop_stdio.cpp
+    src/emulator/imports/iop_format.cpp
     src/emulator/imports/iop_sysclib.cpp
     src/emulator/imports/iop_sysmem.cpp
     src/emulator/imports/iop_timrman.cpp
@@ -62,6 +66,11 @@ if(PS2X_IOP_BUILD_TESTS)
     target_include_directories(ps2_iop_import_version_tests PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src)
     add_test(NAME ps2_iop_import_version_tests COMMAND ps2_iop_import_version_tests)
 
+    add_executable(ps2_iop_spu2_tests tests/iop_spu2_tests.cpp)
+    target_link_libraries(ps2_iop_spu2_tests PRIVATE ps2_iop)
+    target_include_directories(ps2_iop_spu2_tests PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src)
+    add_test(NAME ps2_iop_spu2_tests COMMAND ps2_iop_spu2_tests)
+
 endif()
 
 install(TARGETS ps2_iop

ps2xIOP/include/ps2x/iop/iop_host.h

@@ -96,6 +96,13 @@ namespace ps2x::iop
 
         virtual void audioCommand(uint32_t sid, uint32_t function, GuestBuffer send, GuestBuffer receive) = 0;
 
+        // Mixed SPU2 output: interleaved stereo 16-bit frames at 48 kHz, produced in emulated time.
+        virtual void audioOutput(const int16_t *samples, size_t frames)
+        {
+            (void)samples;
+            (void)frames;
+        }
+
         virtual std::string hostPath(HostPathKind kind) const = 0;
         virtual std::string translateGuestPath(std::string_view path) const = 0;
         virtual uint64_t openHostFile(std::string_view path) = 0;

ps2xIOP/include/ps2x/iop/iop_subsystem.h

@@ -26,6 +26,8 @@ namespace ps2x::iop
         [[nodiscard]] ModuleLoadResult loadModule(std::string_view path, const void *arguments = nullptr, uint32_t argumentSize = 0);
         [[nodiscard]] ModuleLoadResult loadModuleBuffer(uint32_t guestAddress, const void *arguments = nullptr, uint32_t argumentSize = 0);
         [[nodiscard]] bool stopModule(int32_t moduleId, int32_t *result = nullptr);
+        // Returns the id of the physical IRX whose image contains the IOP address, or -1.
+        [[nodiscard]] int32_t findModuleByAddress(uint32_t iopAddress) const noexcept;
         void runEeCycles(uint64_t eeCycles) noexcept;
 
         [[nodiscard]] RpcAbi selectRpcAbi(const RpcAbiRequest &request) const;

ps2xIOP/src/emulator/core/iop_cpu.cpp

@@ -96,6 +96,12 @@ namespace ps2x::iop::detail
         {
             scheduleLoad(reg, value, scheduledLoad, scheduledReg, scheduledValue);
         };
+        // LWL/LWR merge into a value still in the load delay slot, so an lwl/lwr pair
+        // assembles one word even though the register has not been written yet.
+        auto unalignedLoadBase = [&](uint32_t reg)
+        {
+            return cpu.pendingLoad && cpu.pendingLoadReg == reg ? cpu.pendingLoadValue : cpu.gpr[reg];
+        };
         auto overflowAdd = [&](int32_t lhs, int32_t rhs, uint32_t reg)
         {
             const int64_t result = static_cast<int64_t>(lhs) + rhs;
@@ -356,7 +362,7 @@ namespace ps2x::iop::detail
         {
             const uint32_t address = cpu.gpr[rs] + static_cast<uint32_t>(simm);
             const uint32_t memory = m_memory.read32(address & ~3u);
-            const uint32_t old = cpu.gpr[rt];
+            const uint32_t old = unalignedLoadBase(rt);
             static constexpr uint32_t masks[4] = {0x00FFFFFFu, 0x0000FFFFu, 0x000000FFu, 0x00000000u};
             static constexpr uint32_t shifts[4] = {24u, 16u, 8u, 0u};
             load(rt, (old & masks[address & 3u]) | (memory << shifts[address & 3u]));
@@ -377,7 +383,7 @@ namespace ps2x::iop::detail
         {
             const uint32_t address = cpu.gpr[rs] + static_cast<uint32_t>(simm);
             const uint32_t memory = m_memory.read32(address & ~3u);
-            const uint32_t old = cpu.gpr[rt];
+            const uint32_t old = unalignedLoadBase(rt);
             static constexpr uint32_t masks[4] = {0x00000000u, 0xFF000000u, 0xFFFF0000u, 0xFFFFFF00u};
             static constexpr uint32_t shifts[4] = {0u, 8u, 16u, 24u};
             load(rt, (old & masks[address & 3u]) | (memory >> shifts[address & 3u]));

ps2xIOP/src/emulator/core/iop_kernel.cpp

@@ -32,6 +32,7 @@ namespace ps2x::iop::detail
         m_nextSemaphoreId = 1;
         m_nextEventFlagId = 1;
         m_currentThread = nullptr;
+        m_maybeDeadThreads = false;
     }
 
     bool IopKernel::dispatchThreadImport(uint16_t ordinal, IopCpuState &cpu, uint64_t currentCycle)
@@ -107,6 +108,7 @@ namespace ps2x::iop::detail
             if (m_currentThread != nullptr)
             {
                 m_currentThread->state = ordinal == 9 ? IopThreadState::Dead : IopThreadState::Dormant;
+                m_maybeDeadThreads = m_maybeDeadThreads || ordinal == 9;
                 cpu.stopped = true;
                 cpu.yielded = true;
             }
@@ -471,6 +473,38 @@ namespace ps2x::iop::detail
         }
     }
 
+    bool IopKernel::eventFlagReady(int id, uint32_t bits, uint32_t mode) const
+    {
+        const auto event = m_eventFlags.find(id);
+        return event == m_eventFlags.end() || bits == 0u || eventSatisfied(event->second, bits, mode);
+    }
+
+    bool IopKernel::hasReadyAtOrAbove(int priority) const noexcept
+    {
+        for (const auto &[id, thread] : m_threads)
+        {
+            if (thread.state == IopThreadState::Ready && static_cast<int>(thread.priority) <= priority)
+                return true;
+        }
+        return false;
+    }
+
+    bool IopKernel::hasCriticalSectionInProgress() const noexcept
+    {
+        for (const auto &[id, thread] : m_threads)
+        {
+            if (thread.state == IopThreadState::Ready && thread.sliceEndedWithInterruptsOff)
+                return true;
+        }
+        return false;
+    }
+
+    bool IopKernel::semaphoreReady(int id) const
+    {
+        const auto semaphore = m_semaphores.find(id);
+        return semaphore == m_semaphores.end() || semaphore->second.current > 0;
+    }
+
     bool IopKernel::eventSatisfied(const EventFlag &event, uint32_t bits, uint32_t mode)
     {
         if (bits == 0u)
@@ -671,19 +705,25 @@ namespace ps2x::iop::detail
 
     IopThread *IopKernel::beginNextReady(uint64_t currentCycle)
     {
+        IopThread *next = nullptr;
+        bool resumeCriticalSection = false;
         for (auto &[id, thread] : m_threads)
         {
             if (thread.state == IopThreadState::Delay && thread.wakeCycle <= currentCycle)
                 thread.state = IopThreadState::Ready;
-        }
-
-        IopThread *next = nullptr;
-        for (auto &[id, thread] : m_threads)
-        {
-            if (thread.state != IopThreadState::Ready)
+            if (thread.state != IopThreadState::Ready || resumeCriticalSection)
                 continue;
+            if (thread.sliceEndedWithInterruptsOff)
+            {
+                next = &thread;
+                resumeCriticalSection = true;
+                continue;
+            }
+            // Among equal priorities the interrupted thread goes first; one that merely became ready
+            // (e.g. its DelayThread expired) must not cut into it.
             if (next == nullptr || thread.priority < next->priority ||
-                (thread.priority == next->priority && thread.id < next->id))
+                (thread.priority == next->priority &&
+                 (thread.sliceEnded != next->sliceEnded ? thread.sliceEnded : thread.id < next->id)))
                 next = &thread;
         }
         if (next == nullptr)
@@ -709,16 +749,26 @@ namespace ps2x::iop::detail
 
     void IopKernel::endTimeslice(IopThread &thread, uint32_t returnSentinel)
     {
+        thread.sliceEnded = false;
+        thread.sliceEndedWithInterruptsOff = false;
         if (thread.cpu.pc == returnSentinel || thread.cpu.stopped)
             thread.state = IopThreadState::Dormant;
         else if (thread.state == IopThreadState::Running)
+        {
             thread.state = IopThreadState::Ready;
+            // A yield (e.g. RotateThreadReadyQueue) gives way; running out of emulator budget does not.
+            thread.sliceEnded = !thread.cpu.yielded;
+            thread.sliceEndedWithInterruptsOff = thread.sliceEnded && m_memory.interruptControl() == 0u;
+        }
         m_currentThread = nullptr;
         cleanupDeadThreads();
     }
 
     void IopKernel::cleanupDeadThreads()
     {
+        if (!m_maybeDeadThreads)
+            return;
+        m_maybeDeadThreads = false;
         for (auto thread = m_threads.begin(); thread != m_threads.end();)
         {
             if (thread->second.state != IopThreadState::Dead)
@@ -738,7 +788,10 @@ namespace ps2x::iop::detail
         {
             const uint32_t pc = IopMemory::physicalAddress(thread.cpu.pc);
             if (pc >= base && pc < base + size)
+            {
                 thread.state = IopThreadState::Dead;
+                m_maybeDeadThreads = true;
+            }
         }
     }
 }

ps2xIOP/src/emulator/core/iop_kernel.h

@@ -41,6 +41,11 @@ namespace ps2x::iop::detail
         uint32_t waitMode = 0;
         uint32_t waitResultAddress = 0;
         int wakeupCount = 0;
+        // The emulator ended this thread's slice although the thread could still run. The IOP kernel does
+        // not time-slice: such a thread keeps the CPU until it blocks or a higher-priority thread becomes
+        // ready, and with interrupts suspended (CpuSuspendIntr) not even that can preempt it.
+        bool sliceEnded = false;
+        bool sliceEndedWithInterruptsOff = false;
     };
 
     class IopKernel
@@ -67,6 +72,21 @@ namespace ps2x::iop::detail
         void terminateThreadsInRange(uint32_t base, uint32_t size);
 
         [[nodiscard]] size_t threadCount() const noexcept { return m_threads.size(); }
+        [[nodiscard]] bool inThread() const noexcept { return m_currentThread != nullptr; }
+        // Priority of the thread now running, or -1 outside any thread.
+        [[nodiscard]] int currentPriority() const noexcept
+        {
+            return m_currentThread != nullptr ? static_cast<int>(m_currentThread->priority) : -1;
+        }
+        // Whether a thread that would run before one of `priority` is ready (lower value = more urgent;
+        // without time-slicing an equal-priority thread that already runs keeps the CPU).
+        [[nodiscard]] bool hasReadyAtOrAbove(int priority) const noexcept;
+        // Whether the emulator stopped a thread mid-run while it held interrupts off (CpuSuspendIntr).
+        [[nodiscard]] bool hasCriticalSectionInProgress() const noexcept;
+        // Whether a WaitEventFlag / WaitSema issued now could return without blocking (unknown IDs count as
+        // ready so the regular import reports the error).
+        [[nodiscard]] bool eventFlagReady(int id, uint32_t bits, uint32_t mode) const;
+        [[nodiscard]] bool semaphoreReady(int id) const;
 
     private:
         struct Semaphore
@@ -93,6 +113,8 @@ namespace ps2x::iop::detail
 
         IopMemory &m_memory;
         std::map<int, IopThread> m_threads;
+        // Set whenever a thread may have become Dead; endTimeslice runs every slice and must not walk all threads.
+        bool m_maybeDeadThreads = false;
         std::map<int, Semaphore> m_semaphores;
         std::map<int, EventFlag> m_eventFlags;
         uint32_t m_nextThreadId = 1;