Code cleanup

CMakeSettings.json

@@ -14,7 +14,7 @@
       "generator": "Ninja",
       "inheritEnvironments": [ "msvc_x64_x64" ],
       "buildRoot": "${projectDir}\\out\\build\\${name}",
-      "installRoot": "${projectDir}\\out\\install\\${name}",
+      "installRoot": "${projectDir}\\out\\install\\${name}"
     },
     {
       "name": "Debug",

src/Cafe/CafeSystem.cpp

@@ -254,13 +254,6 @@ void InfoLog_PrintActiveSettings()
 	cemuLog_log(LogType::Force, "Console language: {}", config.console_language);
 }
 
-void PPCCore_setupSPR(PPCInterpreter_t* hCPU, uint32 coreIndex)
-{
-	hCPU->sprExtended.PVR = 0x70010001;
-	hCPU->spr.UPIR = coreIndex;
-	hCPU->sprExtended.msr |= MSR_FP; // enable floating point
-}
-
 struct SharedDataEntry
 {
 	/* +0x00 */ uint32be name;

src/Cafe/GamePatch.cpp

@@ -52,7 +52,7 @@ typedef struct
 void hleExport_xcx_enterCriticalSection(PPCInterpreter_t* hCPU)
 {
 	ppcDefineParamStructPtr(xcxCS, xcxCS_t, 0);
-	uint32 threadId = coreinitThread_getCurrentThreadMPTRDepr(hCPU);
+	uint32 threadId = MEMPTR<OSThread_t>(coreinit::OSGetCurrentThread()).GetMPTR();
 	cemu_assert_debug(xcxCS->ukn08 != 0);
 	cemu_assert_debug(threadId);
 	if (xcxCS->ownerThreadId == (uint32be)threadId)

src/Cafe/HW/Espresso/Debugger/Debugger.cpp

@@ -513,10 +513,10 @@ void debugger_enterTW(PPCInterpreter_t* hCPU)
 		if (bp->bpType == DEBUGGER_BP_T_LOGGING && bp->enabled)
 		{
 			std::string logName = !bp->comment.empty() ? "Breakpoint '"+boost::nowide::narrow(bp->comment)+"'" : fmt::format("Breakpoint at 0x{:08X} (no comment)", bp->address);
-			std::string logContext = fmt::format("Thread: {:08x} LR: 0x{:08x}", coreinitThread_getCurrentThreadMPTRDepr(hCPU), hCPU->spr.LR, cemuLog_advancedPPCLoggingEnabled() ? " Stack Trace:" : "");
+			std::string logContext = fmt::format("Thread: {:08x} LR: 0x{:08x}", MEMPTR<OSThread_t>(coreinit::OSGetCurrentThread()).GetMPTR(), hCPU->spr.LR, cemuLog_advancedPPCLoggingEnabled() ? " Stack Trace:" : "");
 			cemuLog_log(LogType::Force, "[Debugger] {} was executed! {}", logName, logContext);
 			if (cemuLog_advancedPPCLoggingEnabled())
-				DebugLogStackTrace(coreinitThread_getCurrentThreadDepr(hCPU), hCPU->gpr[1]);
+				DebugLogStackTrace(coreinit::OSGetCurrentThread(), hCPU->gpr[1]);
 			break;
 		}
 		bp = bp->next;
@@ -535,7 +535,7 @@ void debugger_enterTW(PPCInterpreter_t* hCPU)
 
 	// handle breakpoints
 	debuggerState.debugSession.isTrapped = true;
-	debuggerState.debugSession.debuggedThreadMPTR = coreinitThread_getCurrentThreadMPTRDepr(hCPU);
+	debuggerState.debugSession.debuggedThreadMPTR = MEMPTR<OSThread_t>(coreinit::OSGetCurrentThread()).GetMPTR();
 	debuggerState.debugSession.instructionPointer = hCPU->instructionPointer;
 	debuggerState.debugSession.hCPU = hCPU;
 	debugger_createPPCStateSnapshot(hCPU);

src/Cafe/HW/Espresso/Debugger/GDBStub.cpp

@@ -900,7 +900,7 @@ void GDBServer::HandleTrapInstruction(PPCInterpreter_t* hCPU)
 		return cemu_assert_suspicious();
 
 	// Secondly, delete one-shot breakpoints but also temporarily delete patched instruction to run original instruction
-	OSThread_t* currThread = coreinitThread_getCurrentThreadDepr(hCPU);
+	OSThread_t* currThread = coreinit::OSGetCurrentThread();
 	std::string pauseReason = fmt::format("T05thread:{:08X};core:{:02X};{}", GET_THREAD_ID(currThread), PPCInterpreter_getCoreIndex(hCPU), patchedBP->second.GetReason());
 	bool pauseThreads = patchedBP->second.ShouldBreakThreads() || patchedBP->second.ShouldBreakThreadsOnNextInterrupt();
 	if (patchedBP->second.IsPersistent())
@@ -939,7 +939,7 @@ void GDBServer::HandleTrapInstruction(PPCInterpreter_t* hCPU)
 			ThreadPool::FireAndForget(&waitForBrokenThreads, std::move(m_resumed_context), pauseReason);
 		}
 
-		breakThreads(GET_THREAD_ID(coreinitThread_getCurrentThreadDepr(hCPU)));
+		breakThreads(GET_THREAD_ID(coreinit::OSGetCurrentThread()));
 		cemuLog_logDebug(LogType::Force, "[GDBStub] Resumed from a breakpoint!");
 	}
 }

src/Cafe/HW/Latte/Core/LatteConst.h

@@ -1,21 +1,27 @@
 #pragma once
 #include "Cafe/HW/Latte/ISA/LatteReg.h"
 
-// this file contains legacy C-style defines, modernize and merge into LatteReg.h
+// todo - this file contains legacy C-style defines, modernize and merge into LatteReg.h
 
 // GPU7/Latte hardware info
 
-#define LATTE_NUM_GPR						(128)
-#define LATTE_NUM_STREAMOUT_BUFFER			(4)
-#define LATTE_NUM_COLOR_TARGET				(8)
+#define LATTE_NUM_GPR						128
+#define LATTE_NUM_STREAMOUT_BUFFER			4
+#define LATTE_NUM_COLOR_TARGET				8
 
-#define LATTE_NUM_MAX_TEX_UNITS				(18) // number of available texture units per shader stage (this might be higher than 18? BotW is the only game which uses more than 16?)
-#define LATTE_NUM_MAX_UNIFORM_BUFFERS		(16) // number of supported uniform buffer binding locations
+#define LATTE_NUM_MAX_TEX_UNITS				18 // number of available texture units per shader stage (this might be higher than 18? BotW is the only game which uses more than 16?)
+#define LATTE_NUM_MAX_UNIFORM_BUFFERS		16 // number of supported uniform buffer binding locations
 
-#define LATTE_VS_ATTRIBUTE_LIMIT			(32) // todo: verify
-#define	LATTE_NUM_MAX_ATTRIBUTE_LOCATIONS	(256) // should this be 128 since there are only 128 GPRs?
+#define LATTE_VS_ATTRIBUTE_LIMIT			32 // todo: verify
+#define	LATTE_NUM_MAX_ATTRIBUTE_LOCATIONS	256 // should this be 128 since there are only 128 GPRs?
 
-#define LATTE_MAX_VERTEX_BUFFERS			(16)
+#define LATTE_MAX_VERTEX_BUFFERS			16
+
+// Cemu-specific constants
+
+#define LATTE_CEMU_PS_TEX_UNIT_BASE 		0
+#define LATTE_CEMU_VS_TEX_UNIT_BASE 		32
+#define LATTE_CEMU_GS_TEX_UNIT_BASE 		64
 
 // vertex formats
 

src/Cafe/HW/Latte/Core/LatteTextureLegacy.cpp

@@ -1,10 +1,8 @@
 #include "Cafe/HW/Latte/ISA/RegDefines.h"
-#include "Cafe/OS/libs/gx2/GX2.h" // todo - remove this dependency
 #include "Cafe/HW/Latte/Core/Latte.h"
 #include "Cafe/HW/Latte/Core/LatteShader.h"
 
 #include "Cafe/HW/Latte/Renderer/Renderer.h"
-#include "Cafe/GraphicPack/GraphicPack2.h"
 
 #include "Cafe/HW/Latte/Renderer/OpenGL/OpenGLRenderer.h"
 #include "Cafe/HW/Latte/Renderer/OpenGL/LatteTextureGL.h"
@@ -330,15 +328,15 @@ void LatteTexture_updateTextures()
 	// pixel shader
 	LatteDecompilerShader* pixelShader = LatteSHRC_GetActivePixelShader();
 	if (pixelShader)
-		LatteTexture_updateTexturesForStage(pixelShader, CEMU_PS_TEX_UNIT_BASE, LatteGPUState.contextNew.SQ_TEX_START_PS);
+		LatteTexture_updateTexturesForStage(pixelShader, LATTE_CEMU_PS_TEX_UNIT_BASE, LatteGPUState.contextNew.SQ_TEX_START_PS);
 	// vertex shader
 	LatteDecompilerShader* vertexShader = LatteSHRC_GetActiveVertexShader();
 	cemu_assert_debug(vertexShader != nullptr);
-	LatteTexture_updateTexturesForStage(vertexShader, CEMU_VS_TEX_UNIT_BASE, LatteGPUState.contextNew.SQ_TEX_START_VS);
+	LatteTexture_updateTexturesForStage(vertexShader, LATTE_CEMU_VS_TEX_UNIT_BASE, LatteGPUState.contextNew.SQ_TEX_START_VS);
 	// geometry shader
 	LatteDecompilerShader* geometryShader = LatteSHRC_GetActiveGeometryShader();
 	if (geometryShader)
-		LatteTexture_updateTexturesForStage(geometryShader, CEMU_GS_TEX_UNIT_BASE, LatteGPUState.contextNew.SQ_TEX_START_GS);
+		LatteTexture_updateTexturesForStage(geometryShader, LATTE_CEMU_GS_TEX_UNIT_BASE, LatteGPUState.contextNew.SQ_TEX_START_GS);
 }
 
 // returns the width, height, depth of the texture

src/Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompilerAnalyzer.cpp

@@ -1,9 +1,7 @@
 #include "Cafe/HW/Latte/Core/LatteConst.h"
 #include "Cafe/HW/Latte/Core/LatteShaderAssembly.h"
 #include "Cafe/HW/Latte/ISA/RegDefines.h"
-#include "Cafe/OS/libs/gx2/GX2.h" // todo - remove this dependency
 #include "Cafe/HW/Latte/Core/Latte.h"
-#include "Cafe/HW/Latte/Core/LatteDraw.h"
 #include "Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompiler.h"
 #include "Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompilerInternal.h"
 #include "Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompilerInstructions.h"
@@ -477,11 +475,11 @@ namespace LatteDecompiler
 				continue;
 			sint32 textureBindingPoint;
 			if (decompilerContext->shaderType == LatteConst::ShaderType::Vertex)
-				textureBindingPoint = i + CEMU_VS_TEX_UNIT_BASE;
+				textureBindingPoint = i + LATTE_CEMU_VS_TEX_UNIT_BASE;
 			else if (decompilerContext->shaderType == LatteConst::ShaderType::Geometry)
-				textureBindingPoint = i + CEMU_GS_TEX_UNIT_BASE;
+				textureBindingPoint = i + LATTE_CEMU_GS_TEX_UNIT_BASE;
 			else if (decompilerContext->shaderType == LatteConst::ShaderType::Pixel)
-				textureBindingPoint = i + CEMU_PS_TEX_UNIT_BASE;
+				textureBindingPoint = i + LATTE_CEMU_PS_TEX_UNIT_BASE;
 
 			decompilerContext->output->resourceMappingGL.textureUnitToBindingPoint[i] = textureBindingPoint;
 		}

src/Cafe/HW/Latte/Renderer/Vulkan/CachedFBOVk.h

@@ -75,10 +75,6 @@ class CachedFBOVk : public LatteCachedFBO
 	VkRenderingAttachmentInfoKHR m_vkColorAttachments[8];
 	VkRenderingAttachmentInfoKHR m_vkDepthAttachment;
 	VkRenderingAttachmentInfoKHR m_vkStencilAttachment;
-	//uint8 m_vkColorAttachmentsCount{0};
-	bool m_vkHasDepthAttachment{ false };
-	bool m_vkHasStencilAttachment{ false };
-
 
 	std::vector<class PipelineInfo*> m_usedByPipelines; // PipelineInfo objects which use this renderpass/framebuffer
 };

src/Cafe/HW/Latte/Renderer/Vulkan/VulkanRendererCore.cpp

@@ -513,15 +513,15 @@ uint64 VulkanRenderer::GetDescriptorSetStateHash(LatteDecompilerShader* shader)
 		switch (shader->shaderType)
 		{
 		case LatteConst::ShaderType::Vertex:
-			hostTextureUnit += CEMU_VS_TEX_UNIT_BASE;
+			hostTextureUnit += LATTE_CEMU_VS_TEX_UNIT_BASE;
 			texUnitRegIndex += Latte::REGADDR::SQ_TEX_RESOURCE_WORD0_N_VS;
 			break;
 		case LatteConst::ShaderType::Pixel:
-			hostTextureUnit += CEMU_PS_TEX_UNIT_BASE;
+			hostTextureUnit += LATTE_CEMU_PS_TEX_UNIT_BASE;
 			texUnitRegIndex += Latte::REGADDR::SQ_TEX_RESOURCE_WORD0_N_PS;
 			break;
 		case LatteConst::ShaderType::Geometry:
-			hostTextureUnit += CEMU_GS_TEX_UNIT_BASE;
+			hostTextureUnit += LATTE_CEMU_GS_TEX_UNIT_BASE;
 			texUnitRegIndex += Latte::REGADDR::SQ_TEX_RESOURCE_WORD0_N_GS;
 			break;
 		default:
@@ -631,15 +631,15 @@ VkDescriptorSetInfo* VulkanRenderer::draw_getOrCreateDescriptorSet(PipelineInfo*
 		switch (shader->shaderType)
 		{
 		case LatteConst::ShaderType::Vertex:
-			hostTextureUnit += CEMU_VS_TEX_UNIT_BASE;
+			hostTextureUnit += LATTE_CEMU_VS_TEX_UNIT_BASE;
 			texUnitRegIndex += Latte::REGADDR::SQ_TEX_RESOURCE_WORD0_N_VS;
 			break;
 		case LatteConst::ShaderType::Pixel:
-			hostTextureUnit += CEMU_PS_TEX_UNIT_BASE;
+			hostTextureUnit += LATTE_CEMU_PS_TEX_UNIT_BASE;
 			texUnitRegIndex += Latte::REGADDR::SQ_TEX_RESOURCE_WORD0_N_PS;
 			break;
 		case LatteConst::ShaderType::Geometry:
-			hostTextureUnit += CEMU_GS_TEX_UNIT_BASE;
+			hostTextureUnit += LATTE_CEMU_GS_TEX_UNIT_BASE;
 			texUnitRegIndex += Latte::REGADDR::SQ_TEX_RESOURCE_WORD0_N_GS;
 			break;
 		default:

src/Cafe/IOSU/legacy/iosu_ioctl.cpp

@@ -1,6 +1,5 @@
 #include "Cafe/OS/common/OSCommon.h"
 #include "Cafe/OS/libs/coreinit/coreinit_Thread.h"
-#include "Cafe/OS/libs/coreinit/coreinit.h"
 #include "iosu_ioctl.h"
 #include "util/helpers/ringbuffer.h"
 
@@ -23,7 +22,7 @@ sint32 iosuIoctl_pushAndWait(uint32 ioctlHandle, ioQueueEntry_t* ioQueueEntry)
 	}
 	__OSLockScheduler();
 	ioctlMutex.lock();
-	ioQueueEntry->ppcThread = coreinitThread_getCurrentThreadDepr(PPCInterpreter_getCurrentInstance());
+	ioQueueEntry->ppcThread = coreinit::OSGetCurrentThread();
 
 	_ioctlRingbuffer[ioctlHandle].Push(ioQueueEntry);
 	ioctlMutex.unlock();

src/Cafe/OS/libs/coreinit/coreinit.cpp

@@ -35,7 +35,7 @@
 #include "Cafe/OS/libs/coreinit/coreinit_MEM_BlockHeap.h"
 #include "Cafe/OS/libs/coreinit/coreinit_MEM_ExpHeap.h"
 
-coreinitData_t* gCoreinitData = NULL;
+CoreinitSharedData* gCoreinitData = NULL;
 
 sint32 ScoreStackTrace(OSThread_t* thread, MPTR sp)
 {
@@ -323,8 +323,8 @@ void coreinit_load()
 	coreinit::InitializeSysHeap();
 
 	// allocate coreinit global data
-	gCoreinitData = (coreinitData_t*)memory_getPointerFromVirtualOffset(coreinit_allocFromSysArea(sizeof(coreinitData_t), 32));
-	memset(gCoreinitData, 0x00, sizeof(coreinitData_t));
+	gCoreinitData = (CoreinitSharedData*)memory_getPointerFromVirtualOffset(coreinit_allocFromSysArea(sizeof(CoreinitSharedData), 32));
+	memset(gCoreinitData, 0x00, sizeof(CoreinitSharedData));
 
 	// coreinit weak links
 	osLib_addVirtualPointer("coreinit", "MEMAllocFromDefaultHeap", memory_getVirtualOffsetFromPointer(&gCoreinitData->MEMAllocFromDefaultHeap));

src/Cafe/OS/libs/coreinit/coreinit.h

@@ -16,8 +16,7 @@ void coreinitAsyncCallback_addWithLock(MPTR functionMPTR, uint32 numParameters,
 void coreinit_load();
 
 // coreinit shared memory
-
-typedef struct  
+struct CoreinitSharedData
 {
 	MEMPTR<void> MEMAllocFromDefaultHeap;
 	MEMPTR<void> MEMAllocFromDefaultHeapEx;
@@ -26,11 +25,9 @@ typedef struct
 	MPTR __cpp_exception_init_ptr;
 	MPTR __cpp_exception_cleanup_ptr;
 	MPTR __stdio_cleanup;
-}coreinitData_t;
-
-extern coreinitData_t* gCoreinitData;
+};
 
-#include "Cafe/OS/libs/coreinit/coreinit_Spinlock.h"
+extern CoreinitSharedData* gCoreinitData;
 
 // coreinit init
 void coreinit_start(PPCInterpreter_t* hCPU);

src/Cafe/OS/libs/coreinit/coreinit_MCP.cpp

@@ -71,7 +71,6 @@ sint32 MCP_GetSysProdSettings(MCPHANDLE mcpHandle, SysProdSettings* sysProdSetti
 
 void coreinitExport_MCP_GetSysProdSettings(PPCInterpreter_t* hCPU)
 {
-	cemuLog_logDebug(LogType::Force, "MCP_GetSysProdSettings(0x{:08x},0x{:08x})", hCPU->gpr[3], hCPU->gpr[4]);
 	sint32 result = MCP_GetSysProdSettings(hCPU->gpr[3], (SysProdSettings*)memory_getPointerFromVirtualOffset(hCPU->gpr[4]));
 	osLib_returnFromFunction(hCPU, result);
 }

src/Cafe/OS/libs/coreinit/coreinit_Thread.cpp

@@ -198,7 +198,7 @@ namespace coreinit
 
 	void threadEntry(PPCInterpreter_t* hCPU)
 	{
-		OSThread_t* currentThread = coreinitThread_getCurrentThreadDepr(hCPU);
+		OSThread_t* currentThread = coreinit::OSGetCurrentThread();
 		uint32 r3 = hCPU->gpr[3];
 		uint32 r4 = hCPU->gpr[4];
 		uint32 lr = hCPU->spr.LR;
@@ -368,39 +368,38 @@ namespace coreinit
 	{
 		PPCInterpreter_t* hCPU = PPCInterpreter_getCurrentInstance();
 		hCPU->gpr[3] = exitValue;
-		OSThread_t* threadBE = coreinitThread_getCurrentThreadDepr(hCPU);
-		MPTR t = memory_getVirtualOffsetFromPointer(threadBE);
+		OSThread_t* currentThread = coreinit::OSGetCurrentThread();
 
 		// thread cleanup callback
-		if (!threadBE->cleanupCallback2.IsNull())
+		if (!currentThread->cleanupCallback2.IsNull())
 		{
-			threadBE->stateFlags = _swapEndianU32(_swapEndianU32(threadBE->stateFlags) | 0x00000001);
-			PPCCoreCallback(threadBE->cleanupCallback2.GetMPTR(), threadBE, _swapEndianU32(threadBE->stackEnd));
+			currentThread->stateFlags = _swapEndianU32(_swapEndianU32(currentThread->stateFlags) | 0x00000001);
+			PPCCoreCallback(currentThread->cleanupCallback2.GetMPTR(), currentThread, _swapEndianU32(currentThread->stackEnd));
 		}
 		// cpp exception cleanup
-		if (gCoreinitData->__cpp_exception_cleanup_ptr != 0 && threadBE->crt.eh_globals != nullptr)
+		if (gCoreinitData->__cpp_exception_cleanup_ptr != 0 && currentThread->crt.eh_globals != nullptr)
 		{
-			PPCCoreCallback(_swapEndianU32(gCoreinitData->__cpp_exception_cleanup_ptr), &threadBE->crt.eh_globals);
-			threadBE->crt.eh_globals = nullptr;
+			PPCCoreCallback(_swapEndianU32(gCoreinitData->__cpp_exception_cleanup_ptr), &currentThread->crt.eh_globals);
+			currentThread->crt.eh_globals = nullptr;
 		}
 		// set exit code
-		threadBE->exitValue = exitValue;
+		currentThread->exitValue = exitValue;
 
 		__OSLockScheduler();
 
 		// release held synchronization primitives
-		if (!threadBE->mutexQueue.isEmpty())
+		if (!currentThread->mutexQueue.isEmpty())
 		{
 			cemuLog_log(LogType::Force, "OSExitThread: Thread is holding mutexes");
 			while (true)
 			{
-				OSMutex* mutex = threadBE->mutexQueue.getFirst();
+				OSMutex* mutex = currentThread->mutexQueue.getFirst();
 				if (!mutex)
 					break;
-				if (mutex->owner != threadBE)
+				if (mutex->owner != currentThread)
 				{
 					cemuLog_log(LogType::Force, "OSExitThread: Thread is holding mutex which it doesn't own");
-					threadBE->mutexQueue.removeMutex(mutex);
+					currentThread->mutexQueue.removeMutex(mutex);
 					continue;
 				}
 				coreinit::OSUnlockMutexInternal(mutex);
@@ -409,22 +408,22 @@ namespace coreinit
 		// todo - release all fast mutexes
 
 		// handle join queue
-		if (!threadBE->joinQueue.isEmpty())
-			threadBE->joinQueue.wakeupEntireWaitQueue(false);
+		if (!currentThread->joinQueue.isEmpty())
+			currentThread->joinQueue.wakeupEntireWaitQueue(false);
 
-		if ((threadBE->attr & 8) != 0)
+		if ((currentThread->attr & 8) != 0)
 		{
 			// deactivate thread since it is detached
-			threadBE->state = OSThread_t::THREAD_STATE::STATE_NONE;
-			coreinit::__OSDeactivateThread(threadBE);
+			currentThread->state = OSThread_t::THREAD_STATE::STATE_NONE;
+			coreinit::__OSDeactivateThread(currentThread);
 			// queue call to thread deallocator if set
-			if (!threadBE->deallocatorFunc.IsNull())
-				__OSQueueThreadDeallocation(threadBE);
+			if (!currentThread->deallocatorFunc.IsNull())
+				__OSQueueThreadDeallocation(currentThread);
 		}
 		else
 		{
 			// non-detached threads remain active
-			threadBE->state = OSThread_t::THREAD_STATE::STATE_MORIBUND;
+			currentThread->state = OSThread_t::THREAD_STATE::STATE_MORIBUND;
 		}
 		PPCCore_switchToSchedulerWithLock();
 	}
@@ -1401,11 +1400,6 @@ void coreinit_resumeThread(OSThread_t* OSThreadBE, sint32 count)
 	__OSUnlockScheduler();
 }
 
-MPTR coreinitThread_getCurrentThreadMPTRDepr(PPCInterpreter_t* hCPU)
-{
-	return memory_getVirtualOffsetFromPointer(coreinit::__currentCoreThread[PPCInterpreter_getCoreIndex(hCPU)]);
-}
-
 OSThread_t* coreinitThread_getCurrentThreadDepr(PPCInterpreter_t* hCPU)
 {
 	return coreinit::__currentCoreThread[PPCInterpreter_getCoreIndex(hCPU)];