PPU LLVM: Recycle identical functions

Author: elad335

rpcs3/Emu/Cell/PPUAnalyser.cpp

@@ -2046,6 +2046,113 @@ bool ppu_module::analyse(u32 lib_toc, u32 entry, const u32 sec_end, const std::b
 	}
 
 	ppu_log.notice("Block analysis: %zu blocks (%zu enqueued)", funcs.size(), block_queue.size());
+
+	std::unordered_map<std::string_view, std::pair<u32, u32>> duplicate_data_map;
+	duplicate_map.clear();
+
+	for (auto& func : funcs)
+	{
+		if (func.size == 0 || func.size > 10000u)
+		{
+			continue;
+		}
+
+		auto& data = duplicate_data_map[std::string_view{get_ptr<char>(func.addr), func.size}];
+
+		const usz count = data.first;
+
+		if (!count)
+		{
+			data.first++;
+			data.second = func.addr;
+			continue;
+		}
+		
+		if (!data.second)
+		{
+			continue;
+		}
+
+		if (count == 1)
+		{
+			const u32 faddr = func.addr;
+			const u32 fend = func.addr + func.size;
+
+			bool fail = false;
+
+			for (const auto& [addr, size] : func.blocks)
+			{
+				if (size == 0)
+				{
+					continue;
+				}
+
+				auto i_ptr = ensure(get_ptr<u32>(addr));
+
+				for (u32 i = addr; i < addr + size; i += 4, i_ptr++)
+				{
+					const ppu_opcode_t op{*i_ptr};
+					const auto itype = s_ppu_itype.decode(op.opcode);
+
+					if (itype != ppu_itype::BC && itype != ppu_itype::B)
+					{
+						continue;
+					}
+
+					const u32 target = (op.aa ? 0 : i) + (itype == ppu_itype::B ? +op.bt24 : +op.bt14);
+
+					if (target >= fend || target < faddr)
+					{
+						fail = true;
+						break;
+					}
+				}
+
+				if (fail)
+				{
+					break;
+				}
+			}
+
+			if (fail)
+			{
+				data.first = 1;
+				data.second = 0;
+				continue;
+			}
+		}
+
+		data.first++;
+
+		// Choose the lowest function as the source
+		data.second = std::min<u32>(data.second, func.addr);
+	}
+
+	usz dups_count = 0;
+
+	for (auto& func : funcs)
+	{
+		if (func.size == 0 || func.size > 10000u)
+		{
+			continue;
+		}
+
+		const auto data = ::at32(duplicate_data_map, std::string_view{get_ptr<char>(func.addr), func.size});
+
+		if (data.first > 1)
+		{
+			dups_count++;
+
+			if (func.addr != data.second)
+			{
+				duplicate_map[func.addr] = data.second;
+			}
+
+			ppu_log.trace("Found PPU function duplicate: func 0x%x (%d times)", data.second, data.first);
+		}
+	}
+
+	ppu_log.success("Function duplication count: %d/%d (%g%)", dups_count, duplicate_data_map.size(), dups_count * 100.0 / duplicate_data_map.size());
 	return true;
 }
 

rpcs3/Emu/Cell/PPUAnalyser.h

@@ -95,6 +95,7 @@ struct ppu_module
 	std::vector<ppu_function> funcs{};
 	std::deque<std::shared_ptr<void>> allocations;
 	std::map<u32, u32> addr_to_seg_index;
+	std::unordered_map<u32, u32> duplicate_map;
 
 	// Copy info without functions
 	void copy_part(const ppu_module& info)

rpcs3/Emu/Cell/PPUThread.cpp

@@ -4146,7 +4146,7 @@ extern void ppu_precompile(std::vector<std::string>& dir_queue, std::vector<ppu_
 			}
 
 			ppu_log.notice("Failed to precompile '%s' (prx: %s, ovl: %s): Attempting tratment as executable file", path, prx_err, ovl_err);
-			possible_exec_file_paths.push(path, offset, file_size);
+			possible_exec_file_paths.push(file_queue[func_i]);
 			inc_fdone = 0;
 		}
 	});
@@ -5054,7 +5054,14 @@ bool ppu_initialize(const ppu_module& info, bool check_only, u64 file_size)
 			break;
 		}
 
-		const auto name = fmt::format("__0x%x", func.addr - reloc);
+		u32 og_func = func.addr;
+
+		if (auto it = info.duplicate_map.find(func.addr); it != info.duplicate_map.end())
+		{
+			og_func = it->second;
+		}
+
+		const auto name = fmt::format("__0x%x", og_func - reloc);
 
 		// Try to locate existing function if it is not the first time
 		const auto addr = is_first ? ensure(reinterpret_cast<ppu_intrp_func_t>(jit->get(name)))
@@ -5194,6 +5201,15 @@ static void ppu_initialize2(jit_compiler& jit, const ppu_module& module_part, co
 
 			if (module_part.funcs[fi].size)
 			{
+				const u32 faddr = module_part.funcs[fi].addr;
+				auto it = module_part.duplicate_map.find(faddr);
+
+				if (it != module_part.duplicate_map.end() && it->second != faddr)
+				{
+					ppu_log.trace("LLVM: Function 0x%x was skipped (duplicate)", faddr);
+					continue;
+				}
+
 				// Translate
 				if (const auto func = translator.Translate(module_part.funcs[fi]))
 				{

rpcs3/Emu/Cell/PPUTranslator.cpp

@@ -419,7 +419,15 @@ void PPUTranslator::CallFunction(u64 target, Value* indirect)
 
 			if (!indirect)
 			{
-				callee = m_module->getOrInsertFunction(fmt::format("__0x%x", target_last - base), type);
+				const auto it = m_info.duplicate_map.find(target_last);
+				const u32 first_func = it == m_info.duplicate_map.end() ? target_last : it->second;
+
+				if (base)
+				{
+					ensure(first_func >= base && target_last >= base);
+				}
+
+				callee = m_module->getOrInsertFunction(fmt::format("__0x%x", first_func - base), type);
 				cast<Function>(callee.getCallee())->setCallingConv(CallingConv::GHC);
 			}
 		}