Method analyse_vertex_program

rpcs3/Emu/RSX/Program/ProgramStateCache.cpp:135–422

}

vertex_program_utils::vertex_program_metadata vertex_program_utils::analyse_vertex_program(const u32* data, u32 entry, RSXVertexProgram& dst_prog)
{
	vertex_program_utils::vertex_program_metadata result{};
	// u32 last_instruction_address = 0;
	// u32 first_instruction_address = entry;

	std::bitset<rsx::max_vertex_program_instructions> instructions_to_patch;
	std::pair<u32, u32> instruction_range{umax, 0};
	bool has_branch_instruction = false;
	std::stack<u32> call_stack;

	D3 d3{};
	D2 d2{};
	D1 d1{};
	D0 d0{};

	std::function<void(u32, bool)> walk_function = [&](u32 start, bool fast_exit)
	{
		u32 current_instruction = start;
		std::set<u32> conditional_targets;

		while (true)
		{
			ensure(current_instruction < rsx::max_vertex_program_instructions);

			if (result.instruction_mask[current_instruction])
			{
				if (!fast_exit)
				{
					// This can be harmless if a dangling RET was encountered before.
					// This can also be legal in case of BRB...BRI loops since BRIs are conditional. Might just be a loop with exit cond.
					rsx_log.warning("vp_analyser: Possible infinite loop detected");
				}

				// There is never any reason to continue scanning after self-intersecting on the control-flow tree.
				break;
			}

			const auto instruction = v128::loadu(&data[current_instruction * 4]);
			d1.HEX = instruction._u32[1];
			d2.HEX = instruction._u32[2];
			d3.HEX = instruction._u32[3];

			// Touch current instruction
			result.instruction_mask[current_instruction] = true;
			instruction_range.first = std::min(current_instruction, instruction_range.first);
			instruction_range.second = std::max(current_instruction, instruction_range.second);

			// Whether to check if the current instruction references an input stream
			auto input_attribute_ref = [&]()
			{
				if (!d1.input_src)
				{
					// It is possible to reference ATTR0, but this is mandatory anyway. No need to explicitly test for it
					return;
				}

				const auto ref_mask = (1u << d1.input_src);