diff --git a/rpcs3/Emu/Cell/MFC.h b/rpcs3/Emu/Cell/MFC.h index 839987cd68f0..5ddf7a073ab0 100644 --- a/rpcs3/Emu/Cell/MFC.h +++ b/rpcs3/Emu/Cell/MFC.h @@ -21,6 +21,15 @@ enum MFC_MASK_CMD = 0xffff, }; +// Atomic Status Update +enum +{ + MFC_PUTLLC_SUCCESS = 0, + MFC_PUTLLC_FAILURE = 1, //reservation was lost + MFC_PUTLLUC_SUCCESS = 2, + MFC_GETLLAR_SUCCESS = 4, +}; + enum { MFC_SPU_TO_PPU_MAILBOX_STATUS_MASK = 0x000000FF, diff --git a/rpcs3/Emu/Cell/SPUThread.h b/rpcs3/Emu/Cell/SPUThread.h index 7dd9b2d636c9..84618e74a1a7 100644 --- a/rpcs3/Emu/Cell/SPUThread.h +++ b/rpcs3/Emu/Cell/SPUThread.h @@ -470,6 +470,7 @@ class SPUThread : public PPCThread Channel<1> QueryType; Channel<1> QueryMask; Channel<1> TagStatus; + Channel<1> AtomicStat; } Prxy; struct @@ -519,6 +520,31 @@ class SPUThread : public PPCThread } break; + case MFC_GETLLAR_CMD: + case MFC_PUTLLC_CMD: + case MFC_PUTLLUC_CMD: + { + extern std::mutex g_SyncMutex; + //can provide compatability for CellSyncMutex through SPU<>PPU and SPU<>SPU + if (op == MFC_GETLLAR_CMD) + { + g_SyncMutex.lock(); + } + + ConLog.Warning("DMA %s: lsa=0x%x, ea = 0x%llx, (tag) = 0x%x, (size) = 0x%x, cmd = 0x%x", + op == MFC_GETLLAR_CMD ? "GETLLAR" : op == MFC_PUTLLC_CMD ? "PUTLLC" : "PUTLLUC", + lsa, ea, tag, size, cmd); + + dmac.ProcessCmd(op == MFC_GETLLAR_CMD ? MFC_GET_CMD : MFC_PUT_CMD, tag, lsa, ea, 128); + Prxy.AtomicStat.PushUncond(op == MFC_GETLLAR_CMD ? MFC_GETLLAR_SUCCESS : op == MFC_PUTLLC_CMD ? MFC_PUTLLC_SUCCESS : MFC_PUTLLUC_SUCCESS); + + if (op == MFC_PUTLLC_CMD || op == MFC_PUTLLUC_CMD) + { + g_SyncMutex.unlock(); + } + } + break; + default: ConLog.Error("Unknown MFC cmd. (opcode=0x%x, cmd=0x%x, lsa = 0x%x, ea = 0x%llx, tag = 0x%x, size = 0x%x)", op, cmd, lsa, ea, tag, size); @@ -549,6 +575,9 @@ class SPUThread : public PPCThread case SPU_RdSigNotify2: return SPU.SNR[1].GetCount(); + case MFC_RdAtomicStat: + return Prxy.AtomicStat.GetCount(); + default: ConLog.Error("%s error: unknown/illegal channel (%d [%s]).", __FUNCTION__, ch, spu_ch_name[ch]); break; @@ -641,6 +670,10 @@ class SPUThread : public PPCThread //ConLog.Warning("%s: 0x%x = %s", __FUNCTION__, v, spu_ch_name[ch]); break; + case MFC_RdAtomicStat: + while (!Prxy.AtomicStat.Pop(v) && !Emu.IsStopped()) Sleep(1); + break; + default: ConLog.Error("%s error: unknown/illegal channel (%d [%s]).", __FUNCTION__, ch, spu_ch_name[ch]); break; diff --git a/rpcs3/Emu/Memory/Memory.h b/rpcs3/Emu/Memory/Memory.h index 5a50c3a2c8dd..9f53cad35763 100644 --- a/rpcs3/Emu/Memory/Memory.h +++ b/rpcs3/Emu/Memory/Memory.h @@ -425,9 +425,9 @@ class mem_base_t return Memory.IsGoodAddr(m_addr, sizeof(T)); } - __forceinline operator bool() const + __forceinline operator u32() const { - return m_addr != 0; + return m_addr; } __forceinline bool operator != (nullptr_t) const @@ -592,6 +592,11 @@ template class mem_t : public mem_base_t return *this; } + __forceinline T GetValue() + { + return (be_t&)Memory[this->m_addr]; + } + operator const T() const { return (be_t&)Memory[this->m_addr]; diff --git a/rpcs3/Emu/SysCalls/Modules/cellSync.cpp b/rpcs3/Emu/SysCalls/Modules/cellSync.cpp index 451d61d1ccea..ee0ae0d43e20 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellSync.cpp +++ b/rpcs3/Emu/SysCalls/Modules/cellSync.cpp @@ -1,9 +1,12 @@ #include "stdafx.h" #include "Emu/SysCalls/SysCalls.h" #include "Emu/SysCalls/SC_FUNC.h" +#include void cellSync_init(); -Module cellSync("cellSync", cellSync_init); +void cellSync_unload(); +Module cellSync("cellSync", cellSync_init, nullptr, cellSync_unload); +std::mutex g_SyncMutex; // Return Codes enum @@ -22,78 +25,114 @@ enum CELL_SYNC_ERROR_NO_SPU_CONTEXT_STORAGE = 0x80410114, }; -int cellSyncMutexInitialize(mem32_t mutex) +struct CellSyncMutex { + be_t m_freed; + be_t m_order; + /* + (???) Initialize: set zeros + (???) Lock: increase m_order and wait until m_freed == old m_order + (???) Unlock: increase m_freed + (???) TryLock: ????? + */ +}; + +int cellSyncMutexInitialize(mem_ptr_t mutex) { cellSync.Log("cellSyncMutexInitialize(mutex=0x%x)", mutex.GetAddr()); - const u32 mutex_addr = mutex.GetAddr(); - if (!mutex_addr) + + if (!mutex.IsGood()) { return CELL_SYNC_ERROR_NULL_POINTER; } - if (mutex_addr % 4) + if (mutex.GetAddr() % 4) { return CELL_SYNC_ERROR_ALIGN; } - mutex = 0; - _mm_sfence(); - return CELL_OK; + + { /* global mutex */ + std::lock_guard lock(g_SyncMutex); //??? + mutex->m_freed = 0; + mutex->m_order = 0; + return CELL_OK; + } } -int cellSyncMutexLock(mem32_t mutex) +int cellSyncMutexLock(mem_ptr_t mutex) { cellSync.Log("cellSyncMutexLock(mutex=0x%x)", mutex.GetAddr()); - const u32 mutex_addr = mutex.GetAddr(); - if (!mutex_addr) + + if (!mutex.IsGood()) { return CELL_SYNC_ERROR_NULL_POINTER; } - if (mutex_addr % 4) + if (mutex.GetAddr() % 4) { return CELL_SYNC_ERROR_ALIGN; } - while (_InterlockedExchange((volatile long*)(Memory + mutex_addr), 1 << 24)); - //need to check how does SPU work with these mutexes, also obtainment order is not guaranteed - _mm_lfence(); + + be_t old_order; + { /* global mutex */ + std::lock_guard lock(g_SyncMutex); + old_order = mutex->m_order; + mutex->m_order = mutex->m_order + 1; + } + + int counter = 0; + while (old_order != mutex->m_freed) + { + Sleep(1); + if (++counter >= 5000) + { + Emu.Pause(); + cellSync.Error("cellSyncMutexLock(mutex=0x%x, old_order=%d, order=%d, freed=%d): TIMEOUT", + mutex.GetAddr(), (u16)old_order, (u16)mutex->m_order, (u16)mutex->m_freed); + break; + } + } return CELL_OK; } -int cellSyncMutexTryLock(mem32_t mutex) +int cellSyncMutexTryLock(mem_ptr_t mutex) { cellSync.Log("cellSyncMutexTryLock(mutex=0x%x)", mutex.GetAddr()); - const u32 mutex_addr = mutex.GetAddr(); - if (!mutex_addr) + + if (!mutex.IsGood()) { return CELL_SYNC_ERROR_NULL_POINTER; } - if (mutex_addr % 4) + if (mutex.GetAddr() % 4) { return CELL_SYNC_ERROR_ALIGN; } - //check cellSyncMutexLock - if (_InterlockedExchange((volatile long*)(Memory + mutex_addr), 1 << 24)) - { - return CELL_SYNC_ERROR_BUSY; + { /* global mutex */ + std::lock_guard lock(g_SyncMutex); + if (mutex->m_order != mutex->m_freed) + { + return CELL_SYNC_ERROR_BUSY; + } + mutex->m_order = mutex->m_order + 1; + return CELL_OK; } - _mm_lfence(); - return CELL_OK; } -int cellSyncMutexUnlock(mem32_t mutex) +int cellSyncMutexUnlock(mem_ptr_t mutex) { cellSync.Log("cellSyncMutexUnlock(mutex=0x%x)", mutex.GetAddr()); - const u32 mutex_addr = mutex.GetAddr(); - if (!mutex_addr) + + if (!mutex.IsGood()) { return CELL_SYNC_ERROR_NULL_POINTER; } - if (mutex_addr % 4) + if (mutex.GetAddr() % 4) { return CELL_SYNC_ERROR_ALIGN; } - //check cellSyncMutexLock - _mm_sfence(); - _InterlockedExchange((volatile long*)(Memory + mutex_addr), 0); - return CELL_OK; + + { /* global mutex */ + std::lock_guard lock(g_SyncMutex); + mutex->m_freed = mutex->m_freed + 1; + return CELL_OK; + } } void cellSync_init() @@ -102,4 +141,9 @@ void cellSync_init() cellSync.AddFunc(0x1bb675c2, cellSyncMutexLock); cellSync.AddFunc(0xd06918c4, cellSyncMutexTryLock); cellSync.AddFunc(0x91f2b7b0, cellSyncMutexUnlock); +} + +void cellSync_unload() +{ + g_SyncMutex.unlock(); } \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp b/rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp index 1c2866b22b72..28584b91c6df 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp +++ b/rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp @@ -238,10 +238,12 @@ int cellSysutilGetSystemParamString(s32 id, mem_list_ptr_t buf, u32 bufsize) { case CELL_SYSUTIL_SYSTEMPARAM_ID_NICKNAME: cellSysutil.Warning("cellSysutilGetSystemParamString: CELL_SYSUTIL_SYSTEMPARAM_ID_NICKNAME"); + memcpy(buf, "Unknown", 8); //for example break; case CELL_SYSUTIL_SYSTEMPARAM_ID_CURRENT_USERNAME: cellSysutil.Warning("cellSysutilGetSystemParamString: CELL_SYSUTIL_SYSTEMPARAM_ID_CURRENT_USERNAME"); + memcpy(buf, "Unknown", 8); break; default: diff --git a/rpcs3/Emu/SysCalls/Modules/sys_fs.cpp b/rpcs3/Emu/SysCalls/Modules/sys_fs.cpp index 9819ef8fbd20..ca291901f142 100644 --- a/rpcs3/Emu/SysCalls/Modules/sys_fs.cpp +++ b/rpcs3/Emu/SysCalls/Modules/sys_fs.cpp @@ -3,7 +3,9 @@ #include "Emu/SysCalls/SC_FUNC.h" void sys_fs_init(); -Module sys_fs(0x000e, sys_fs_init); +void sys_fs_unload(); +Module sys_fs(0x000e, sys_fs_init, nullptr, sys_fs_unload); +Array FDs; bool sdata_check(u32 version, u32 flags, u64 filesizeInput, u64 filesizeTmp) { @@ -137,13 +139,9 @@ int cellFsSdataOpen(u32 path_addr, int flags, mem32_t fd, mem32_t arg, u64 size) std::atomic g_FsAioReadID = 0; -int cellFsAioRead(mem_ptr_t aio, mem32_t aio_id, mem_func_ptr_t xaio, u32 error, int xid, u64 size)> func) +void fsAioRead(u32 fd, mem_ptr_t aio, mem32_t aio_id, mem_func_ptr_t xaio, u32 error, int xid, u64 size)> func) { - ID id; - u32 fd = (u32)aio->fd; - if(!sys_fs.CheckId(fd, id)) return CELL_ESRCH; - vfsFileBase& orig_file = *(vfsFileBase*)id.m_data; - //open the file again (to prevent access conflicts roughly) + vfsFileBase& orig_file = *(vfsFileBase*)FDs[fd]; u64 nbytes = (u64)aio->size; const u32 buf_addr = (u32)aio->buf_addr; @@ -153,7 +151,8 @@ int cellFsAioRead(mem_ptr_t aio, mem32_t aio_id, mem_func_ptr_t aio, mem32_t aio_id, mem_func_ptr_tbuf_addr); + //start callback thread + if(func) + func.async(aio.GetAddr(), error, xid, res); +} + +int cellFsAioRead(mem_ptr_t aio, mem32_t aio_id, mem_func_ptr_t xaio, u32 error, int xid, u64 size)> func) +{ + //ID id; + u32 fd = (u32)aio->fd; + //if(!sys_fs.CheckId(fd, id)) return CELL_ESRCH; + if (fd >= FDs.GetCount()) return CELL_ESRCH; + if (FDs[fd] == nullptr) return CELL_ESRCH; + //vfsFileBase& orig_file = *(vfsFileBase*)id.m_data; + vfsFileBase& orig_file = *(vfsFileBase*)FDs[fd]; + + std::thread t(fsAioRead, fd, aio, aio_id, func); + t.detach(); - if(func) - func(aio, error, xid, res); + sys_fs.Warning("cellFsAioRead(aio_addr: 0x%x[%s, addr=0x%x], id_addr: 0x%x, func_addr: 0x%x)", aio.GetAddr(), + orig_file.GetPath().c_str(), (u32)aio->buf_addr, aio_id.GetAddr(), func.GetAddr()); return CELL_OK; } @@ -206,3 +220,16 @@ void sys_fs_init() sys_fs.AddFunc(0xcb588dba, cellFsFGetBlockSize); sys_fs.AddFunc(0xc1c507e7, cellFsAioRead); } + +void sys_fs_unload() +{ + for (u32 i = 0; i < FDs.GetCount(); i++) + { + if (FDs[i]) + { + FDs[i]->Close(); + delete FDs[i]; + } + } + FDs.Clear(); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/lv2/SC_FileSystem.cpp b/rpcs3/Emu/SysCalls/lv2/SC_FileSystem.cpp index 8e873b797288..fb4ad1ddf5fa 100644 --- a/rpcs3/Emu/SysCalls/lv2/SC_FileSystem.cpp +++ b/rpcs3/Emu/SysCalls/lv2/SC_FileSystem.cpp @@ -3,6 +3,7 @@ #include "Emu/SysCalls/SysCalls.h" extern Module sys_fs; +extern Array FDs; int cellFsOpen(u32 path_addr, int flags, mem32_t fd, mem32_t arg, u64 size) { @@ -94,7 +95,9 @@ int cellFsOpen(u32 path_addr, int flags, mem32_t fd, mem32_t arg, u64 size) return CELL_ENOENT; } - fd = sys_fs.GetNewId(stream, flags); + fd = FDs.AddCpy(stream); + //fd = sys_fs.GetNewId(stream, flags); + sys_fs.Warning("cellFsOpen(path: %s): fd == %d", path.mb_str(), fd.GetValue()); return CELL_OK; } @@ -103,9 +106,12 @@ int cellFsRead(u32 fd, u32 buf_addr, u64 nbytes, mem64_t nread) { sys_fs.Log("cellFsRead(fd: %d, buf_addr: 0x%x, nbytes: 0x%llx, nread_addr: 0x%x)", fd, buf_addr, nbytes, nread.GetAddr()); - ID id; - if(!sys_fs.CheckId(fd, id)) return CELL_ESRCH; - vfsStream& file = *(vfsStream*)id.m_data; + //ID id; + //if(!sys_fs.CheckId(fd, id)) return CELL_ESRCH; + if (fd >= FDs.GetCount()) return CELL_ESRCH; + if (FDs[fd] == nullptr) return CELL_ESRCH; + //vfsStream& file = *(vfsStream*)id.m_data; + vfsStream& file = *(vfsStream*)FDs[fd]; if(Memory.IsGoodAddr(buf_addr) && !Memory.IsGoodAddr(buf_addr, nbytes)) { @@ -125,9 +131,13 @@ int cellFsWrite(u32 fd, u32 buf_addr, u64 nbytes, mem64_t nwrite) { sys_fs.Log("cellFsWrite(fd: %d, buf_addr: 0x%x, nbytes: 0x%llx, nwrite_addr: 0x%x)", fd, buf_addr, nbytes, nwrite.GetAddr()); - ID id; - if(!sys_fs.CheckId(fd, id)) return CELL_ESRCH; - vfsStream& file = *(vfsStream*)id.m_data; + //ID id; + //if(!sys_fs.CheckId(fd, id)) return CELL_ESRCH; + if (fd >= FDs.GetCount()) return CELL_ESRCH; + if (FDs[fd] == nullptr) return CELL_ESRCH; + //vfsStream& file = *(vfsStream*)id.m_data; + vfsStream& file = *(vfsStream*)FDs[fd]; + if(Memory.IsGoodAddr(buf_addr) && !Memory.IsGoodAddr(buf_addr, nbytes)) { MemoryBlock& block = Memory.GetMemByAddr(buf_addr); @@ -144,12 +154,17 @@ int cellFsWrite(u32 fd, u32 buf_addr, u64 nbytes, mem64_t nwrite) int cellFsClose(u32 fd) { - sys_fs.Log("cellFsClose(fd: %d)", fd); - ID id; - if(!sys_fs.CheckId(fd, id)) return CELL_ESRCH; - vfsStream& file = *(vfsStream*)id.m_data; + sys_fs.Warning("cellFsClose(fd: %d)", fd); + //ID id; + //if(!sys_fs.CheckId(fd, id)) return CELL_ESRCH; + if (fd >= FDs.GetCount()) return CELL_ESRCH; + if (FDs[fd] == nullptr) return CELL_ESRCH; + //vfsStream& file = *(vfsStream*)id.m_data; + vfsStream& file = *(vfsStream*)FDs[fd]; file.Close(); - Emu.GetIdManager().RemoveID(fd); + delete FDs[fd]; + //Emu.GetIdManager().RemoveID(fd); + FDs[fd] = nullptr; return CELL_OK; } @@ -231,9 +246,12 @@ int cellFsStat(const u32 path_addr, mem_ptr_t sb) int cellFsFstat(u32 fd, mem_ptr_t sb) { sys_fs.Log("cellFsFstat(fd: %d, sb_addr: 0x%x)", fd, sb.GetAddr()); - ID id; - if(!sys_fs.CheckId(fd, id)) return CELL_ESRCH; - vfsStream& file = *(vfsStream*)id.m_data; + //ID id; + //if(!sys_fs.CheckId(fd, id)) return CELL_ESRCH; + if (fd >= FDs.GetCount()) return CELL_ESRCH; + if (FDs[fd] == nullptr) return CELL_ESRCH; + //vfsStream& file = *(vfsStream*)id.m_data; + vfsStream& file = *(vfsStream*)FDs[fd]; sb->st_mode = CELL_FS_S_IRUSR | CELL_FS_S_IWUSR | CELL_FS_S_IXUSR | @@ -312,9 +330,12 @@ int cellFsLseek(u32 fd, s64 offset, u32 whence, mem64_t pos) sys_fs.Error(fd, "Unknown seek whence! (%d)", whence); return CELL_EINVAL; } - ID id; - if(!sys_fs.CheckId(fd, id)) return CELL_ESRCH; - vfsStream& file = *(vfsStream*)id.m_data; + //ID id; + //if(!sys_fs.CheckId(fd, id)) return CELL_ESRCH; + if (fd >= FDs.GetCount()) return CELL_ESRCH; + if (FDs[fd] == nullptr) return CELL_ESRCH; + //vfsStream& file = *(vfsStream*)id.m_data; + vfsStream& file = *(vfsStream*)FDs[fd]; pos = file.Seek(offset, seek_mode); return CELL_OK; } @@ -322,9 +343,12 @@ int cellFsLseek(u32 fd, s64 offset, u32 whence, mem64_t pos) int cellFsFtruncate(u32 fd, u64 size) { sys_fs.Log("cellFsFtruncate(fd: %d, size: %lld)", fd, size); - ID id; - if(!sys_fs.CheckId(fd, id)) return CELL_ESRCH; - vfsStream& file = *(vfsStream*)id.m_data; + //ID id; + //if(!sys_fs.CheckId(fd, id)) return CELL_ESRCH; + if (fd >= FDs.GetCount()) return CELL_ESRCH; + if (FDs[fd] == nullptr) return CELL_ESRCH; + //vfsStream& file = *(vfsStream*)id.m_data; + vfsStream& file = *(vfsStream*)FDs[fd]; u64 initialSize = file.GetSize(); if (initialSize < size) diff --git a/rpcs3/Emu/SysCalls/lv2/SC_Memory.cpp b/rpcs3/Emu/SysCalls/lv2/SC_Memory.cpp index 7d7d866995ce..f1674f6ab48b 100644 --- a/rpcs3/Emu/SysCalls/lv2/SC_Memory.cpp +++ b/rpcs3/Emu/SysCalls/lv2/SC_Memory.cpp @@ -6,20 +6,26 @@ SysCallBase sc_mem("memory"); int sys_memory_container_create(u32 cid_addr, u32 yield_size) { - sc_mem.Warning("sys_memory_container_create(cid_addr=0x%x,yield_size=0x%x)", cid_addr, yield_size); + sc_mem.Warning("(HACK!) sys_memory_container_create(cid_addr=0x%x,yield_size=0x%x)", cid_addr, yield_size); if(!Memory.IsGoodAddr(cid_addr, 4)) { return CELL_EFAULT; } - u64 addr = Memory.Alloc(yield_size, 1); + yield_size &= ~0xfffff; //round down to 1 MB granularity + + //alignment hack (Memory.Alloc does not support alignment yet): alloc size is increased + u64 addr = Memory.Alloc(yield_size + 0x100000, 0x100000); //1 MB alignment (???) if(!addr) { return CELL_ENOMEM; } + //fix alignment: + addr = (addr + 0x100000) & ~0xfffff; + Memory.Write32(cid_addr, sc_mem.GetNewId(new MemoryContainerInfo(addr, yield_size))); return CELL_OK; } @@ -43,18 +49,20 @@ int sys_memory_container_destroy(u32 cid) int sys_memory_allocate(u32 size, u32 flags, u32 alloc_addr_addr) { //0x30000100; - sc_mem.Log("sys_memory_allocate(size=0x%x, flags=0x%x)", size, flags); + sc_mem.Warning("(HACK!) sys_memory_allocate(size=0x%x, flags=0x%x)", size, flags); u32 addr; switch(flags) { case SYS_MEMORY_PAGE_SIZE_1M: if(size & 0xfffff) return CELL_EALIGN; - addr = Memory.Alloc(size, 0x100000); + addr = Memory.Alloc(size + 0x100000, 0x100000); + addr = (addr + 0x100000) & ~0xfffff; break; case SYS_MEMORY_PAGE_SIZE_64K: if(size & 0xffff) return CELL_EALIGN; - addr = Memory.Alloc(size, 0x10000); + addr = Memory.Alloc(size + 0x10000, 0x10000); + addr = (addr + 0x10000) & ~0xffff; break; default: return CELL_EINVAL; diff --git a/rpcs3/Emu/SysCalls/lv2/SC_SPU_Thread.cpp b/rpcs3/Emu/SysCalls/lv2/SC_SPU_Thread.cpp index 2f1c27f98ca2..543e72d975e4 100644 --- a/rpcs3/Emu/SysCalls/lv2/SC_SPU_Thread.cpp +++ b/rpcs3/Emu/SysCalls/lv2/SC_SPU_Thread.cpp @@ -138,7 +138,7 @@ int sys_spu_thread_initialize(mem32_t thread, u32 group, u32 spu_num, mem_ptr_t< group_info.threads[spu_num] = &new_thread; - ConLog.Write("New SPU Thread:"); + /*ConLog.Write("New SPU Thread:"); ConLog.Write("SPU img offset = 0x%x", (u32)img->segs_addr); ConLog.Write("entry_point = 0x%x", spu_ep); ConLog.Write("name = %s", name.c_str()); @@ -147,7 +147,7 @@ int sys_spu_thread_initialize(mem32_t thread, u32 group, u32 spu_num, mem_ptr_t< ConLog.Write("a3 = 0x%x", a3); ConLog.Write("a4 = 0x%x", a4); ConLog.Write("ls_offset = 0x%x", ((SPUThread&)new_thread).dmac.ls_offset); - ConLog.SkipLn(); + ConLog.SkipLn();*/ return CELL_OK; } diff --git a/rpcs3/Loader/Loader.h b/rpcs3/Loader/Loader.h index ab5c974c20bb..8e5ec023bd9c 100644 --- a/rpcs3/Loader/Loader.h +++ b/rpcs3/Loader/Loader.h @@ -2,7 +2,7 @@ #include "Emu/FS/vfsFileBase.h" #ifdef _DEBUG - #define LOADER_DEBUG + //#define LOADER_DEBUG #endif enum Elf_Machine