Merge branch 'master' into texcache-stuffs

include/cpu_dynarmic.hpp

@@ -181,5 +181,7 @@ class CPU {
     void addTicks(u64 ticks) { env.AddTicks(ticks); }
 
     void clearCache() { jit->ClearCache(); }
+    void clearCacheRange(u32 start, u32 size) { jit->InvalidateCacheRange(start, size); }
+
     void runFrame();
 };

include/kernel/kernel.hpp

@@ -175,6 +175,8 @@ public:
 	void svcSignalEvent();
 	void svcSetTimer();
 	void svcSleepThread();
+	void svcInvalidateInstructionCacheRange();
+	void svcInvalidateEntireInstructionCache();
 	void connectToPort();
 	void outputDebugString();
 	void waitSynchronization1();
@@ -250,4 +252,5 @@ public:
 
 	void sendGPUInterrupt(GPUInterrupt type) { serviceManager.sendGPUInterrupt(type); }
 	void clearInstructionCache();
+	void clearInstructionCacheRange(u32 start, u32 size);
 };

include/renderer.hpp

@@ -53,6 +53,7 @@ class Renderer {
 
 	EmulatorConfig* emulatorConfig = nullptr;
 
+	void doSoftwareTextureCopy(u32 inputAddr, u32 outputAddr, u32 copySize, u32 inputWidth, u32 inputGap, u32 outputWidth, u32 outputGap);
   public:
 	Renderer(GPU& gpu, const std::array<u32, regNum>& internalRegs, const std::array<u32, extRegNum>& externalRegs);
 	virtual ~Renderer();

src/core/kernel/kernel.cpp

@@ -69,6 +69,10 @@ void Kernel::serviceSVC(u32 svc) {
 		case 0x3A: getResourceLimitCurrentValues(); break;
 		case 0x3B: getThreadContext(); break;
 		case 0x3D: outputDebugString(); break;
+
+		// Luma SVCs
+		case 0x93: svcInvalidateInstructionCacheRange(); break;
+		case 0x94: svcInvalidateEntireInstructionCache(); break;
 		default: Helpers::panic("Unimplemented svc: %X @ %08X", svc, regs[15]); break;
 	}
 
@@ -298,6 +302,23 @@ void Kernel::duplicateHandle() {
 }
 
 void Kernel::clearInstructionCache() { cpu.clearCache(); }
+void Kernel::clearInstructionCacheRange(u32 start, u32 size) { cpu.clearCacheRange(start, size); }
+
+void Kernel::svcInvalidateInstructionCacheRange() {
+	const u32 start = regs[0];
+	const u32 size = regs[1];
+	logSVC("svcInvalidateInstructionCacheRange(start = %08X, size = %08X)\n", start, size);
+
+	clearInstructionCacheRange(start, size);
+	regs[0] = Result::Success;
+}
+
+void Kernel::svcInvalidateEntireInstructionCache() {
+	logSVC("svcInvalidateEntireInstructionCache()\n");
+
+	clearInstructionCache();
+	regs[0] = Result::Success;
+}
 
 namespace SystemInfoType {
 	enum : u32 {

src/core/renderer_gl/renderer_gl.cpp

@@ -793,26 +793,7 @@ void RendererGL::textureCopy(u32 inputAddr, u32 outputAddr, u32 totalBytes, u32
 			printf("RendererGL::TextureCopy failed to locate src framebuffer!\n");
 		}
 
-		invalidateRegion(outputAddr, copySize);
+		doSoftwareTextureCopy(inputAddr, outputAddr, copySize, inputWidth, inputGap, outputWidth, outputGap);
-		u8* inputPointer = gpu.getPointerPhys<u8>(inputAddr);
-		u8* outputPointer = gpu.getPointerPhys<u8>(outputAddr);
-
-		u32 counter = 0;
-		u32 line = 0;
-
-		while (counter < copySize) {
-			const u32 bytes = inputWidth;
-			std::memcpy(outputPointer, inputPointer, bytes);
-			counter += bytes;
-			line += bytes;
-
-			inputPointer += inputWidth + inputGap;
-			if (line >= outputWidth) {
-				outputPointer += outputWidth + outputGap;
-				line = 0;
-			}
-		}
-
 		return;
 	}
 

src/core/renderer_mtl/renderer_mtl.cpp

@@ -426,7 +426,7 @@ void RendererMTL::textureCopy(u32 inputAddr, u32 outputAddr, u32 totalBytes, u32
 	// Find the source surface.
 	auto srcFramebuffer = getColorRenderTarget(inputAddr, PICA::ColorFmt::RGBA8, copyStride, copyHeight, false);
 	if (!srcFramebuffer) {
-		Helpers::warn("RendererMTL::TextureCopy failed to locate src framebuffer!\n");
+		doSoftwareTextureCopy(inputAddr, outputAddr, copySize, inputWidth, inputGap, outputWidth, outputGap);
 		return;
 	}
 	nextRenderPassName = "Clear before texture copy";

src/core/services/ldr_ro.cpp

@@ -22,6 +22,7 @@ namespace CROHeader {
 		NameOffset = 0x084,
 		NextCRO = 0x088,
 		PrevCRO = 0x08C,
+		FixedSize = 0x98,
 		OnUnresolved = 0x0AC,
 		CodeOffset = 0x0B0,
 		DataOffset = 0x0B8,
@@ -167,6 +168,10 @@ public:
 		return mem.read32(croPointer + CROHeader::PrevCRO);
 	}
 
+	u32 getFixedSize() {
+		return mem.read32(croPointer + CROHeader::FixedSize);
+	}
+
 	void setNextCRO(u32 nextCRO) {
 		mem.write32(croPointer + CROHeader::NextCRO, nextCRO);
 	}
@@ -1248,8 +1253,7 @@ void LDRService::initialize(u32 messagePointer) {
 		Helpers::panic("Failed to rebase CRS");
 	}
 
-	kernel.clearInstructionCache();
+	kernel.clearInstructionCacheRange(mapVaddr, size);
-
 	loadedCRS = mapVaddr;
 
 	mem.write32(messagePointer, IPC::responseHeader(0x1, 1, 0));
@@ -1278,8 +1282,6 @@ void LDRService::linkCRO(u32 messagePointer) {
 		Helpers::panic("Failed to link CRO");
 	}
 
-	kernel.clearInstructionCache();
-
 	mem.write32(messagePointer, IPC::responseHeader(0x6, 1, 0));
 	mem.write32(messagePointer + 4, Result::Success);
 }
@@ -1346,8 +1348,7 @@ void LDRService::loadCRO(u32 messagePointer, bool isNew) {
 
 	// TODO: add fixing
 	cro.fix(fixLevel);
-
+	kernel.clearInstructionCacheRange(mapVaddr, size);
-	kernel.clearInstructionCache();
 
 	if (isNew) {
 		mem.write32(messagePointer, IPC::responseHeader(0x9, 2, 0));
@@ -1377,7 +1378,6 @@ void LDRService::unloadCRO(u32 messagePointer) {
 	}
 
 	CRO cro(mem, mapVaddr, true);
-
 	cro.unregisterCRO(loadedCRS);
 
 	if (!cro.unlink(loadedCRS)) {
@@ -1388,8 +1388,7 @@ void LDRService::unloadCRO(u32 messagePointer) {
 		Helpers::panic("Failed to unrebase CRO");
 	}
 
-	kernel.clearInstructionCache();
+	kernel.clearInstructionCacheRange(mapVaddr, cro.getFixedSize());
-
 	mem.write32(messagePointer, IPC::responseHeader(0x5, 1, 0));
 	mem.write32(messagePointer + 4, Result::Success);
 }

src/renderer.cpp

@@ -3,6 +3,8 @@
 #include <algorithm>
 #include <unordered_map>
 
+#include "PICA/gpu.hpp"
+
 Renderer::Renderer(GPU& gpu, const std::array<u32, regNum>& internalRegs, const std::array<u32, extRegNum>& externalRegs)
 	: gpu(gpu), regs(internalRegs), externalRegs(externalRegs) {}
 Renderer::~Renderer() {}
@@ -39,3 +41,39 @@ const char* Renderer::typeToString(RendererType rendererType) {
 		default: return "Invalid";
 	}
 }
+
+void Renderer::doSoftwareTextureCopy(u32 inputAddr, u32 outputAddr, u32 copySize, u32 inputWidth, u32 inputGap, u32 outputWidth, u32 outputGap) {
+	u8* inputPointer = gpu.getPointerPhys<u8>(inputAddr);
+	u8* outputPointer = gpu.getPointerPhys<u8>(outputAddr);
+
+	if (inputPointer == nullptr || outputPointer == nullptr) {
+		return;
+	}
+
+	u32 inputBytesLeft = inputWidth;
+	u32 outputBytesLeft = outputWidth;
+	u32 copyBytesLeft = copySize;
+
+	while (copyBytesLeft > 0) {
+		const u32 bytes = std::min<u32>({inputBytesLeft, outputBytesLeft, copyBytesLeft});
+		std::memcpy(outputPointer, inputPointer, bytes);
+
+		inputPointer += bytes;
+		outputPointer += bytes;
+
+		inputBytesLeft -= bytes;
+		outputBytesLeft -= bytes;
+		copyBytesLeft -= bytes;
+
+		// Apply input and output gap when an input or output line ends
+		if (inputBytesLeft == 0) {
+			inputBytesLeft = inputWidth;
+			inputPointer += inputGap;
+		}
+
+		if (outputBytesLeft == 0) {
+			outputBytesLeft = outputWidth;
+			outputPointer += outputGap;
+		}
+	}
+}