mirror/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2025-02-25 12:40:57 +00:00
Code Issues Packages Projects Releases Wiki Activity

vm::atomic update, be_t update

Browse Source 
1) MakeFromLE replaced with make(), MakeFromBE removed. Compiler seems
to be able to optimize it anyway.
2) be_t<> conversion operator temporarily replaced with conversion
through LE because it can't work with all possible numeric conversions
(float<>int for example)
This commit is contained in:
Nekotekina 2014-09-20 03:16:11 +04:00
parent 0baf295c1b
commit 66000240ac
16 changed files with 98 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
Utilities/BEType.h
View File

@ -306,17 +306,12 @@ public:
m_data = se_t<T, sizeof(T2)>::func(value); m_data = se_t<T, sizeof(T2)>::func(value);
} }
static be_t MakeFromLE(const T value) static be_t make(const T value)
{ {
T data = se_t<T, sizeof(T2)>::func(value); T data = se_t<T, sizeof(T2)>::func(value);
return (be_t&)data; return (be_t&)data;
} }
static be_t MakeFromBE(const T value)
{
return (be_t&)value;
}
//template<typename T1> //template<typename T1>
operator const T() const operator const T() const
{ {
@ -335,7 +330,8 @@ public:
template<typename T1> template<typename T1>
operator const be_t<T1>() const operator const be_t<T1>() const
{ {
return _convert<T1, T, ((sizeof(T1) > sizeof(T)) ? 1 : (sizeof(T1) < sizeof(T) ? 2 : 0))>::func(m_data); return be_t<T1>::make(ToLE());
//return _convert<T1, T, ((sizeof(T1) > sizeof(T)) ? 1 : (sizeof(T1) < sizeof(T) ? 2 : 0))>::func(m_data);
} }
template<typename T1> be_t& operator += (T1 right) { return *this = T(*this) + right; } template<typename T1> be_t& operator += (T1 right) { return *this = T(*this) + right; }
@ -401,17 +397,12 @@ public:
return se_t<const T, sizeof(T2)>::func(m_data); return se_t<const T, sizeof(T2)>::func(m_data);
} }
static be_t MakeFromLE(const T value) static be_t make(const T value)
{ {
const T data = se_t<const T, sizeof(T2)>::func(value); const T data = se_t<const T, sizeof(T2)>::func(value);
return (be_t&)data; return (be_t&)data;
} }
static be_t MakeFromBE(const T value)
{
return (be_t&)value;
}
//template<typename T1> //template<typename T1>
operator const T() const operator const T() const
{ {
@ -421,21 +412,7 @@ public:
template<typename T1> template<typename T1>
operator const be_t<T1>() const operator const be_t<T1>() const
{ {
if (sizeof(T1) > sizeof(T) || std::is_floating_point<T>::value || std::is_floating_point<T1>::value) return be_t<T1>::make(ToLE());
{
T1 res = se_t<T1, sizeof(T1)>::func(ToLE());
return (be_t<T1>&)res;
}
else if (sizeof(T1) < sizeof(T))
{
T1 res = ToBE() >> ((sizeof(T) - sizeof(T1)) * 8);
return (be_t<T1>&)res;
}
else
{
T1 res = ToBE();
return (be_t<T1>&)res;
}
} }
template<typename T1> be_t operator & (const be_t<T1>& right) const { const T res = ToBE() & right.ToBE(); return (be_t&)res; } template<typename T1> be_t operator & (const be_t<T1>& right) const { const T res = ToBE() & right.ToBE(); return (be_t&)res; }
@ -540,12 +517,6 @@ template<typename T, typename T1, T1 value> struct _se<be_t<T>, T1, value> : pub
#define se32(x) _se<u32, decltype(x), x>::value #define se32(x) _se<u32, decltype(x), x>::value
#define se64(x) _se<u64, decltype(x), x>::value #define se64(x) _se<u64, decltype(x), x>::value
template<typename T>
__forceinline static const be_t<T> to_be(const T value)
{
return be_t<T>::MakeFromLE(value);
}
template<typename T> __forceinline static u8 Read8(T& f) template<typename T> __forceinline static u8 Read8(T& f)
{ {
u8 ret; u8 ret;

17
Utilities/GNU.h
View File

@ -45,7 +45,7 @@ void strcpy_trunc(char(&dst)[size], const char(&src)[rsize])
#define INFINITE 0xFFFFFFFF #define INFINITE 0xFFFFFFFF
#define _CRT_ALIGN(x) __attribute__((aligned(x))) #define _CRT_ALIGN(x) __attribute__((aligned(x)))
#define InterlockedCompareExchange(ptr,new_val,old_val) __sync_val_compare_and_swap(ptr,old_val,new_val) #define InterlockedCompareExchange(ptr,new_val,old_val) __sync_val_compare_and_swap(ptr,old_val,new_val)
#define InterlockedCompareExchange64(ptr,new_val,old_val) __sync_val_compare_and_swap(ptr,old_val,new_val) #define InterlockedExchange(ptr, value) __sync_lock_test_and_set(ptr, value)
inline int64_t InterlockedOr64(volatile int64_t *dest, int64_t val) inline int64_t InterlockedOr64(volatile int64_t *dest, int64_t val)
{ {
@ -54,7 +54,7 @@ inline int64_t InterlockedOr64(volatile int64_t *dest, int64_t val)
do do
{ {
olderval = oldval; olderval = oldval;
oldval = InterlockedCompareExchange64(dest, olderval | val, olderval); oldval = __sync_val_compare_and_swap(dest, olderval | val, olderval);
} while (olderval != oldval); } while (olderval != oldval);
return oldval; return oldval;
} }
@ -100,4 +100,15 @@ static __forceinline uint64_t InterlockedCompareExchange(volatile uint64_t* dest
{ {
return _InterlockedCompareExchange64((volatile long long*)dest, exch, comp); return _InterlockedCompareExchange64((volatile long long*)dest, exch, comp);
} }
#endif #endif
#ifndef InterlockedExchange
static __forceinline uint32_t InterlockedExchange(volatile uint32_t* dest, uint32_t value)
{
return _InterlockedExchange((volatile long*)dest, value);
}
static __forceinline uint64_t InterlockedExchange(volatile uint64_t* dest, uint64_t value)
{
return _InterlockedExchange64((volatile long long*)dest, value);
}
#endif

4
rpcs3/Crypto/unpkg.cpp
View File

@ -120,8 +120,8 @@ int Decrypt(rFile& pkg_f, rFile& dec_pkg_f, PKGHeader* m_header)
{ {
aes_crypt_ecb(&c, AES_ENCRYPT, iv, ctr+j*HASH_LEN); aes_crypt_ecb(&c, AES_ENCRYPT, iv, ctr+j*HASH_LEN);
be_t<u64> hi = be_t<u64>::MakeFromBE(*(u64*)&iv[0]); be_t<u64> hi = *(be_t<u64>*)&iv[0];
be_t<u64> lo = be_t<u64>::MakeFromBE(*(u64*)&iv[8]); be_t<u64> lo = *(be_t<u64>*)&iv[8];
lo++; lo++;
if (lo == 0) if (lo == 0)

2
rpcs3/Emu/CPU/CPUThread.h
View File

@ -109,7 +109,7 @@ public:
virtual std::string GetThreadName() const virtual std::string GetThreadName() const
{ {
std::string temp = (GetFName() + fmt::Format("[0x%08llx]", PC)); std::string temp = (GetFName() + fmt::Format("[0x%08x]", PC));
return temp; return temp;
} }

15
rpcs3/Emu/Memory/vm_atomic.h
View File

@ -25,16 +25,27 @@ namespace vm
template<typename T> template<typename T>
class _atomic_base class _atomic_base
{ {
T data; volatile T data;
typedef typename _to_atomic<T, sizeof(T)>::type atomic_type; typedef typename _to_atomic<T, sizeof(T)>::type atomic_type;
public: public:
T compare_and_swap(T cmp, T exch) __forceinline const T compare_and_swap(const T cmp, const T exch) volatile
{ {
const atomic_type res = InterlockedCompareExchange((volatile atomic_type*)&data, (atomic_type&)exch, (atomic_type&)cmp); const atomic_type res = InterlockedCompareExchange((volatile atomic_type*)&data, (atomic_type&)exch, (atomic_type&)cmp);
return (T&)res; return (T&)res;
} }
__forceinline const T exchange(const T value) volatile
{
const atomic_type res = InterlockedExchange((volatile atomic_type*)&data, (atomic_type&)value);
return (T&)res;
}
__forceinline const T read_relaxed() const volatile
{
return (T&)data;
}
}; };
template<typename T> struct atomic_le : public _atomic_base<T> template<typename T> struct atomic_le : public _atomic_base<T>

18
rpcs3/Emu/RSX/sysutil_video.h
View File

@ -228,15 +228,15 @@ enum CellVideoOutRGBOutputRange
static const CellVideoOutResolution ResolutionTable[] = static const CellVideoOutResolution ResolutionTable[] =
{ {
{ be_t<u16>::MakeFromBE(se16(0xffff)), be_t<u16>::MakeFromBE(se16(0xffff)) }, //0 - 0 { be_t<u16>::make(0xffff), be_t<u16>::make(0xffff) }, //0 - 0
{ be_t<u16>::MakeFromBE(se16(1920)), be_t<u16>::MakeFromBE(se16(1080)) }, //1 - 1 { be_t<u16>::make(1920), be_t<u16>::make(1080) }, //1 - 1
{ be_t<u16>::MakeFromBE(se16(1280)), be_t<u16>::MakeFromBE(se16(720)) }, //2 - 2 { be_t<u16>::make(1280), be_t<u16>::make(720) }, //2 - 2
{ be_t<u16>::MakeFromBE(se16(720)), be_t<u16>::MakeFromBE(se16(480)) }, //4 - 3 { be_t<u16>::make(720), be_t<u16>::make(480) }, //4 - 3
{ be_t<u16>::MakeFromBE(se16(720)), be_t<u16>::MakeFromBE(se16(576)) }, //5 - 4 { be_t<u16>::make(720), be_t<u16>::make(576) }, //5 - 4
{ be_t<u16>::MakeFromBE(se16(1600)), be_t<u16>::MakeFromBE(se16(1080)) }, //10 - 5 { be_t<u16>::make(1600), be_t<u16>::make(1080) }, //10 - 5
{ be_t<u16>::MakeFromBE(se16(1440)), be_t<u16>::MakeFromBE(se16(1080)) }, //11 - 6 { be_t<u16>::make(1440), be_t<u16>::make(1080) }, //11 - 6
{ be_t<u16>::MakeFromBE(se16(1280)), be_t<u16>::MakeFromBE(se16(1080)) }, //12 - 7 { be_t<u16>::make(1280), be_t<u16>::make(1080) }, //12 - 7
{ be_t<u16>::MakeFromBE(se16(960)), be_t<u16>::MakeFromBE(se16(1080)) }, //13 - 8 { be_t<u16>::make(960), be_t<u16>::make(1080) }, //13 - 8
}; };
inline static u32 ResolutionIdToNum(u32 id) inline static u32 ResolutionIdToNum(u32 id)

2
rpcs3/Emu/SysCalls/Modules/cellSaveData.cpp
View File

@ -210,7 +210,7 @@ void getSaveDataStat(SaveDataEntry entry, vm::ptr<CellSaveDataStatGet> statGet)
} }
} }
statGet->fileList = vm::bptr<CellSaveDataFileStat>::make(be_t<u32>::MakeFromLE((u32)Memory.Alloc(sizeof(CellSaveDataFileStat) * (u32)fileEntries.size(), sizeof(CellSaveDataFileStat)))); statGet->fileList = vm::bptr<CellSaveDataFileStat>::make(be_t<u32>::make((u32)Memory.Alloc(sizeof(CellSaveDataFileStat) * (u32)fileEntries.size(), sizeof(CellSaveDataFileStat))));
for (u32 i=0; i<fileEntries.size(); i++) for (u32 i=0; i<fileEntries.size(); i++)
memcpy(&statGet->fileList[i], &fileEntries[i], sizeof(CellSaveDataFileStat)); memcpy(&statGet->fileList[i], &fileEntries[i], sizeof(CellSaveDataFileStat));
} }

2
rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp
View File

@ -208,7 +208,7 @@ s64 spursInit(
spurs->m.ppu1 = ppu1->GetId(); spurs->m.ppu1 = ppu1->GetId();
// enable exception event handler // enable exception event handler
if (spurs->m.enableEH.compare_and_swap(be_t<u32>::MakeFromBE(0), be_t<u32>::MakeFromBE(se32(1))).ToBE() != 0) if (spurs->m.enableEH.compare_and_swap(be_t<u32>::make(0), be_t<u32>::make(1)).ToBE() == 0)
{ {
assert(sys_spu_thread_group_connect_event(spurs->m.spuTG, spurs->m.queue, SYS_SPU_THREAD_GROUP_EVENT_EXCEPTION) == CELL_OK); assert(sys_spu_thread_group_connect_event(spurs->m.spuTG, spurs->m.queue, SYS_SPU_THREAD_GROUP_EVENT_EXCEPTION) == CELL_OK);
} }

7
rpcs3/Emu/SysCalls/Modules/cellSync.cpp
View File

@ -16,7 +16,7 @@ u32 libsre;
u32 libsre_rtoc; u32 libsre_rtoc;
#endif #endif
s32 syncMutexInitialize(vm::ptr<CellSyncMutex> mutex) s32 syncMutexInitialize(vm::ptr<vm::atomic<CellSyncMutex>> mutex)
{ {
if (!mutex) if (!mutex)
{ {
@ -28,12 +28,11 @@ s32 syncMutexInitialize(vm::ptr<CellSyncMutex> mutex)
} }
// prx: set zero and sync // prx: set zero and sync
mutex->m_data() = 0; mutex->exchange({});
InterlockedCompareExchange(&mutex->m_data(), 0, 0);
return CELL_OK; return CELL_OK;
} }
s32 cellSyncMutexInitialize(vm::ptr<CellSyncMutex> mutex) s32 cellSyncMutexInitialize(vm::ptr<vm::atomic<CellSyncMutex>> mutex)
{ {
cellSync->Log("cellSyncMutexInitialize(mutex_addr=0x%x)", mutex.addr()); cellSync->Log("cellSyncMutexInitialize(mutex_addr=0x%x)", mutex.addr());

2
rpcs3/Emu/SysCalls/Modules/cellSync.h
View File

@ -155,7 +155,7 @@ struct CellSyncLFQueue
static_assert(sizeof(CellSyncLFQueue) == 128, "CellSyncLFQueue: wrong size"); static_assert(sizeof(CellSyncLFQueue) == 128, "CellSyncLFQueue: wrong size");
s32 syncMutexInitialize(vm::ptr<CellSyncMutex> mutex); s32 syncMutexInitialize(vm::ptr<vm::atomic<CellSyncMutex>> mutex);
s32 syncBarrierInitialize(vm::ptr<CellSyncBarrier> barrier, u16 total_count); s32 syncBarrierInitialize(vm::ptr<CellSyncBarrier> barrier, u16 total_count);

6
rpcs3/Emu/SysCalls/lv2/sys_lwcond.cpp
View File

@ -13,7 +13,7 @@ s32 lwcond_create(sys_lwcond_t& lwcond, sys_lwmutex_t& lwmutex, u64 name_u64)
{ {
u32 id = sys_lwcond.GetNewId(new Lwcond(name_u64), TYPE_LWCOND); u32 id = sys_lwcond.GetNewId(new Lwcond(name_u64), TYPE_LWCOND);
u32 addr = Memory.RealToVirtualAddr(&lwmutex); u32 addr = Memory.RealToVirtualAddr(&lwmutex);
lwcond.lwmutex.set(be_t<u32>::MakeFromLE(addr)); lwcond.lwmutex.set(be_t<u32>::make(addr));
lwcond.lwcond_queue = id; lwcond.lwcond_queue = id;
std::string name((const char*)&name_u64, 8); std::string name((const char*)&name_u64, 8);
@ -154,7 +154,7 @@ s32 sys_lwcond_wait(vm::ptr<sys_lwcond_t> lwcond, u64 timeout)
auto mutex = vm::ptr<sys_lwmutex_t>::make(lwcond->lwmutex.addr()); auto mutex = vm::ptr<sys_lwmutex_t>::make(lwcond->lwmutex.addr());
u32 tid_le = GetCurrentPPUThread().GetId(); u32 tid_le = GetCurrentPPUThread().GetId();
be_t<u32> tid = be_t<u32>::MakeFromLE(tid_le); be_t<u32> tid = be_t<u32>::make(tid_le);
SleepQueue* sq = nullptr; SleepQueue* sq = nullptr;
Emu.GetIdManager().GetIDData((u32)mutex->sleep_queue, sq); Emu.GetIdManager().GetIDData((u32)mutex->sleep_queue, sq);
@ -176,7 +176,7 @@ s32 sys_lwcond_wait(vm::ptr<sys_lwcond_t> lwcond, u64 timeout)
if (sq) if (sq)
{ {
mutex->mutex.unlock(tid, be_t<u32>::MakeFromLE(mutex->attribute.ToBE() == se32(SYS_SYNC_PRIORITY) ? sq->pop_prio() : sq->pop())); mutex->mutex.unlock(tid, be_t<u32>::make(mutex->attribute.ToBE() == se32(SYS_SYNC_PRIORITY) ? sq->pop_prio() : sq->pop()));
} }
else if (mutex->attribute.ToBE() == se32(SYS_SYNC_RETRY)) else if (mutex->attribute.ToBE() == se32(SYS_SYNC_RETRY))
{ {

8
rpcs3/Emu/SysCalls/lv2/sys_lwmutex.cpp
View File

@ -79,14 +79,14 @@ s32 sys_lwmutex_lock(vm::ptr<sys_lwmutex_t> lwmutex, u64 timeout)
//ConLog.Write("*** lock mutex (addr=0x%x, attr=0x%x, Nrec=%d, owner=%d, waiter=%d)", //ConLog.Write("*** lock mutex (addr=0x%x, attr=0x%x, Nrec=%d, owner=%d, waiter=%d)",
//lwmutex.addr(), (u32)lwmutex->attribute, (u32)lwmutex->recursive_count, lwmutex->vars.parts.owner.GetOwner(), (u32)lwmutex->waiter); //lwmutex.addr(), (u32)lwmutex->attribute, (u32)lwmutex->recursive_count, lwmutex->vars.parts.owner.GetOwner(), (u32)lwmutex->waiter);
return lwmutex->lock(be_t<u32>::MakeFromLE(GetCurrentPPUThread().GetId()), timeout ? ((timeout < 1000) ? 1 : (timeout / 1000)) : 0); return lwmutex->lock(be_t<u32>::make(GetCurrentPPUThread().GetId()), timeout ? ((timeout < 1000) ? 1 : (timeout / 1000)) : 0);
} }
s32 sys_lwmutex_trylock(vm::ptr<sys_lwmutex_t> lwmutex) s32 sys_lwmutex_trylock(vm::ptr<sys_lwmutex_t> lwmutex)
{ {
sys_lwmutex.Log("sys_lwmutex_trylock(lwmutex_addr=0x%x)", lwmutex.addr()); sys_lwmutex.Log("sys_lwmutex_trylock(lwmutex_addr=0x%x)", lwmutex.addr());
return lwmutex->trylock(be_t<u32>::MakeFromLE(GetCurrentPPUThread().GetId())); return lwmutex->trylock(be_t<u32>::make(GetCurrentPPUThread().GetId()));
} }
s32 sys_lwmutex_unlock(vm::ptr<sys_lwmutex_t> lwmutex) s32 sys_lwmutex_unlock(vm::ptr<sys_lwmutex_t> lwmutex)
@ -96,7 +96,7 @@ s32 sys_lwmutex_unlock(vm::ptr<sys_lwmutex_t> lwmutex)
//ConLog.Write("*** unlocking mutex (addr=0x%x, attr=0x%x, Nrec=%d, owner=%d, waiter=%d)", //ConLog.Write("*** unlocking mutex (addr=0x%x, attr=0x%x, Nrec=%d, owner=%d, waiter=%d)",
//lwmutex.addr(), (u32)lwmutex->attribute, (u32)lwmutex->recursive_count, (u32)lwmutex->vars.parts.owner.GetOwner(), (u32)lwmutex->waiter); //lwmutex.addr(), (u32)lwmutex->attribute, (u32)lwmutex->recursive_count, (u32)lwmutex->vars.parts.owner.GetOwner(), (u32)lwmutex->waiter);
return lwmutex->unlock(be_t<u32>::MakeFromLE(GetCurrentPPUThread().GetId())); return lwmutex->unlock(be_t<u32>::make(GetCurrentPPUThread().GetId()));
} }
void SleepQueue::push(u32 tid) void SleepQueue::push(u32 tid)
@ -292,7 +292,7 @@ int sys_lwmutex_t::unlock(be_t<u32> tid)
recursive_count -= 1; recursive_count -= 1;
if (!recursive_count.ToBE()) if (!recursive_count.ToBE())
{ {
be_t<u32> target = be_t<u32>::MakeFromBE(se32(0)); be_t<u32> target = be_t<u32>::make(0);
switch (attribute.ToBE() & se32(SYS_SYNC_ATTR_PROTOCOL_MASK)) switch (attribute.ToBE() & se32(SYS_SYNC_ATTR_PROTOCOL_MASK))
{ {
case se32(SYS_SYNC_FIFO): case se32(SYS_SYNC_FIFO):

4
rpcs3/Emu/SysCalls/lv2/sys_ppu_thread.cpp
View File

@ -214,8 +214,8 @@ void sys_ppu_thread_once(PPUThread& CPU, vm::ptr<vm::atomic<u32>> once_ctrl, vm:
{ {
sys_ppu_thread.Warning("sys_ppu_thread_once(once_ctrl_addr=0x%x, init_addr=0x%x)", once_ctrl.addr(), init.addr()); sys_ppu_thread.Warning("sys_ppu_thread_once(once_ctrl_addr=0x%x, init_addr=0x%x)", once_ctrl.addr(), init.addr());
auto cmp = to_be<u32>(SYS_PPU_THREAD_ONCE_INIT); be_t<u32> cmp = be_t<u32>::make(SYS_PPU_THREAD_ONCE_INIT);
if (once_ctrl->compare_and_swap(cmp, to_be<u32>(SYS_PPU_THREAD_DONE_INIT)) == cmp) if (once_ctrl->compare_and_swap(cmp, be_t<u32>::make(SYS_PPU_THREAD_DONE_INIT)) == cmp)
{ {
init.call(CPU); init.call(CPU);
} }

18
rpcs3/Emu/SysCalls/lv2/sys_spinlock.cpp
View File

@ -7,22 +7,22 @@
SysCallBase sys_spinlock("sys_spinlock"); SysCallBase sys_spinlock("sys_spinlock");
void sys_spinlock_initialize(vm::ptr<std::atomic<be_t<u32>>> lock) void sys_spinlock_initialize(vm::ptr<vm::atomic<u32>> lock)
{ {
sys_spinlock.Log("sys_spinlock_initialize(lock_addr=0x%x)", lock.addr()); sys_spinlock.Log("sys_spinlock_initialize(lock_addr=0x%x)", lock.addr());
// prx: set 0 and sync // prx: set 0 and sync
*lock = be_t<u32>::MakeFromBE(0); lock->exchange(be_t<u32>::make(0));
} }
void sys_spinlock_lock(vm::ptr<std::atomic<be_t<u32>>> lock) void sys_spinlock_lock(vm::ptr<vm::atomic<u32>> lock)
{ {
sys_spinlock.Log("sys_spinlock_lock(lock_addr=0x%x)", lock.addr()); sys_spinlock.Log("sys_spinlock_lock(lock_addr=0x%x)", lock.addr());
// prx: exchange with 0xabadcafe, repeat until exchanged with 0 // prx: exchange with 0xabadcafe, repeat until exchanged with 0
while (lock->exchange(be_t<u32>::MakeFromBE(se32(0xabadcafe))).ToBE()) while (lock->exchange(be_t<u32>::make(0xabadcafe)).ToBE())
{ {
while (lock->load(std::memory_order_relaxed).ToBE()) while (lock->read_relaxed().ToBE())
{ {
std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack
if (Emu.IsStopped()) if (Emu.IsStopped())
@ -39,12 +39,12 @@ void sys_spinlock_lock(vm::ptr<std::atomic<be_t<u32>>> lock)
} }
} }
s32 sys_spinlock_trylock(vm::ptr<std::atomic<be_t<u32>>> lock) s32 sys_spinlock_trylock(vm::ptr<vm::atomic<u32>> lock)
{ {
sys_spinlock.Log("sys_spinlock_trylock(lock_addr=0x%x)", lock.addr()); sys_spinlock.Log("sys_spinlock_trylock(lock_addr=0x%x)", lock.addr());
// prx: exchange with 0xabadcafe, translate exchanged value // prx: exchange with 0xabadcafe, translate exchanged value
if (lock->exchange(be_t<u32>::MakeFromBE(se32(0xabadcafe))).ToBE()) if (lock->exchange(be_t<u32>::make(0xabadcafe)).ToBE())
{ {
return CELL_EBUSY; return CELL_EBUSY;
} }
@ -52,10 +52,10 @@ s32 sys_spinlock_trylock(vm::ptr<std::atomic<be_t<u32>>> lock)
return CELL_OK; return CELL_OK;
} }
void sys_spinlock_unlock(vm::ptr<std::atomic<be_t<u32>>> lock) void sys_spinlock_unlock(vm::ptr<vm::atomic<u32>> lock)
{ {
sys_spinlock.Log("sys_spinlock_unlock(lock_addr=0x%x)", lock.addr()); sys_spinlock.Log("sys_spinlock_unlock(lock_addr=0x%x)", lock.addr());
// prx: sync and set 0 // prx: sync and set 0
*lock = be_t<u32>::MakeFromBE(0); lock->exchange(be_t<u32>::make(0));
} }

8
rpcs3/Emu/SysCalls/lv2/sys_spinlock.h
View File

@ -1,7 +1,7 @@
#pragma once #pragma once
// SysCalls // SysCalls
void sys_spinlock_initialize(vm::ptr<std::atomic<be_t<u32>>> lock); void sys_spinlock_initialize(vm::ptr<vm::atomic<u32>> lock);
void sys_spinlock_lock(vm::ptr<std::atomic<be_t<u32>>> lock); void sys_spinlock_lock(vm::ptr<vm::atomic<u32>> lock);
s32 sys_spinlock_trylock(vm::ptr<std::atomic<be_t<u32>>> lock); s32 sys_spinlock_trylock(vm::ptr<vm::atomic<u32>> lock);
void sys_spinlock_unlock(vm::ptr<std::atomic<be_t<u32>>> lock); void sys_spinlock_unlock(vm::ptr<vm::atomic<u32>> lock);

35
rpcs3/Loader/TROPUSR.cpp
View File

@ -144,11 +144,20 @@ bool TROPUSRLoader::Generate(const std::string& filepath, const std::string& con
default: trophy_grade = 0; default: trophy_grade = 0;
} }
TROPUSREntry4 entry4 = { be_t<u32>::MakeFromBE(se32(4)), be_t<u32>::MakeFromBE(se32(sizeof(TROPUSREntry4) - 0x10)), TROPUSREntry4 entry4 = {
be_t<u32>::MakeFromLE((u32)m_table4.size()), be_t<u32>::MakeFromBE(se32(0)), be_t<u32>::MakeFromLE(trophy_id), be_t<u32>::make(4),
be_t<u32>::MakeFromLE(trophy_grade), be_t<u32>::MakeFromBE(se32(0xFFFFFFFF)) }; be_t<u32>::make(sizeof(TROPUSREntry4) - 0x10),
TROPUSREntry6 entry6 = { be_t<u32>::MakeFromBE(se32(6)), be_t<u32>::MakeFromBE(se32(sizeof(TROPUSREntry6) - 0x10)), be_t<u32>::make((u32)m_table4.size()),
be_t<u32>::MakeFromLE((u32)m_table6.size()), be_t<u32>::MakeFromBE(0), be_t<u32>::MakeFromLE(trophy_id) }; be_t<u32>::make(0),
be_t<u32>::make(trophy_id),
be_t<u32>::make(trophy_grade),
be_t<u32>::make(0xFFFFFFFF) };
TROPUSREntry6 entry6 = {
be_t<u32>::make(6),
be_t<u32>::make(sizeof(TROPUSREntry6) - 0x10),
be_t<u32>::make((u32)m_table6.size()),
be_t<u32>::make(0),
be_t<u32>::make(trophy_id) };
m_table4.push_back(entry4); m_table4.push_back(entry4);
m_table6.push_back(entry6); m_table6.push_back(entry6);
@ -156,11 +165,19 @@ bool TROPUSRLoader::Generate(const std::string& filepath, const std::string& con
} }
u64 offset = sizeof(TROPUSRHeader) + 2 * sizeof(TROPUSRTableHeader); u64 offset = sizeof(TROPUSRHeader) + 2 * sizeof(TROPUSRTableHeader);
TROPUSRTableHeader table4header = { be_t<u32>::MakeFromBE(se32(4)), be_t<u32>::MakeFromBE(se32(sizeof(TROPUSREntry4)-0x10)), TROPUSRTableHeader table4header = {
be_t<u32>::MakeFromBE(se32(1)), be_t<u32>::MakeFromLE((u32)m_table4.size()), be_t<u64>::MakeFromLE(offset) }; be_t<u32>::make(4),
be_t<u32>::make(sizeof(TROPUSREntry4) - 0x10),
be_t<u32>::make(1),
be_t<u32>::make((u32)m_table4.size()),
be_t<u64>::make(offset) };
offset += m_table4.size() * sizeof(TROPUSREntry4); offset += m_table4.size() * sizeof(TROPUSREntry4);
TROPUSRTableHeader table6header = { be_t<u32>::MakeFromBE(se32(6)), be_t<u32>::MakeFromBE(se32(sizeof(TROPUSREntry6)-0x10)), TROPUSRTableHeader table6header = {
be_t<u32>::MakeFromBE(se32(1)), be_t<u32>::MakeFromLE((u32)m_table6.size()), be_t<u64>::MakeFromLE(offset) }; be_t<u32>::make(6),
be_t<u32>::make(sizeof(TROPUSREntry6) - 0x10),
be_t<u32>::make(1),
be_t<u32>::make((u32)m_table6.size()),
be_t<u64>::make(offset) };
offset += m_table6.size() * sizeof(TROPUSREntry6); offset += m_table6.size() * sizeof(TROPUSREntry6);
m_tableHeaders.clear(); m_tableHeaders.clear();