KytyPlus v1.8

Author: Your Name

src/common/singleton.h

@@ -2,6 +2,7 @@
 #define KYTY_COMMON_SINGLETON_H_
 
 #include <cstdlib>
+#include <mutex>
 #include <new>
 
 namespace Common {
@@ -10,27 +11,17 @@ template <class T>
 class Singleton {
 public:
 	static T* Instance() {
-		if (!g_m_instance) {
-			// NOLINTNEXTLINE(cppcoreguidelines-no-malloc,hicpp-no-malloc)
-			g_m_instance = static_cast<T*>(std::malloc(sizeof(T)));
-			new (g_m_instance) T;
-		}
-
-		return g_m_instance;
+		static T instance;
+		return &instance;
 	}
 
 	KYTY_CLASS_NO_COPY(Singleton);
 
 protected:
-	Singleton();
-	~Singleton();
-
-private:
-	static inline T* g_m_instance = nullptr;
+	Singleton()  = default;
+	~Singleton() = default;
 };
 
-// template<class T> T* Singleton<T>::instance = 0;
-
 } // namespace Common
 
 #endif /* KYTY_COMMON_SINGLETON_H_ */

src/common/uniqueFunction.h

@@ -41,7 +41,7 @@ class UniqueFunction {
 	UniqueFunction(const UniqueFunction&)                = delete;
 	UniqueFunction& operator=(const UniqueFunction&)     = delete;
 
-	Result operator()(Args... args) const {
+	Result operator()(Args... args) {
 		return m_callable->Invoke(std::forward<Args>(args)...);
 	}
 

src/core/Avx512Emitter.hpp

@@ -44,25 +44,30 @@ namespace KytyPS5::JIT {
 
         // Emits SFENCE (Store Fence) for memory consistency
         std::expected<void, JitError> EmitStoreFence() {
-            return AppendBytes({ 0xEF });
+            // SFENCE = 0x0F 0xAE 0xF8
+            return AppendBytes({ 0x0F, 0xAE, 0xF8 });
         }
 
         // Emits LFENCE (Load Fence)
         std::expected<void, JitError> EmitLoadFence() {
-            return AppendBytes({ 0xEF }); // Simplified; real SFENCE/LFENCE differ in opcode bits
+            // LFENCE = 0x0F 0xAE 0xE8
+            return AppendBytes({ 0x0F, 0xAE, 0xE8 });
         }
 
-        const std::vector<uint8_t>& GetBuffer() const { return code_buffer_; }
+        // Emits MFENCE (Memory Fence)
+        std::expected<void, JitError> EmitMemFence() {
+            // MFENCE = 0x0F 0xAE 0xF0
+            return AppendBytes({ 0x0F, 0xAE, 0xF0 });
+        }
 
-        // Generic scaffolding entry used by JitDispatcher::EmitAvx512.
-        std::expected<void, JitError> EmitInstruction(uint32_t opcode, uint8_t zmm_reg) {
-            std::vector<uint8_t> bytes = {
-                0x62,
-                static_cast<uint8_t>(0x00 | ((zmm_reg & 7u) << 3)),
-                static_cast<uint8_t>(opcode & 0xFFu),
-                static_cast<uint8_t>(0x00 | ((zmm_reg & 7u) << 3)),
-            };
-            return AppendBytes(bytes);
+        // Raw emission callback for JitDispatcher — appends raw bytes to an external buffer
+        void EmitRaw(uint32_t opcode, uint8_t zmm_reg, std::vector<uint8_t>& out_buffer) {
+            // Simplified: emit a placeholder EVEX-encoded NOP-like instruction
+            // Real implementation would decode opcode and emit proper EVEV-encoded instruction
+            out_buffer.push_back(0x62);
+            out_buffer.push_back(static_cast<uint8_t>(0xF0 | (zmm_reg & 0x0F)));
+            out_buffer.push_back(0x00);
+            out_buffer.push_back(0x00);
         }
 
     private:
@@ -74,18 +79,4 @@ namespace KytyPS5::JIT {
         std::vector<uint8_t> code_buffer_;
     };
 
-    class JitTranslator {
-    public:
-        void TranslateSimd(uint8_t op) {
-            if (op == 0x01) { // Example Op: ADD_SIMD
-                emitter_.EmitVAddPs(0, 1, 2);
-            } else if (op == 0x02) { // Example Op: FENCE
-                emitter_.EmitStoreFence();
-            }
-        }
-
-    private:
-        Avx512Emitter emitter_;
-    };
-
 }

src/core/JitDispatcher.hpp

@@ -13,10 +13,10 @@
 namespace KytyPS5::Core {
 
 struct alignas(64) ThreadContext {
-	uint64_t gprs[32];
+	uint64_t gprs[16]; // x86-64 has 16 GPRs (rax, rcx, rdx, rbx, rsp, rbp, rsi, rdi, r8-r15)
 	uint64_t sp = 0;
 	uint64_t pc = 0;
-	uint64_t nzcv = 0;
+	uint64_t rflags = 0;
 };
 
 struct OpMov {
@@ -173,24 +173,10 @@ class JitDispatcher {
 		if (op.base_reg >= 12) {
 			EmitFillMove(op.base_reg, 10);
 		}
+		// MOV d, [b + offset]
 		PushByte(0x48);
-		PushByte(0x89);
-		PushModRM(0, b);
-		if (op.offset != 0) {
-			PushByte(0x48);
-			PushByte(0x05);
-			const uint32_t off = static_cast<uint32_t>(op.offset);
-			for (int i = 0; i < 4; ++i) {
-				PushByte(static_cast<uint8_t>((off >> (i * 8)) & 0xFF));
-			}
-		}
-		PushByte(0xE8);
-		for (int i = 0; i < 4; ++i) {
-			PushByte(0x00);
-		}
-		PushByte(0x48);
-		PushByte(0x89);
-		PushModRM(d, 0);
+		PushByte(0x8B);
+		PushModRM(d, b, static_cast<uint32_t>(op.offset));
 		if (op.reg_dest >= 12) {
 			EmitSpillMove(op.reg_dest, d);
 		}
@@ -205,12 +191,15 @@ class JitDispatcher {
 		if (op.base_reg >= 12) {
 			EmitFillMove(op.base_reg, 10);
 		}
+		// MOV [b + offset], s
 		PushByte(0x48);
 		PushByte(0x89);
-		PushModRM(b, s, static_cast<uint32_t>(op.offset));
+		PushModRM(s, b, static_cast<uint32_t>(op.offset));
 	}
 
 	void EmitJmp(const OpJmp& op) {
+		// JMP rel32 — caller must compute relative offset from end of this instruction
+		// For scaffolding, emit placeholder that will be patched later
 		PushByte(0xE9);
 		const uint32_t rel = static_cast<uint32_t>(op.target_addr);
 		for (int i = 0; i < 4; ++i) {
@@ -219,22 +208,21 @@ class JitDispatcher {
 	}
 
 	void EmitSyscall(const OpSyscall& op) {
+		// MOV RAX, call_id
 		PushByte(0x48);
 		PushByte(0xB8);
 		const uint64_t id = op.call_id;
 		for (int i = 0; i < 8; ++i) {
 			PushByte(static_cast<uint8_t>((id >> (i * 8)) & 0xFF));
 		}
+		// SYSCALL
 		PushByte(0x0F);
 		PushByte(0x05);
 	}
 
 	void EmitAvx512(const OpAvx512& op) {
-		(void)avx_emitter_->EmitInstruction(op.opcode, op.zmm_reg);
-		PushByte(0x62);
-		PushByte(0x00);
-		PushByte(0x00);
-		PushByte(0x00);
+		// Delegate to the AVX-512 emitter for proper encoding
+		avx_emitter_->EmitRaw(op.opcode, op.zmm_reg, code_buffer_);
 	}
 
 	std::vector<uint8_t> code_buffer_;

src/emulator.cpp

@@ -175,7 +175,8 @@ static void Execute(const std::filesystem::path& game_patch) {
 	    },
 	    &patch_path);
 	Libs::Graphics::WindowRun();
-	std::quick_exit(0);
+	KytyClose();
+	std::_Exit(0);
 }
 
 void Run(const RunOptions& options) {

src/graphics/host_gpu/graphicContext.h

@@ -6,6 +6,7 @@
 #include "graphics/host_gpu/vulkanCommon.h" // IWYU pragma: export
 #include "graphics/host_gpu/vulkanInstance.h"
 
+#include <memory>
 #include <vector>
 #include <vk_mem_alloc.h>
 
@@ -32,7 +33,7 @@ struct GraphicContext: public VulkanInstance {
 	void                   AppendHardwareRayTracingDeviceExtensions(
 	    const std::vector<vk::ExtensionProperties>& available_extensions,
 	    std::vector<const char*>&                   device_extensions);
-	void LoadHardwareRayTracingFunctions() const;
+	void LoadHardwareRayTracingFunctions();
 
 	uint32_t screen_width  = 0;
 	uint32_t screen_height = 0;

src/graphics/host_gpu/renderer/image/image.cpp

@@ -590,8 +590,9 @@ void Image::CopyImageWithBuffer(Image& source, Buffer& buffer) {
 }
 
 void Image::CopyMip(Image& source, uint32_t mip, uint32_t layer) {
-	EXIT_IF(m_scheduler == nullptr || source.backing.samples != backing.samples ||
-	        mip >= backing.mip_levels || layer >= backing.layers);
+	EXIT_IF(m_scheduler == nullptr || m_graphics == nullptr ||
+	        source.backing.samples != backing.samples || mip >= backing.mip_levels ||
+	        layer >= backing.layers);
 	m_scheduler->EndRendering();
 	const auto width  = std::max(backing.extent.width >> mip, 1u);
 	const auto height = std::max(backing.extent.height >> mip, 1u);
@@ -600,24 +601,59 @@ void Image::CopyMip(Image& source, uint32_t mip, uint32_t layer) {
 	const auto [source_layers, destination_layers] = SanitizeCopyLayers(source, *this, depth);
 	const auto aspects                             = FullAspectMask(source.backing.format);
 	EXIT_IF(aspects != FullAspectMask(backing.format));
-	std::array<vk::ImageCopy, 2> copies {};
-	uint32_t                     copy_count = 0;
-	for (const auto aspect: {vk::ImageAspectFlagBits::eColor, vk::ImageAspectFlagBits::eDepth,
-	                         vk::ImageAspectFlagBits::eStencil}) {
-		if (!static_cast<bool>(aspects & aspect)) {
+	auto command = m_scheduler->Current().Handle();
+	Transit(vk::ImageLayout::eTransferDstOptimal, vk::AccessFlagBits2::eTransferWrite, {}, command);
+	source.Transit(vk::ImageLayout::eTransferSrcOptimal, vk::AccessFlagBits2::eTransferRead, {},
+	               command);
+
+	const auto non_stencil = aspects & ~vk::ImageAspectFlagBits::eStencil;
+	for (const auto aspect: {vk::ImageAspectFlagBits::eColor, vk::ImageAspectFlagBits::eDepth}) {
+		if (!static_cast<bool>(non_stencil & aspect)) {
 			continue;
 		}
-		auto& copy          = copies[copy_count++];
+		vk::ImageCopy copy {};
 		copy.srcSubresource = {aspect, 0, 0, source_layers};
 		copy.dstSubresource = {aspect, mip, layer, destination_layers};
 		copy.extent         = {width, height, depth};
+		command.copyImage(source.backing.image, vk::ImageLayout::eTransferSrcOptimal, backing.image,
+		                  vk::ImageLayout::eTransferDstOptimal, 1, &copy);
+	}
+
+	// Some AMD hosts drop stencil during image-to-image copies of packed D*S8
+	// formats. Route the stencil plane through a scratch buffer instead.
+	if (static_cast<bool>(aspects & vk::ImageAspectFlagBits::eStencil)) {
+		const auto stencil_bytes =
+		    static_cast<uint64_t>(width) * height * depth * source_layers;
+		EXIT_IF(stencil_bytes == 0);
+		Buffer scratch(*m_graphics, *m_scheduler, MemoryUsage::DeviceLocal, 0,
+		               vk::BufferUsageFlagBits::eTransferSrc | vk::BufferUsageFlagBits::eTransferDst,
+		               stencil_bytes);
+		vk::BufferImageCopy region {};
+		region.imageSubresource = {vk::ImageAspectFlagBits::eStencil, 0, 0, source_layers};
+		region.imageExtent      = {width, height, depth};
+		command.copyImageToBuffer(source.backing.image, vk::ImageLayout::eTransferSrcOptimal,
+		                          scratch.Handle(), 1, &region);
+
+		vk::BufferMemoryBarrier2 buffer_barrier {};
+		buffer_barrier.srcStageMask        = vk::PipelineStageFlagBits2::eTransfer;
+		buffer_barrier.srcAccessMask       = vk::AccessFlagBits2::eTransferWrite;
+		buffer_barrier.dstStageMask        = vk::PipelineStageFlagBits2::eTransfer;
+		buffer_barrier.dstAccessMask       = vk::AccessFlagBits2::eTransferRead;
+		buffer_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+		buffer_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+		buffer_barrier.buffer              = scratch.Handle();
+		buffer_barrier.size                = stencil_bytes;
+		vk::DependencyInfo dependency {};
+		dependency.bufferMemoryBarrierCount = 1;
+		dependency.pBufferMemoryBarriers    = &buffer_barrier;
+		command.pipelineBarrier2(dependency);
+
+		region.imageSubresource = {vk::ImageAspectFlagBits::eStencil, mip, layer,
+		                           destination_layers};
+		command.copyBufferToImage(scratch.Handle(), backing.image,
+		                          vk::ImageLayout::eTransferDstOptimal, 1, &region);
 	}
-	auto command = m_scheduler->Current().Handle();
-	Transit(vk::ImageLayout::eTransferDstOptimal, vk::AccessFlagBits2::eTransferWrite, {}, command);
-	source.Transit(vk::ImageLayout::eTransferSrcOptimal, vk::AccessFlagBits2::eTransferRead, {},
-	               command);
-	command.copyImage(source.backing.image, vk::ImageLayout::eTransferSrcOptimal, backing.image,
-	                  vk::ImageLayout::eTransferDstOptimal, copy_count, copies.data());
+
 	Transit(vk::ImageLayout::eGeneral,
 	        vk::AccessFlagBits2::eShaderRead | vk::AccessFlagBits2::eTransferRead, {}, command);
 }