Compilation fix + CellSpursAttribute

Utilities/BEType.h

@@ -530,6 +530,24 @@ 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 se64(x) _se<u64, decltype(x), x>::value
 
+// template that helps to define be_t arrays in unions
+template<typename T, size_t size>
+class be_array_t
+{
+	be_t<T> data[size];
+
+public:
+	__forceinline be_t<T>& operator [] (size_t index)
+	{
+		return data[index];
+	}
+
+	__forceinline const be_t<T>& operator [] (size_t index) const
+	{
+		return data[index];
+	}
+};
+
 template<typename T> __forceinline static u8 Read8(T& f)
 {
 	u8 ret;

rpcs3/Emu/Cell/SPURSManager.cpp

@@ -3,37 +3,6 @@
 
 #include "SPURSManager.h"
 
-SPURSManagerAttribute::SPURSManagerAttribute(int nSpus, int spuPriority, int ppuPriority, bool exitIfNoWork)
-{
-	this->nSpus = nSpus;
-	this->spuThreadGroupPriority = spuPriority;
-	this->ppuThreadPriority = ppuPriority;
-	this->exitIfNoWork = exitIfNoWork;
-
-	memset(this->namePrefix, 0, CELL_SPURS_NAME_MAX_LENGTH + 1);
-	this->threadGroupType = 0;
-	this->container = 0;
-}
-
-int SPURSManagerAttribute::_setNamePrefix(const char *name, u32 size)
-{
-	strncpy(this->namePrefix, name, size);
-	this->namePrefix[0] = 0;
-	return 0;
-}
-
-int SPURSManagerAttribute::_setSpuThreadGroupType(int type)
-{
-	this->threadGroupType = type;
-	return 0;
-}
-
-int SPURSManagerAttribute::_setMemoryContainerForSpuThread(u32 container)
-{
-	this->container = container;
-	return 0;
-}
-
 SPURSManagerEventFlag::SPURSManagerEventFlag(u32 flagClearMode, u32 flagDirection)
 {
 	this->flagClearMode = flagClearMode;
@@ -46,14 +15,12 @@ SPURSManagerTasksetAttribute::SPURSManagerTasksetAttribute(u64 args, vm::ptr<con
 	this->maxContention = maxContention;
 }
 
-SPURSManager::SPURSManager(SPURSManagerAttribute *attr)
+SPURSManager::SPURSManager()
 {
-	this->attr = attr;
 }
 
 void SPURSManager::Finalize()
 {
-	delete this->attr;
 }
 
 void SPURSManager::AttachLv2EventQueue(u32 queue, vm::ptr<u8> port, int isDynamic)

rpcs3/Emu/Cell/SPURSManager.h

@@ -2,28 +2,6 @@
 
 #include "Emu/SysCalls/Modules/cellSpurs.h"
 
-// Internal class to shape a SPURS attribute.
-class SPURSManagerAttribute
-{
-public:
-	SPURSManagerAttribute(int nSpus, int spuPriority, int ppuPriority, bool exitIfNoWork);
-
-	int _setNamePrefix(const char *name, u32 size);
-
-	int _setSpuThreadGroupType(int type);
-
-	int _setMemoryContainerForSpuThread(u32 container);
-
-protected:
-	be_t<int> nSpus; 
-	be_t<int> spuThreadGroupPriority; 
-	be_t<int> ppuThreadPriority; 
-	bool exitIfNoWork;
-	char namePrefix[CELL_SPURS_NAME_MAX_LENGTH+1];
-	be_t<int> threadGroupType;
-	be_t<u32> container;
-};
-
 class SPURSManagerEventFlag
 {
 public:
@@ -68,12 +46,9 @@ protected:
 class SPURSManager
 {
 public:
-	SPURSManager(SPURSManagerAttribute *attr);
+	SPURSManager();
 
 	void Finalize();
 	void AttachLv2EventQueue(u32 queue, vm::ptr<u8> port, int isDynamic);
 	void DetachLv2EventQueue(u8 port);
-
-protected:
-	SPURSManagerAttribute *attr;
 };

rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp

@@ -15,23 +15,23 @@ extern u32 libsre_rtoc;
 
 s64 spursInit(
 	vm::ptr<CellSpurs2> spurs,
-	u32 arg2,
+	u32 revision,
-	u64 arg3,
+	u32 sdkVersion,
 	s32 nSpus,
 	s32 spuPriority,
 	s32 ppuPriority,
 	u32 flags,
-	u32 arg8,
+	const char prefix[],
-	u32 arg9,
+	u32 prefixSize,
-	u32 arg10,
+	u32 container,
 	u32 arg11,
 	u32 arg12,
 	u32 arg13)
 {
 	// internal function
 #ifdef PRX_DEBUG
-	return cb_caller<s32,vm::ptr<CellSpurs2>, u32, u64, s32, s32, s32, u32, u32, u32, u32, u32, u32, u32>::call(GetCurrentPPUThread(), libsre + 0x74E4, libsre_rtoc,
+	return cb_caller<s32,vm::ptr<CellSpurs2>, u32, u32, s32, s32, s32, u32, u32, u32, u32, u32, u32, u32>::call(GetCurrentPPUThread(), libsre + 0x74E4, libsre_rtoc,
-		spurs, arg2, arg3, nSpus, spuPriority, ppuPriority, flags, arg8, arg9, arg10, arg11, arg12, arg13);
+		spurs, revision, sdkVersion, nSpus, spuPriority, ppuPriority, flags, Memory.RealToVirtualAddr(prefix), prefixSize, container, arg11, arg12, arg13);
 #else
 	//spurs->spurs = new SPURSManager(attr);
 	return CELL_OK;
@@ -54,7 +54,7 @@ s64 cellSpursInitialize(vm::ptr<CellSpurs> spurs, s32 nSpus, s32 spuPriority, s3
 		spuPriority,
 		ppuPriority,
 		exitIfNoWork ? 1 : 0,
-		0,
+		nullptr,
 		0,
 		0,
 		0,
@@ -78,25 +78,25 @@ s64 cellSpursInitializeWithAttribute(vm::ptr<CellSpurs> spurs, vm::ptr<const Cel
 	{
 		return CELL_SPURS_CORE_ERROR_ALIGN;
 	}
-	if (attr->m.arg1 > 2)
+	if (attr->m.revision > 2)
 	{
 		return CELL_SPURS_CORE_ERROR_INVAL;
 	}
 	
 	return spursInit(
 		vm::ptr<CellSpurs2>::make(spurs.addr()),
-		attr->m.arg1,
+		attr->m.revision,
-		attr->m.arg2,
+		attr->m.sdkVersion,
 		attr->m.nSpus,
 		attr->m.spuPriority,
 		attr->m.ppuPriority,
-		(u32)attr->_u32.raw[10] | (u32)attr->_u8[20],
+		(u32)attr->m.flags | (attr->m.exitIfNoWork ? 1 : 0),
-		attr.addr() + 0x15,
+		attr->m.prefix,
-		attr->_u32.raw[9],
+		attr->m.prefixSize,
-		attr->_u32.raw[11],
+		attr->m.container,
 		attr.addr() + 0x38,
-		attr->_u32.raw[16],
+		attr->_u32[16],
-		attr->_u32.raw[17]);
+		attr->_u32[17]);
 #endif
 }
 
@@ -115,83 +115,106 @@ s64 cellSpursInitializeWithAttribute2(vm::ptr<CellSpurs2> spurs, vm::ptr<const C
 	{
 		return CELL_SPURS_CORE_ERROR_ALIGN;
 	}
-	if (attr->m.arg1 > 2)
+	if (attr->m.revision > 2)
 	{
 		return CELL_SPURS_CORE_ERROR_INVAL;
 	}
 
 	return spursInit(
 		spurs,
-		attr->m.arg1,
+		attr->m.revision,
-		attr->m.arg2,
+		attr->m.sdkVersion,
 		attr->m.nSpus,
 		attr->m.spuPriority,
 		attr->m.ppuPriority,
-		(u32)attr->_u32.raw[10] | (u32)attr->_u8[20] | 4,
+		(u32)attr->m.flags | (attr->m.exitIfNoWork ? 1 : 0) | 4,
-		attr.addr() + 0x15,
+		attr->m.prefix,
-		attr->_u32.raw[9],
+		attr->m.prefixSize,
-		attr->_u32.raw[11],
+		attr->m.container,
 		attr.addr() + 0x38,
-		attr->_u32.raw[16],
+		attr->_u32[16],
-		attr->_u32.raw[17]);
+		attr->_u32[17]);
 #endif
 }
 
-s64 cellSpursFinalize(vm::ptr<CellSpurs> spurs)
+s64 _cellSpursAttributeInitialize(vm::ptr<CellSpursAttribute> attr, u32 revision, u32 sdkVersion, u32 nSpus, s32 spuPriority, s32 ppuPriority, bool exitIfNoWork)
 {
-	cellSpurs->Warning("cellSpursFinalize(spurs_addr=0x%x)", spurs.addr());
+	cellSpurs->Warning("_cellSpursAttributeInitialize(attr_addr=0x%x, revision=%d, sdkVersion=0x%x, nSpus=%d, spuPriority=%d, ppuPriority=%d, exitIfNoWork=%d)",
+		attr.addr(), revision, sdkVersion, nSpus, spuPriority, ppuPriority, exitIfNoWork ? 1 : 0);
 
-#ifdef PRX_DEBUG
+#ifdef PRX_DEBUG_XXX
-	return GetCurrentPPUThread().FastCall2(libsre + 0x8568, libsre_rtoc);
-#else
-	spurs->spurs->Finalize();
-
-	return CELL_OK;
-#endif
-}
-
-s64 _cellSpursAttributeInitialize(vm::ptr<CellSpursAttribute> attr, s32 nSpus, s32 spuPriority, s32 ppuPriority, bool exitIfNoWork)
-{
-	cellSpurs->Warning("_cellSpursAttributeInitialize(attr_addr=0x%x, nSpus=%d, spuPriority=%d, ppuPriority=%d, exitIfNoWork=%d)",
-		attr.addr(), nSpus, spuPriority, ppuPriority, exitIfNoWork);
-
-#ifdef PRX_DEBUG
 	return GetCurrentPPUThread().FastCall2(libsre + 0x72CC, libsre_rtoc);
 #else
-	attr->attr = new SPURSManagerAttribute(nSpus, spuPriority, ppuPriority, exitIfNoWork);
+	if (!attr)
+	{
+		return CELL_SPURS_CORE_ERROR_NULL_POINTER;
+	}
+	if (attr.addr() % 8)
+	{
+		return CELL_SPURS_CORE_ERROR_ALIGN;
+	}
 
+	memset(attr.get_ptr(), 0, attr->size);
+	attr->m.revision = revision;
+	attr->m.sdkVersion = sdkVersion;
+	attr->m.nSpus = nSpus;
+	attr->m.spuPriority = spuPriority;
+	attr->m.ppuPriority = ppuPriority;
+	attr->m.exitIfNoWork = exitIfNoWork;
 	return CELL_OK;
 #endif
 }
 
 s64 cellSpursAttributeSetMemoryContainerForSpuThread(vm::ptr<CellSpursAttribute> attr, u32 container)
 {
-	cellSpurs->Warning("cellSpursAttributeSetMemoryContainerForSpuThread(attr_addr=0x%x, container=0x%x)", attr.addr(), container);
+	cellSpurs->Warning("cellSpursAttributeSetMemoryContainerForSpuThread(attr_addr=0x%x, container=%d)", attr.addr(), container);
 
-#ifdef PRX_DEBUG
+#ifdef PRX_DEBUG_XXX
 	return GetCurrentPPUThread().FastCall2(libsre + 0x6FF8, libsre_rtoc);
 #else
-	attr->attr->_setMemoryContainerForSpuThread(container);
+	if (!attr)
+	{
+		return CELL_SPURS_CORE_ERROR_NULL_POINTER;
+	}
+	if (attr.addr() % 8)
+	{
+		return CELL_SPURS_CORE_ERROR_ALIGN;
+	}
+	CellSpursAttribute a = *attr;
+	if ((u32)a.m.flags & 0x20000000) // check unknown flag
+	{
+		return CELL_SPURS_CORE_ERROR_STAT;
+	}
 
+	attr->_u32[11] = container;
+	attr->m.flags |= 0x40000000; // set unknown flag
 	return CELL_OK;
 #endif
 }
 
 s64 cellSpursAttributeSetNamePrefix(vm::ptr<CellSpursAttribute> attr, vm::ptr<const char> prefix, u32 size)
 {
-	cellSpurs->Warning("cellSpursAttributeSetNamePrefix(attr_addr=0x%x, prefix_addr=0x%x, size=0x%x)", attr.addr(), prefix.addr(), size);
+	cellSpurs->Warning("cellSpursAttributeSetNamePrefix(attr_addr=0x%x, prefix_addr=0x%x, size=%d)", attr.addr(), prefix.addr(), size);
 
-#ifdef PRX_DEBUG
+#ifdef PRX_DEBUG_XXX
 	return GetCurrentPPUThread().FastCall2(libsre + 0x7234, libsre_rtoc);
 #else
+	if (!attr || !prefix)
+	{
+		return CELL_SPURS_CORE_ERROR_NULL_POINTER;
+	}
+	if (attr.addr() % 8)
+	{
+		return CELL_SPURS_CORE_ERROR_ALIGN;
+	}
+
 	if (size > CELL_SPURS_NAME_MAX_LENGTH)
 	{
-		cellSpurs->Error("cellSpursAttributeSetNamePrefix : CELL_SPURS_CORE_ERROR_INVAL");
 		return CELL_SPURS_CORE_ERROR_INVAL;
 	}
 
-	attr->attr->_setNamePrefix(prefix.get_ptr(), size);
+	memcpy(attr->m.prefix, prefix.get_ptr(), size);
-
+	attr->m.prefixSize = size;
 	return CELL_OK;
 #endif
 }
@@ -211,12 +234,37 @@ s64 cellSpursAttributeSetSpuThreadGroupType(vm::ptr<CellSpursAttribute> attr, s3
 {
 	cellSpurs->Warning("cellSpursAttributeSetSpuThreadGroupType(attr_addr=0x%x, type=%d)", attr.addr(), type);
 
-#ifdef PRX_DEBUG
+#ifdef PRX_DEBUG_XXX
 	return GetCurrentPPUThread().FastCall2(libsre + 0x70C8, libsre_rtoc);
 #else
-	attr->attr->_setSpuThreadGroupType(type);
+	if (!attr)
+	{
+		return CELL_SPURS_CORE_ERROR_NULL_POINTER;
+	}
+	if (attr.addr() % 8)
+	{
+		return CELL_SPURS_CORE_ERROR_ALIGN;
+	}
 
-	return CELL_OK;
+	if (type == 0x18)
+	{
+		if (attr->m.flags & 0x40000000) // check unknown flag
+		{
+			return CELL_SPURS_CORE_ERROR_STAT;
+		}
+
+		attr->m.flags |= 0x20000000; // set unknown flag
+		return CELL_OK;
+	}
+	else if (type)
+	{
+		return CELL_SPURS_CORE_ERROR_INVAL;
+	}
+	else // if type == 0
+	{
+		attr->m.flags &= ~0x20000000; // clear unknown flag
+		return CELL_OK;
+	}
 #endif
 }
 
@@ -240,6 +288,19 @@ s64 cellSpursAttributeEnableSystemWorkload(vm::ptr<CellSpursAttribute> attr, vm:
 #endif
 }
 
+s64 cellSpursFinalize(vm::ptr<CellSpurs> spurs)
+{
+	cellSpurs->Warning("cellSpursFinalize(spurs_addr=0x%x)", spurs.addr());
+
+#ifdef PRX_DEBUG
+	return GetCurrentPPUThread().FastCall2(libsre + 0x8568, libsre_rtoc);
+#else
+	spurs->spurs->Finalize();
+
+	return CELL_OK;
+#endif
+}
+
 s64 cellSpursGetSpuThreadGroupId(vm::ptr<CellSpurs> spurs, vm::ptr<be_t<u32>> group)
 {
 #ifdef PRX_DEBUG

rpcs3/Emu/SysCalls/Modules/cellSpurs.h

@@ -77,7 +77,6 @@ enum TaskConstants
 };
 
 class SPURSManager;
-class SPURSManagerAttribute;
 class SPURSManagerEventFlag;
 class SPURSManagerTaskset;
 
@@ -100,27 +99,28 @@ struct CellSpursAttribute
 	union
 	{
 		// raw data
-		u8 _u8[size / sizeof(u8)];
+		u8 _u8[size];
-
+		be_array_t<u32, size / sizeof(u32)> _u32;
-		struct
-		{
-			be_t<u32> raw[size / sizeof(u32)];
-		} _u32;
 
 		// real structure
 		struct
 		{
-			be_t<u32> arg1;
+			be_t<u32> revision;    // 0x0
-			be_t<u32> arg2;
+			be_t<u32> sdkVersion;  // 0x4
-			be_t<u32> nSpus;
+			be_t<u32> nSpus;       // 0x8
-			be_t<s32> spuPriority;
+			be_t<s32> spuPriority; // 0xC
-			be_t<s32> ppuPriority;
+			be_t<s32> ppuPriority; // 0x10
+			bool exitIfNoWork;     // 0x14
+			char prefix[15];       // 0x15 (not a NTS)
+			be_t<u32> prefixSize;  // 0x24
+			be_t<u32> flags;       // 0x28
+			be_t<u32> container;   // 0x2C
+			// ...
 		} m;
 
 		// alternative implementation
 		struct
 		{
-			SPURSManagerAttribute *attr;
 		} c;
 	};
 };