Now pass in remap candidates to the spirv-simulator

Author: per-mathisen-arm

src/execute_commands.cpp

@@ -25,7 +25,24 @@ static bool run_spirv(lava_file_reader& reader, const trackedpipeline& pipeline_
 			const uint32_t buffer_index = access.buffer_data->index;
 			suballoc_location loc = reader.parent->allocator.find_buffer_memory(buffer_index);
 			std::byte* base = (std::byte*)loc.memory;
-			set_bindings[binding_pair.first] = base + access.offset;
+			std::byte* binding_ptr = base + access.offset;
+			set_bindings[binding_pair.first] = binding_ptr;
+			if (!access.buffer_data->candidates.empty() && access.size != 0)
+			{
+				const VkDeviceSize binding_start = access.offset;
+				const VkDeviceSize binding_end = access.offset + access.size;
+				std::vector<SPIRVSimulator::PhysicalAddressCandidate>* candidate_list = nullptr;
+				for (const auto& candidate : access.buffer_data->candidates)
+				{
+					if (candidate.offset < binding_start || candidate.offset >= binding_end) continue;
+					if (!candidate_list) candidate_list = &inputs.candidates[static_cast<const void*>(binding_ptr)];
+					SPIRVSimulator::PhysicalAddressCandidate sim_candidate;
+					sim_candidate.address = candidate.address;
+					sim_candidate.offset = candidate.offset - binding_start;
+					sim_candidate.payload = access.buffer_data;
+					candidate_list->push_back(sim_candidate);
+				}
+			}
 		}
 	}
 	shader_data.calls++;

src/hardcode_read.cpp

@@ -1614,7 +1614,7 @@ VKAPI_ATTR void retrace_vkUpdateBufferTRACETOOLTEST(lava_file_reader& reader)
 	memcpy(ptr, info.pData, info.dataSize);
 	if (reader.parent->remap_scan)
 	{
-		reader.parent->find_address_candidates(tbuf, info.dataSize, info.pData, reader.current);
+		reader.parent->find_address_candidates(tbuf, info.dataSize, info.pData, info.dstOffset, reader.current);
 		if (ar) assert(tbuf.candidates.size() >= ar->count);
 	}
 	mem_unmap(reader, device, loc, ar, ptr);

src/lavatube.h

@@ -236,7 +236,7 @@ struct trackedshadermodule : trackable
 struct remap_candidate
 {
 	VkDeviceAddress address; // contained value
-	VkDeviceSize offset; // the offset of the candidate
+	VkDeviceSize offset; // byte offset from start of buffer
 	change_source source; // last write to memory area from which we came
 
 	remap_candidate(VkDeviceAddress a, VkDeviceSize b, change_source c) { address = a; offset = b; source = c; }

src/read.cpp

@@ -282,20 +282,21 @@ void lava_reader::dump_info()
 	}
 }
 
-uint32_t lava_reader::find_address_candidates(trackedbuffer& buffer_data, VkDeviceSize size, const void* ptr, change_source source) const
+uint32_t lava_reader::find_address_candidates(trackedbuffer& buffer_data, VkDeviceSize size, const void* ptr, VkDeviceSize base_offset, change_source source) const
 {
 	buffer_data.self_test();
+	const char* base_ptr = (const char*)ptr;
 	// Search on a 4-byte aligned boundary
 	if ((uintptr_t)ptr % sizeof(uint32_t) != 0)
 	{
 		ptr = (const void*)aligned_size((uintptr_t)ptr, sizeof(uint32_t));
 	}
 	const uint32_t* start = (const uint32_t*)ptr;
-	const uint32_t* end = (const uint32_t*)((char*)ptr + size);
+	const uint32_t* end = (const uint32_t*)(base_ptr + size);
 	uint32_t found = 0;
 	for (const uint32_t* p = start; p + 2 <= end; p++)
 	{
-		const VkDeviceSize offset = (VkDeviceSize)p;
+		const VkDeviceSize offset = base_offset + (VkDeviceSize)((const char*)p - base_ptr);
 		const VkDeviceAddress candidate = *((uintptr_t*)p); // read full 64bit word at current position
 
 		// Do we already have a candidate for this address?

src/read.h

@@ -65,9 +65,10 @@ class lava_reader
 	std::vector<std::atomic_uint_fast32_t>* thread_call_numbers; // thread local call numbers
 
 	// Use the remapping lists below to find possible candidates for remapping in a buffer.
-	// Return the number of candidates found. Will search from 'ptr', which is a mapped buffer,
-	// a 'size' sized window. Caller must make sure access is thread safe.
-	uint32_t find_address_candidates(trackedbuffer& buffer_data, VkDeviceSize size, const void* ptr, change_source source) const;
+	// Return the number of candidates found. Will search from 'ptr' over a 'size' sized window.
+	// base_offset is the byte offset from the start of the buffer to 'ptr'.
+	// Caller must make sure access is thread safe.
+	uint32_t find_address_candidates(trackedbuffer& buffer_data, VkDeviceSize size, const void* ptr, VkDeviceSize base_offset, change_source source) const;
 
 	// This is thread safe since we allocate it all before threading begins.
 	address_remapper<trackedobject> device_address_remapping;
@@ -161,7 +162,8 @@ class lava_file_reader : public file_reader
 			if (buf && size)
 			{
 				memcpy(ptr, uptr, size);
-				parent->find_address_candidates(buffer_data, size, ptr, current);
+				const VkDeviceSize base_offset = (VkDeviceSize)(ptr - buf);
+				parent->find_address_candidates(buffer_data, size, ptr, base_offset, current);
 			}
 			read_position += size;
 			ptr += size;