Merge pull request #1615 from davidgfnet/memx64

Implement fast memory ops on x64

Author: davidgfnet

core/hw/sh4/dyna/blockmanager.cpp

@@ -34,53 +34,7 @@ bm_List all_blocks;
 bm_List del_blocks;
 #include <set>
 
-struct BlockMapCMP
-{
-	static bool is_code(RuntimeBlockInfo* blk)
-	{
-		if ((unat)((u8*)blk-CodeCache)<CODE_SIZE)
-			return true;
-		else
-			return false;
-	}
-
-	static unat get_blkstart(RuntimeBlockInfo* blk)
-	{
-		if (is_code(blk)) 
-			return (unat)blk; 
-		else 
-			return (unat)blk->code;
-	}
-
-	static unat get_blkend(RuntimeBlockInfo* blk)
-	{
-		if (is_code(blk)) 
-			return (unat)blk; 
-		else 
-			return (unat)blk->code+blk->host_code_size-1;
-	}
-
-	//return true if blkl > blkr
-	bool operator()(RuntimeBlockInfo* blkl, RuntimeBlockInfo* blkr) const
-	{
-		if (!is_code(blkl) && !is_code(blkr))
-			return (unat)blkl->code<(unat)blkr->code;
-
-		unat blkr_start=get_blkstart(blkr),blkl_end=get_blkend(blkl);
-
-		if (blkl_end<blkr_start)
-		{
-			return true;
-		}
-		else
-		{
-			return false;
-		}
-	}
-};
-
-typedef std::set<RuntimeBlockInfo*,BlockMapCMP> blkmap_t;
-blkmap_t blkmap;
+std::map<void*, RuntimeBlockInfo*> blkmap;
 u32 bm_gc_luc,bm_gcf_luc;
 
 
@@ -114,18 +68,20 @@ RuntimeBlockInfo* DYNACALL bm_GetBlock(u32 addr)
 // This takes a RX address and returns the info block ptr (RW space)
 RuntimeBlockInfo* bm_GetBlock(void* dynarec_code)
 {
+	if (blkmap.empty())
+		return 0;
+
 	void *dynarecrw = CC_RX2RW(dynarec_code);
-	blkmap_t::iterator iter = blkmap.find((RuntimeBlockInfo*)dynarecrw);
-	if (iter != blkmap.end())
-	{
-		verify((*iter)->contains_code((u8*)dynarecrw));
-		return *iter;
-	}
-	else
-	{
-		printf("bm_GetBlock(%p) failed ..\n", dynarec_code);
+	// Returns a block who's code addr is bigger than dynarec_code (or end)
+	auto iter = blkmap.upper_bound(dynarecrw);
+	iter--;  // Need to go back to find the potential candidate
+
+	// However it might be out of bounds, check for that
+	if ((char*)iter->second->code + iter->second->host_code_size < dynarec_code)
 		return 0;
-	}
+
+	verify(iter->second->contains_code((u8*)dynarecrw));
+	return iter->second;
 }
 
 // Takes RX pointer and returns a RW pointer
@@ -143,13 +99,13 @@ RuntimeBlockInfo* bm_GetStaleBlock(void* dynarec_code)
 
 void bm_AddBlock(RuntimeBlockInfo* blk)
 {
-	all_blocks.push_back(blk);
-	if (blkmap.find(blk)!=blkmap.end())
-	{
-		printf("DUP: %08X %p %08X %p\n", (*blkmap.find(blk))->addr,(*blkmap.find(blk))->code,blk->addr,blk->code);
+	auto iter = blkmap.find((void*)blk->code);
+	if (iter != blkmap.end()) {
+		printf("DUP: %08X %p %08X %p\n", iter->second->addr, iter->second->code, blk->addr, blk->code);
 		verify(false);
 	}
-	blkmap.insert(blk);
+	blkmap[(void*)blk->code] = blk;
+	all_blocks.push_back(blk);
 
 	verify((void*)bm_GetCode(blk->addr)==(void*)ngen_FailedToFindBlock);
 	FPCA(blk->addr) = (DynarecCodeEntryPtr)CC_RW2RX(blk->code);
@@ -304,6 +260,7 @@ void bm_Periodical_1s()
 #endif
 }
 
+#if 0
 void constprop(RuntimeBlockInfo* blk);
 void bm_Rebuild()
 {
@@ -343,6 +300,7 @@ void bm_Rebuild()
 
 	rebuild_counter=30;
 }
+#endif
 
 void bm_vmem_pagefill(void** ptr, u32 size_bytes)
 {

core/hw/sh4/dyna/blockmanager.h

@@ -72,7 +72,14 @@ struct RuntimeBlockInfo: RuntimeBlockInfo_Core
 
 	u32 memops;
 	u32 linkedmemops;
-	std::map<void*, u32> memory_accesses;	// key is host pc when access is made, value is opcode id
+	// key is a host pc for a load/store in a jit block
+	// value contains information for mem-op rewriting purposes.
+	struct memop_info {
+		uint16_t opid;
+		uint8_t  rewrite_offset;
+		uint8_t  emitted_bytes;
+	};		
+	std::map<void*, memop_info> memory_accesses;
 };
 
 struct CachedBlockInfo: RuntimeBlockInfo_Core

core/linux/common.cpp

@@ -82,7 +82,10 @@ void fault_handler (int sn, siginfo_t * si, void *segfault_ctx)
 				context_to_segfault(&ctx, segfault_ctx);
 			}
 		#elif HOST_CPU == CPU_X64
-			//x64 has no rewrite support
+			else if (dyna_cde && ngen_Rewrite((unat&)ctx.pc, 0, 0))
+			{
+				context_to_segfault(&ctx, segfault_ctx);
+			}
 		#elif HOST_CPU == CPU_ARM64
 			else if (dyna_cde && ngen_Rewrite(ctx.pc, 0, 0))
 			{

core/rec-ARM64/rec_arm64.cpp

@@ -229,9 +229,6 @@ class Arm64Assembler : public MacroAssembler
 	typedef void (MacroAssembler::*Arm64Op_RROF)(const Register&, const Register&, const Operand&, enum FlagsUpdate);
 
 public:
-	Arm64Assembler() : Arm64Assembler(emit_GetCCPtr())
-	{
-	}
 	Arm64Assembler(void *buffer) : MacroAssembler((u8 *)buffer, 64 * 1024), regalloc(this)
 	{
 		call_regs.push_back(&w0);
@@ -1148,15 +1145,13 @@ class Arm64Assembler : public MacroAssembler
 		if (!_nvmem_enabled())
 			return false;
 
-		Instruction *start_instruction = GetCursorAddress<Instruction *>();
-
 		// WARNING: the rewrite code relies on having two ops before the memory access
 		// Update ngen_Rewrite (and perhaps read_memory_rewrite_size) if adding or removing code
+		Instruction *start_instruction = GetCursorAddress<Instruction *>();
 		Add(w1, *call_regs[0], sizeof(Sh4Context), LeaveFlags);
 		Bfc(w1, 29, 3);		// addr &= ~0xE0000000
-
-		//printf("direct read memory access opid %d pc %p code addr %08x\n", opid, GetCursorAddress<void *>(), this->block->addr);
-		this->block->memory_accesses[GetCursorAddress<void *>()] = (u32)opid;
+		Instruction *mem_instruction = GetCursorAddress<Instruction *>();
+		unsigned prologue_size = (char*)mem_instruction - (char*)start_instruction;
 
 		u32 size = op.flags & 0x7f;
 		switch(size)
@@ -1192,7 +1187,10 @@ class Arm64Assembler : public MacroAssembler
 			Str(x1, sh4_context_mem_operand(op.rd.reg_ptr()));
 #endif
 		}
+		unsigned code_size = (unsigned)(GetCursorAddress<char*>() - (char*)start_instruction);
 		EnsureCodeSize(start_instruction, read_memory_rewrite_size);
+		verify(code_size < 256 && prologue_size < 256);
+		this->block->memory_accesses[mem_instruction] = { (uint16_t)opid, (uint8_t)prologue_size, (uint8_t)code_size };
 
 		return true;
 	}
@@ -1228,15 +1226,13 @@ class Arm64Assembler : public MacroAssembler
 		if (!_nvmem_enabled())
 			return false;
 
-		Instruction *start_instruction = GetCursorAddress<Instruction *>();
-
 		// WARNING: the rewrite code relies on having two ops before the memory access
 		// Update ngen_Rewrite (and perhaps write_memory_rewrite_size) if adding or removing code
+		Instruction *start_instruction = GetCursorAddress<Instruction *>();
 		Add(w7, *call_regs[0], sizeof(Sh4Context), LeaveFlags);
 		Bfc(w7, 29, 3);		// addr &= ~0xE0000000
-
-		//printf("direct write memory access opid %d pc %p code addr %08x\n", opid, GetCursorAddress<void *>(), this->block->addr);
-		this->block->memory_accesses[GetCursorAddress<void *>()] = (u32)opid;
+		Instruction *mem_instruction = GetCursorAddress<Instruction *>();
+		unsigned prologue_size = (char*)mem_instruction - (char*)start_instruction;
 
 		u32 size = op.flags & 0x7f;
 		switch(size)
@@ -1257,7 +1253,11 @@ class Arm64Assembler : public MacroAssembler
 			Str(x1, MemOperand(x28, x7));
 			break;
 		}
+
+		unsigned code_size = (unsigned)(GetCursorAddress<char*>() - (char*)start_instruction);
 		EnsureCodeSize(start_instruction, write_memory_rewrite_size);
+		verify(code_size < 256 && prologue_size < 256);
+		this->block->memory_accesses[mem_instruction] = { (uint16_t)opid, (uint8_t)prologue_size, (uint8_t)code_size };
 
 		return true;
 	}
@@ -1411,7 +1411,7 @@ void ngen_Compile(RuntimeBlockInfo* block, SmcCheckEnum smc_checks, bool reset,
 {
 	verify(emit_FreeSpace() >= 16 * 1024);
 
-	compiler = new Arm64Assembler();
+	compiler = new Arm64Assembler(emit_GetCCPtr());
 
 	compiler->ngen_Compile(block, smc_checks, reset, staging, optimise);
 
@@ -1456,7 +1456,7 @@ bool ngen_Rewrite(unat& host_pc, unat, unat)
 		printf("ngen_Rewrite: memory access at %p not found (%lu entries)\n", code_ptr, block->memory_accesses.size());
 		return false;
 	}
-	u32 opid = it->second;
+	u32 opid = it->second.opid;
 	verify(opid < block->oplist.size());
 	const shil_opcode& op = block->oplist[opid];
 	Arm64Assembler *assembler = new Arm64Assembler(code_ptr - 2);	// Skip the 2 preceding ops (bic, add)