From cda9d8450dd0d15f5f017a47aa3ebb778ea9a2da Mon Sep 17 00:00:00 2001 From: Mark Young Date: Wed, 13 Jan 2016 13:47:16 -0700 Subject: Win32: Get 32-bit Windows build working Also includes changes to allow simultaneous 32-bit and 64-bit Windows builds. --- layers/draw_state.cpp | 42 ++++++++++++++++++------------------- layers/draw_state.h | 2 +- layers/mem_tracker.cpp | 53 ++++++++++++++++++++++++----------------------- layers/object_tracker.h | 50 ++++++++++++++++++++++---------------------- layers/screenshot.cpp | 2 +- layers/vk_layer_logging.h | 2 +- 6 files changed, 76 insertions(+), 75 deletions(-) (limited to 'layers') diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp index d50fbaa0..11972f76 100644 --- a/layers/draw_state.cpp +++ b/layers/draw_state.cpp @@ -2235,15 +2235,15 @@ static VkBool32 dsUpdate(layer_data* my_data, VkDevice device, uint32_t descript binding = pWDS[i].dstBinding; // Make sure that layout being updated has the binding being updated if (pLayout->bindings.find(binding) == pLayout->bindings.end()) { - skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, reinterpret_cast(ds), __LINE__, DRAWSTATE_INVALID_UPDATE_INDEX, "DS", - "Descriptor Set %" PRIu64 " does not have binding to match update binding %u for update type %s!", reinterpret_cast(ds), binding, string_VkStructureType(pUpdate->sType)); + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, (uint64_t)(ds), __LINE__, DRAWSTATE_INVALID_UPDATE_INDEX, "DS", + "Descriptor Set %" PRIu64 " does not have binding to match update binding %u for update type %s!", (uint64_t)(ds), binding, string_VkStructureType(pUpdate->sType)); } else { // Next verify that update falls within size of given binding endIndex = getUpdateEndIndex(my_data, device, pLayout, binding, pWDS[i].dstArrayElement, pUpdate); if (getBindingEndIndex(pLayout, binding) < endIndex) { pLayoutCI = &pLayout->createInfo; string DSstr = vk_print_vkdescriptorsetlayoutcreateinfo(pLayoutCI, "{DS} "); - skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, (uint64_t) ds, __LINE__, DRAWSTATE_DESCRIPTOR_UPDATE_OUT_OF_BOUNDS, "DS", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, (uint64_t)(ds), __LINE__, DRAWSTATE_DESCRIPTOR_UPDATE_OUT_OF_BOUNDS, "DS", "Descriptor update type of %s is out of bounds for matching binding %u in Layout w/ CI:\n%s!", string_VkStructureType(pUpdate->sType), binding, DSstr.c_str()); } else { // TODO : should we skip update on a type mismatch or force it? uint32_t startIndex; @@ -2257,7 +2257,7 @@ static VkBool32 dsUpdate(layer_data* my_data, VkDevice device, uint32_t descript GENERIC_HEADER* pNewNode = NULL; skipCall |= shadowUpdateNode(my_data, device, pUpdate, &pNewNode); if (NULL == pNewNode) { - skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, (uint64_t) ds, __LINE__, DRAWSTATE_OUT_OF_MEMORY, "DS", + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, (uint64_t)(ds), __LINE__, DRAWSTATE_OUT_OF_MEMORY, "DS", "Out of memory while attempting to allocate UPDATE struct in vkUpdateDescriptors()"); } else { // Insert shadow node into LL of updates for this set @@ -2708,7 +2708,7 @@ static VkBool32 printDSConfig(layer_data* my_data, const VkCommandBuffer cb) LAYOUT_NODE* pLayout = pSet->pLayout; // Print layout details skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT_EXT, (VkDebugReportObjectTypeEXT) 0, 0, __LINE__, DRAWSTATE_NONE, "DS", - "Layout #%u, (object %#" PRIxLEAST64 ") for DS %#" PRIxLEAST64 ".", index+1, reinterpret_cast(pLayout->layout), reinterpret_cast(pSet->set)); + "Layout #%u, (object %#" PRIxLEAST64 ") for DS %#" PRIxLEAST64 ".", index+1, (uint64_t)(pLayout->layout), (uint64_t)(pSet->set)); sprintf(prefix, " [L%u] ", index); string DSLstr = vk_print_vkdescriptorsetlayoutcreateinfo(&pLayout->createInfo, prefix).c_str(); skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT_EXT, (VkDebugReportObjectTypeEXT) 0, 0, __LINE__, DRAWSTATE_NONE, "DS", @@ -3076,7 +3076,7 @@ VkBool32 ValidateCmdBufImageLayouts(VkCommandBuffer cmdBuffer) { auto image_data = dev_data->imageLayoutMap.find(cb_image_data.first); if (image_data == dev_data->imageLayoutMap.end()) { skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0, __LINE__, DRAWSTATE_INVALID_IMAGE_LAYOUT, "DS", - "Cannot submit cmd buffer using deleted image %" PRIu64 ".", reinterpret_cast(cb_image_data.first)); + "Cannot submit cmd buffer using deleted image %" PRIu64 ".", (uint64_t)(cb_image_data.first)); } else { if (dev_data->imageLayoutMap[cb_image_data.first]->layout != cb_image_data.second.initialLayout) { skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0, __LINE__, DRAWSTATE_INVALID_IMAGE_LAYOUT, "DS", @@ -3112,8 +3112,8 @@ VkBool32 validateAndIncrementResources(layer_data* my_data, GLOBAL_CB_NODE* pCB) for (auto buffer : drawDataElement.buffers) { auto buffer_data = my_data->bufferMap.find(buffer); if (buffer_data == my_data->bufferMap.end()) { - skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, reinterpret_cast(buffer), __LINE__, DRAWSTATE_INVALID_BUFFER, "DS", - "Cannot submit cmd buffer using deleted buffer %" PRIu64 ".", reinterpret_cast(buffer)); + skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, (uint64_t)(buffer), __LINE__, DRAWSTATE_INVALID_BUFFER, "DS", + "Cannot submit cmd buffer using deleted buffer %" PRIu64 ".", (uint64_t)(buffer)); } else { buffer_data->second.in_use.fetch_add(1); } @@ -3225,7 +3225,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit(VkQueue queue, uint } else { skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0, __LINE__, DRAWSTATE_QUEUE_FORWARD_PROGRESS, "DS", "Queue %#" PRIx64 " is waiting on semaphore %#" PRIx64 " that has no way to be signaled.", - reinterpret_cast(queue), reinterpret_cast(submit->pWaitSemaphores[i])); + reinterpret_cast(queue), (uint64_t)(submit->pWaitSemaphores[i])); } } for (uint32_t i=0; i < submit->signalSemaphoreCount; ++i) { @@ -3284,7 +3284,7 @@ VkBool32 cleanInFlightCmdBuffer(layer_data* my_data, VkCommandBuffer cmdBuffer) if (my_data->eventMap[event].needsSignaled) { skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, 0, 0, DRAWSTATE_INVALID_QUERY, "DS", "Cannot get query results on queryPool %" PRIu64 " with index %d which was guarded by unsignaled event %" PRIu64 ".", - reinterpret_cast(queryEventsPair.first.pool), queryEventsPair.first.index, reinterpret_cast(event)); + (uint64_t)(queryEventsPair.first.pool), queryEventsPair.first.index, (uint64_t)(event)); } } } @@ -3436,7 +3436,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults(VkDevice device, VkQueryPoo if (queryEventElement == pCB->waitedEventsBeforeQueryReset.end()) { skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, 0, __LINE__, DRAWSTATE_INVALID_QUERY, "DS", "Cannot get query results on queryPool %" PRIu64 " with index %d which is in flight.", - reinterpret_cast(queryPool), firstQuery + i); + (uint64_t)(queryPool), firstQuery + i); } else { for (auto event : queryEventElement->second) { dev_data->eventMap[event].needsSignaled = true; @@ -3454,18 +3454,18 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults(VkDevice device, VkQueryPoo if (!(((flags & VK_QUERY_RESULT_PARTIAL_BIT) || (flags & VK_QUERY_RESULT_WAIT_BIT)) && make_available)) { skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, 0, __LINE__, DRAWSTATE_INVALID_QUERY, "DS", "Cannot get query results on queryPool %" PRIu64 " with index %d which is unavailable.", - reinterpret_cast(queryPool), firstQuery + i); + (uint64_t)(queryPool), firstQuery + i); } // Unavailable } else if (queryToStateElement != dev_data->queryToStateMap.end() && !queryToStateElement->second) { skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, 0, __LINE__, DRAWSTATE_INVALID_QUERY, "DS", "Cannot get query results on queryPool %" PRIu64 " with index %d which is unavailable.", - reinterpret_cast(queryPool), firstQuery + i); + (uint64_t)(queryPool), firstQuery + i); // Unitialized } else if (queryToStateElement == dev_data->queryToStateMap.end()) { skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, 0, __LINE__, DRAWSTATE_INVALID_QUERY, "DS", "Cannot get query results on queryPool %" PRIu64 " with index %d which is uninitialized.", - reinterpret_cast(queryPool), firstQuery + i); + (uint64_t)(queryPool), firstQuery + i); } } if (skip_call) @@ -3477,12 +3477,12 @@ VkBool32 validateIdleBuffer(const layer_data* my_data, VkBuffer buffer) { VkBool32 skip_call = VK_FALSE; auto buffer_data = my_data->bufferMap.find(buffer); if (buffer_data == my_data->bufferMap.end()) { - skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, reinterpret_cast(buffer), __LINE__, DRAWSTATE_DOUBLE_DESTROY, "DS", - "Cannot free buffer %" PRIxLEAST64 " that has not been allocated.", reinterpret_cast(buffer)); + skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, (uint64_t)(buffer), __LINE__, DRAWSTATE_DOUBLE_DESTROY, "DS", + "Cannot free buffer %" PRIxLEAST64 " that has not been allocated.", (uint64_t)(buffer)); } else { if (buffer_data->second.in_use.load()) { - skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, reinterpret_cast(buffer), __LINE__, DRAWSTATE_OBJECT_INUSE, "DS", - "Cannot free buffer %" PRIxLEAST64 " that is in use by a command buffer.", reinterpret_cast(buffer)); + skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, (uint64_t)(buffer), __LINE__, DRAWSTATE_OBJECT_INUSE, "DS", + "Cannot free buffer %" PRIxLEAST64 " that is in use by a command buffer.", (uint64_t)(buffer)); } } return skip_call; @@ -4238,7 +4238,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline(VkCommandBuffer com } else { skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, (uint64_t) pipeline, __LINE__, DRAWSTATE_INVALID_PIPELINE, "DS", - "Attempt to bind Pipeline %#" PRIxLEAST64 " that doesn't exist!", reinterpret_cast(pipeline)); + "Attempt to bind Pipeline %#" PRIxLEAST64 " that doesn't exist!", (uint64_t)(pipeline)); } } if (VK_FALSE == skipCall) @@ -5310,7 +5310,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults(VkCommandBu QueryObject query = {queryPool, firstQuery + i}; if(!pCB->queryToStateMap[query]) { skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, DRAWSTATE_INVALID_QUERY, "DS", - "Requesting a copy from query to buffer with invalid query: queryPool %" PRIu64 ", index %d", reinterpret_cast(queryPool), firstQuery + i); + "Requesting a copy from query to buffer with invalid query: queryPool %" PRIu64 ", index %d", (uint64_t)(queryPool), firstQuery + i); } } if (pCB->state == CB_RECORDING) { @@ -6026,7 +6026,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse( } else { skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0, __LINE__, DRAWSTATE_QUEUE_FORWARD_PROGRESS, "DS", "Queue %#" PRIx64 " is waiting on semaphore %#" PRIx64 " that has no way to be signaled.", - reinterpret_cast(queue), reinterpret_cast(bindInfo.pWaitSemaphores[i])); + reinterpret_cast(queue), (uint64_t)(bindInfo.pWaitSemaphores[i])); } } for (uint32_t i=0; i < bindInfo.signalSemaphoreCount; ++i) { diff --git a/layers/draw_state.h b/layers/draw_state.h index dca0d8b5..903f678d 100755 --- a/layers/draw_state.h +++ b/layers/draw_state.h @@ -469,7 +469,7 @@ namespace std { template <> struct hash { size_t operator()(QueryObject query) const throw() { - return hash()(reinterpret_cast(query.pool)) ^ hash()(query.index); + return hash()((uint64_t)(query.pool)) ^ hash()(query.index); } }; } diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp index a29a6a4d..6bc775ea 100644 --- a/layers/mem_tracker.cpp +++ b/layers/mem_tracker.cpp @@ -469,19 +469,19 @@ add_mem_obj_info( static VkBool32 validate_memory_is_valid(layer_data *my_data, VkDeviceMemory mem, const char* functionName, VkImage image = VK_NULL_HANDLE) { if (mem == MEMTRACKER_SWAP_CHAIN_IMAGE_KEY) { - MT_OBJ_BINDING_INFO* pBindInfo = get_object_binding_info(my_data, reinterpret_cast(image), VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT); + MT_OBJ_BINDING_INFO* pBindInfo = get_object_binding_info(my_data, (uint64_t)(image), VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT); if (pBindInfo && !pBindInfo->valid) { return log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, - reinterpret_cast(mem), __LINE__, MEMTRACK_INVALID_USAGE_FLAG, "MEM", - "%s: Cannot read invalid swapchain image %" PRIx64 ", please fill the memory before using.", functionName, reinterpret_cast(image)); + (uint64_t)(mem), __LINE__, MEMTRACK_INVALID_USAGE_FLAG, "MEM", + "%s: Cannot read invalid swapchain image %" PRIx64 ", please fill the memory before using.", functionName, (uint64_t)(image)); } } else { MT_MEM_OBJ_INFO *pMemObj = get_mem_obj_info(my_data, mem); if (pMemObj && !pMemObj->valid) { return log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, - reinterpret_cast(mem), __LINE__, MEMTRACK_INVALID_USAGE_FLAG, "MEM", - "%s: Cannot read invalid memory %" PRIx64 ", please fill the memory before using.", functionName, reinterpret_cast(mem)); + (uint64_t)(mem), __LINE__, MEMTRACK_INVALID_USAGE_FLAG, "MEM", + "%s: Cannot read invalid memory %" PRIx64 ", please fill the memory before using.", functionName, (uint64_t)(mem)); } } return false; @@ -489,7 +489,7 @@ static VkBool32 validate_memory_is_valid(layer_data *my_data, VkDeviceMemory mem static void set_memory_valid(layer_data *my_data, VkDeviceMemory mem, bool valid, VkImage image = VK_NULL_HANDLE) { if (mem == MEMTRACKER_SWAP_CHAIN_IMAGE_KEY) { - MT_OBJ_BINDING_INFO* pBindInfo = get_object_binding_info(my_data, reinterpret_cast(image), VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT); + MT_OBJ_BINDING_INFO* pBindInfo = get_object_binding_info(my_data, (uint64_t)(image), VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT); if (pBindInfo) { pBindInfo->valid = valid; } @@ -967,7 +967,7 @@ print_mem_list( log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, 0, __LINE__, MEMTRACK_NONE, "MEM", " ===MemObjInfo at %p===", (void*)pInfo); log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, 0, __LINE__, MEMTRACK_NONE, "MEM", - " Mem object: %#" PRIxLEAST64, reinterpret_cast(pInfo->mem)); + " Mem object: %#" PRIxLEAST64, (uint64_t)(pInfo->mem)); log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, 0, __LINE__, MEMTRACK_NONE, "MEM", " Ref Count: %u", pInfo->refCount); if (0 != pInfo->allocInfo.allocationSize) { @@ -1032,7 +1032,7 @@ printCBList( continue; for (list::iterator it = pCBInfo->pMemObjList.begin(); it != pCBInfo->pMemObjList.end(); ++it) { log_msg(my_data->report_data, VK_DEBUG_REPORT_INFO_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, 0, __LINE__, MEMTRACK_NONE, "MEM", - " Mem obj %" PRIu64, reinterpret_cast(*it)); + " Mem obj %" PRIu64, (uint64_t)(*it)); } } } @@ -1233,7 +1233,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDevice( // Valid Usage: All child objects created on device must have been destroyed prior to destroying device skipCall |= log_msg(my_device_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, (uint64_t) pInfo->mem, __LINE__, MEMTRACK_MEMORY_LEAK, "MEM", "Mem Object %" PRIu64 " has not been freed. You should clean up this memory by calling " - "vkFreeMemory(%" PRIu64 ") prior to vkDestroyDevice().", reinterpret_cast(pInfo->mem), reinterpret_cast(pInfo->mem)); + "vkFreeMemory(%" PRIu64 ") prior to vkDestroyDevice().", (uint64_t)(pInfo->mem), (uint64_t)(pInfo->mem)); } } } @@ -1552,9 +1552,10 @@ initializeAndTrackMemory( if (size == VK_WHOLE_SIZE) { size = mem_element->second.allocInfo.allocationSize; } - mem_element->second.pData = malloc(2 * size); - memset(mem_element->second.pData, NoncoherentMemoryFillValue, 2 * size); - *ppData = static_cast(mem_element->second.pData) + (size / 2); + size_t convSize = (size_t)(size); + mem_element->second.pData = malloc(2 * convSize); + memset(mem_element->second.pData, NoncoherentMemoryFillValue, 2 * convSize); + *ppData = static_cast(mem_element->second.pData) + (convSize / 2); } } } @@ -1652,14 +1653,14 @@ validateAndCopyNoncoherentMemoryToDriver( __LINE__, MEMTRACK_INVALID_MAP, "MEM", "Memory overflow was detected on mem obj %" PRIxLEAST64, (uint64_t)pMemRanges[i].memory); } } - memcpy(mem_element->second.pDriverData, static_cast(data + half_size), size); + memcpy(mem_element->second.pDriverData, static_cast(data + (size_t)(half_size)), (size_t)(size)); } } } return skipCall; } -VK_LAYER_EXPORT VkResult vkFlushMappedMemoryRanges( +VK_LAYER_EXPORT VkResult VKAPI_CALL vkFlushMappedMemoryRanges( VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange *pMemRanges) @@ -1676,7 +1677,7 @@ VK_LAYER_EXPORT VkResult vkFlushMappedMemoryRanges( return result; } -VK_LAYER_EXPORT VkResult vkInvalidateMappedMemoryRanges( +VK_LAYER_EXPORT VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges( VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange *pMemRanges) @@ -1797,7 +1798,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory( VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; loader_platform_thread_lock_mutex(&globalLock); // Track objects tied to memory - uint64_t buffer_handle = reinterpret_cast(buffer); + uint64_t buffer_handle = (uint64_t)(buffer); VkBool32 skipCall = set_mem_binding(my_data, device, mem, buffer_handle, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, "vkBindBufferMemory"); add_object_binding_info(my_data, buffer_handle, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, mem); { @@ -1823,7 +1824,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory( VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; loader_platform_thread_lock_mutex(&globalLock); // Track objects tied to memory - uint64_t image_handle = reinterpret_cast(image); + uint64_t image_handle = (uint64_t)(image); VkBool32 skipCall = set_mem_binding(my_data, device, mem, image_handle, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, "vkBindImageMemory"); add_object_binding_info(my_data, image_handle, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, mem); { @@ -2210,7 +2211,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool( if (VK_FALSE == commandBufferComplete) { skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, (uint64_t)(*it), __LINE__, MEMTRACK_RESET_CB_WHILE_IN_FLIGHT, "MEM", "Destroying Command Pool 0x%" PRIxLEAST64 " before " - "its command buffer (0x%" PRIxLEAST64 ") has completed.", reinterpret_cast(commandPool), + "its command buffer (0x%" PRIxLEAST64 ") has completed.", (uint64_t)(commandPool), reinterpret_cast(*it)); } } @@ -2378,7 +2379,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers( VkBool32 skip_call = false; for (uint32_t i = 0; i < bindingCount; ++i) { VkDeviceMemory mem; - skip_call |= get_mem_binding_from_object(my_data, commandBuffer, reinterpret_cast(pBuffers[i]), + skip_call |= get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)(pBuffers[i]), VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, &mem); auto cb_data = my_data->cbMap.find(commandBuffer); if (cb_data != my_data->cbMap.end()) { @@ -2399,7 +2400,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer( { layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); VkDeviceMemory mem; - VkBool32 skip_call = get_mem_binding_from_object(my_data, commandBuffer, reinterpret_cast(buffer), VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, &mem); + VkBool32 skip_call = get_mem_binding_from_object(my_data, commandBuffer, (uint64_t)(buffer), VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, &mem); auto cb_data = my_data->cbMap.find(commandBuffer); if (cb_data != my_data->cbMap.end()) { std::function function = [=]() { return validate_memory_is_valid(my_data, mem, "vkCmdBindIndexBuffer()"); }; @@ -2953,7 +2954,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR( if (mismatch) { // TODO: Verify against Valid Usage section of extension log_msg(my_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, (uint64_t) swapchain, __LINE__, MEMTRACK_NONE, "SWAP_CHAIN", - "vkGetSwapchainInfoKHR(%" PRIu64 ", VK_SWAP_CHAIN_INFO_TYPE_PERSISTENT_IMAGES_KHR) returned mismatching data", reinterpret_cast(swapchain)); + "vkGetSwapchainInfoKHR(%" PRIu64 ", VK_SWAP_CHAIN_INFO_TYPE_PERSISTENT_IMAGES_KHR) returned mismatching data", (uint64_t)(swapchain)); } } } @@ -3000,7 +3001,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR( for (uint32_t i = 0; i < pPresentInfo->swapchainCount; ++i) { MT_SWAP_CHAIN_INFO *pInfo = my_data->swapchainMap[pPresentInfo->pSwapchains[i]]; VkImage image = pInfo->images[pPresentInfo->pImageIndices[i]]; - skip_call |= get_mem_binding_from_object(my_data, queue, reinterpret_cast(image), VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, &mem); + skip_call |= get_mem_binding_from_object(my_data, queue, (uint64_t)(image), VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, &mem); skip_call |= validate_memory_is_valid(my_data, mem, "vkQueuePresentKHR()", image); } if (!skip_call) { @@ -3067,7 +3068,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer( continue; } MT_FB_ATTACHMENT_INFO fb_info; - get_mem_binding_from_object(my_data, device, reinterpret_cast(view_data->second.image), VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, &fb_info.mem); + get_mem_binding_from_object(my_data, device, (uint64_t)(view_data->second.image), VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, &fb_info.mem); fb_info.image = view_data->second.image; my_data->fbMap[*pFramebuffer].attachments.push_back(fb_info); loader_platform_thread_unlock_mutex(&globalLock); @@ -3154,7 +3155,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass( MT_PASS_INFO& pass_info = pass_data->second; pass_info.fb = pRenderPassBegin->framebuffer; auto cb_data = my_data->cbMap.find(cmdBuffer); - for (int i = 0; i < pass_info.attachments.size(); ++i) { + for (size_t i = 0; i < pass_info.attachments.size(); ++i) { MT_FB_ATTACHMENT_INFO& fb_info = my_data->fbMap[pass_info.fb].attachments[i]; if (pass_info.attachments[i].load_op == VK_ATTACHMENT_LOAD_OP_CLEAR) { if (cb_data != my_data->cbMap.end()) { @@ -3165,7 +3166,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass( if (attachment_layout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL || attachment_layout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL) { skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, - reinterpret_cast(pRenderPassBegin->renderPass), __LINE__, MEMTRACK_INVALID_LAYOUT, "MEM", + (uint64_t)(pRenderPassBegin->renderPass), __LINE__, MEMTRACK_INVALID_LAYOUT, "MEM", "Cannot clear attachment %d with invalid first layout %d.", pass_info.attachments[i].attachment, attachment_layout); } } else if (pass_info.attachments[i].load_op == VK_ATTACHMENT_LOAD_OP_DONT_CARE) { @@ -3205,7 +3206,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass( auto pass_data = my_data->passMap.find(cb_data->second.pass); if (pass_data != my_data->passMap.end()) { MT_PASS_INFO& pass_info = pass_data->second; - for (int i = 0; i < pass_info.attachments.size(); ++i) { + for (size_t i = 0; i < pass_info.attachments.size(); ++i) { MT_FB_ATTACHMENT_INFO& fb_info = my_data->fbMap[pass_info.fb].attachments[i]; if (pass_info.attachments[i].store_op == VK_ATTACHMENT_STORE_OP_STORE) { if (cb_data != my_data->cbMap.end()) { diff --git a/layers/object_tracker.h b/layers/object_tracker.h index b1b550da..caa6573b 100644 --- a/layers/object_tracker.h +++ b/layers/object_tracker.h @@ -390,7 +390,7 @@ validate_status( char str[1024]; log_msg(mdd(dispatchable_object), msg_flags, pNode->objType, vkObj, __LINE__, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", "OBJECT VALIDATION WARNING: %s object 0x%" PRIxLEAST64 ": %s", string_VkObjectType(objType), - reinterpret_cast(vkObj), fail_msg); + static_cast(vkObj), fail_msg); return VK_FALSE; } return VK_TRUE; @@ -399,7 +399,7 @@ validate_status( // If we do not find it print an error log_msg(mdd(dispatchable_object), msg_flags, (VkObjectType) 0, vkObj, __LINE__, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", "Unable to obtain status for non-existent object 0x%" PRIxLEAST64 " of %s type", - reinterpret_cast(vkObj), string_VkObjectType(objType)); + static_cast(vkObj), string_VkObjectType(objType)); return VK_FALSE; } } @@ -488,15 +488,15 @@ static VkBool32 set_status(VkQueue dispatchable_object, VkFence object, VkDebugR { VkBool32 skipCall = VK_FALSE; if (object != VK_NULL_HANDLE) { - if (VkFenceMap.find(reinterpret_cast(object)) != VkFenceMap.end()) { - OBJTRACK_NODE* pNode = VkFenceMap[reinterpret_cast(object)]; + if (VkFenceMap.find((uint64_t)(object)) != VkFenceMap.end()) { + OBJTRACK_NODE* pNode = VkFenceMap[(uint64_t)(object)]; pNode->status |= status_flag; } else { // If we do not find it print an error skipCall |= log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT) 0, (uint64_t) object, __LINE__, OBJTRACK_NONE, "OBJTRACK", "Unable to set status for non-existent object 0x%" PRIxLEAST64 " of %s type", - reinterpret_cast(object), string_VkDebugReportObjectTypeEXT(objType)); + (uint64_t)(object), string_VkDebugReportObjectTypeEXT(objType)); } } return skipCall; @@ -521,14 +521,14 @@ static void create_physical_device(VkInstance dispatchable_object, VkPhysicalDev static void create_surface_khr(VkInstance dispatchable_object, VkSurfaceKHR vkObj, VkDebugReportObjectTypeEXT objType) { // TODO: Add tracking of surface objects - log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFO_BIT_EXT, objType, reinterpret_cast(vkObj), __LINE__, OBJTRACK_NONE, "OBJTRACK", + log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFO_BIT_EXT, objType, (uint64_t)(vkObj), __LINE__, OBJTRACK_NONE, "OBJTRACK", "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDebugReportObjectTypeEXT(objType), - reinterpret_cast(vkObj)); + (uint64_t)(vkObj)); OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE; pNewObjNode->objType = objType; pNewObjNode->status = OBJSTATUS_NONE; - pNewObjNode->vkObj = reinterpret_cast(vkObj); + pNewObjNode->vkObj = (uint64_t)(vkObj); VkSurfaceKHRMap[(uint64_t)vkObj] = pNewObjNode; uint32_t objIndex = objTypeToIndex(objType); numObjs[objIndex]++; @@ -537,7 +537,7 @@ static void create_surface_khr(VkInstance dispatchable_object, VkSurfaceKHR vkOb static void destroy_surface_khr(VkInstance dispatchable_object, VkSurfaceKHR object) { - uint64_t object_handle = reinterpret_cast(object); + uint64_t object_handle = (uint64_t)(object); if (VkSurfaceKHRMap.find(object_handle) != VkSurfaceKHRMap.end()) { OBJTRACK_NODE* pNode = VkSurfaceKHRMap[(uint64_t)object]; uint32_t objIndex = objTypeToIndex(pNode->objType); @@ -547,7 +547,7 @@ static void destroy_surface_khr(VkInstance dispatchable_object, VkSurfaceKHR obj numObjs[objIndex]--; log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFO_BIT_EXT, pNode->objType, object_handle, __LINE__, OBJTRACK_NONE, "OBJTRACK", "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " %s objs).", - string_VkDebugReportObjectTypeEXT(pNode->objType), reinterpret_cast(object), numTotalObjs, numObjs[objIndex], + string_VkDebugReportObjectTypeEXT(pNode->objType), (uint64_t)(object), numTotalObjs, numObjs[objIndex], string_VkDebugReportObjectTypeEXT(pNode->objType)); delete pNode; VkSurfaceKHRMap.erase(object_handle); @@ -585,10 +585,10 @@ static void free_command_buffer(VkDevice device, VkCommandPool commandPool, VkCo if (VkCommandBufferMap.find(object_handle) != VkCommandBufferMap.end()) { OBJTRACK_NODE* pNode = VkCommandBufferMap[(uint64_t)commandBuffer]; - if (pNode->parentObj != reinterpret_cast(commandPool)) { + if (pNode->parentObj != (uint64_t)(commandPool)) { log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, object_handle, __LINE__, OBJTRACK_COMMAND_POOL_MISMATCH, "OBJTRACK", "FreeCommandBuffers is attempting to free Command Buffer 0x%" PRIxLEAST64 " belonging to Command Pool 0x%" PRIxLEAST64 " from pool 0x%" PRIxLEAST64 ").", - reinterpret_cast(commandBuffer), pNode->parentObj, reinterpret_cast(commandPool)); + reinterpret_cast(commandBuffer), pNode->parentObj, (uint64_t)(commandPool)); } else { uint32_t objIndex = objTypeToIndex(pNode->objType); @@ -612,14 +612,14 @@ static void free_command_buffer(VkDevice device, VkCommandPool commandPool, VkCo static void alloc_descriptor_set(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSet vkObj, VkDebugReportObjectTypeEXT objType) { - log_msg(mdd(device), VK_DEBUG_REPORT_INFO_BIT_EXT, objType, reinterpret_cast(vkObj), __LINE__, OBJTRACK_NONE, "OBJTRACK", + log_msg(mdd(device), VK_DEBUG_REPORT_INFO_BIT_EXT, objType, (uint64_t)(vkObj), __LINE__, OBJTRACK_NONE, "OBJTRACK", "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDebugReportObjectTypeEXT(objType), - reinterpret_cast(vkObj)); + (uint64_t)(vkObj)); OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE; pNewObjNode->objType = objType; pNewObjNode->status = OBJSTATUS_NONE; - pNewObjNode->vkObj = reinterpret_cast(vkObj); + pNewObjNode->vkObj = (uint64_t)(vkObj); pNewObjNode->parentObj = (uint64_t) descriptorPool; VkDescriptorSetMap[(uint64_t)vkObj] = pNewObjNode; uint32_t objIndex = objTypeToIndex(objType); @@ -629,14 +629,14 @@ static void alloc_descriptor_set(VkDevice device, VkDescriptorPool descriptorPoo static void free_descriptor_set(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSet descriptorSet) { - uint64_t object_handle = reinterpret_cast(descriptorSet); + uint64_t object_handle = (uint64_t)(descriptorSet); if (VkDescriptorSetMap.find(object_handle) != VkDescriptorSetMap.end()) { OBJTRACK_NODE* pNode = VkDescriptorSetMap[(uint64_t)descriptorSet]; - if (pNode->parentObj != reinterpret_cast(descriptorPool)) { + if (pNode->parentObj != (uint64_t)(descriptorPool)) { log_msg(mdd(device), VK_DEBUG_REPORT_ERROR_BIT_EXT, pNode->objType, object_handle, __LINE__, OBJTRACK_DESCRIPTOR_POOL_MISMATCH, "OBJTRACK", "FreeDescriptorSets is attempting to free descriptorSet 0x%" PRIxLEAST64 " belonging to Descriptor Pool 0x%" PRIxLEAST64 " from pool 0x%" PRIxLEAST64 ").", - reinterpret_cast(descriptorSet), pNode->parentObj, reinterpret_cast(descriptorPool)); + (uint64_t)(descriptorSet), pNode->parentObj, (uint64_t)(descriptorPool)); } else { uint32_t objIndex = objTypeToIndex(pNode->objType); assert(numTotalObjs > 0); @@ -645,7 +645,7 @@ static void free_descriptor_set(VkDevice device, VkDescriptorPool descriptorPool numObjs[objIndex]--; log_msg(mdd(device), VK_DEBUG_REPORT_INFO_BIT_EXT, pNode->objType, object_handle, __LINE__, OBJTRACK_NONE, "OBJTRACK", "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%" PRIu64 " total objs remain & %" PRIu64 " %s objs).", - string_VkDebugReportObjectTypeEXT(pNode->objType), reinterpret_cast(descriptorSet), numTotalObjs, numObjs[objIndex], + string_VkDebugReportObjectTypeEXT(pNode->objType), (uint64_t)(descriptorSet), numTotalObjs, numObjs[objIndex], string_VkDebugReportObjectTypeEXT(pNode->objType)); delete pNode; VkDescriptorSetMap.erase(object_handle); @@ -676,14 +676,14 @@ static void create_swapchain_image_obj(VkDevice dispatchable_object, VkImage vkO { log_msg(mdd(dispatchable_object), VK_DEBUG_REPORT_INFO_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, (uint64_t) vkObj, __LINE__, OBJTRACK_NONE, "OBJTRACK", "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, "SwapchainImage", - reinterpret_cast(vkObj)); + (uint64_t)(vkObj)); OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE; pNewObjNode->objType = VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT; pNewObjNode->status = OBJSTATUS_NONE; pNewObjNode->vkObj = (uint64_t) vkObj; pNewObjNode->parentObj = (uint64_t) swapchain; - swapchainImageMap[reinterpret_cast(vkObj)] = pNewObjNode; + swapchainImageMap[(uint64_t)(vkObj)] = pNewObjNode; } // @@ -984,7 +984,7 @@ explicit_DestroySwapchainKHR( unordered_map::iterator itr = swapchainImageMap.begin(); while (itr != swapchainImageMap.end()) { OBJTRACK_NODE* pNode = (*itr).second; - if (pNode->parentObj == reinterpret_cast(swapchain)) { + if (pNode->parentObj == (uint64_t)(swapchain)) { swapchainImageMap.erase(itr++); } else { ++itr; @@ -1056,8 +1056,8 @@ explicit_DestroyDescriptorPool( while (itr != VkDescriptorSetMap.end()) { OBJTRACK_NODE* pNode = (*itr).second; auto del_itr = itr++; - if (pNode->parentObj == reinterpret_cast(descriptorPool)) { - destroy_descriptor_set(device, reinterpret_cast((*del_itr).first)); + if (pNode->parentObj == (uint64_t)(descriptorPool)) { + destroy_descriptor_set(device, (VkDescriptorSet)((*del_itr).first)); } } destroy_descriptor_pool(device, descriptorPool); @@ -1087,7 +1087,7 @@ explicit_DestroyCommandPool( while (itr != VkCommandBufferMap.end()) { OBJTRACK_NODE* pNode = (*itr).second; del_itr = itr++; - if (pNode->parentObj == reinterpret_cast(commandPool)) { + if (pNode->parentObj == (uint64_t)(commandPool)) { destroy_command_buffer(reinterpret_cast((*del_itr).first), reinterpret_cast((*del_itr).first)); } diff --git a/layers/screenshot.cpp b/layers/screenshot.cpp index cc192b87..107c7dee 100644 --- a/layers/screenshot.cpp +++ b/layers/screenshot.cpp @@ -141,7 +141,7 @@ static void writePPM( const char *filename, VkImage image1) VkImage image2; VkResult err; bool pass; - int x, y; + uint32_t x, y; const char *ptr; VkDeviceMemory mem2; VkCommandBuffer commandBuffer; diff --git a/layers/vk_layer_logging.h b/layers/vk_layer_logging.h index e199472d..5c7fdf17 100644 --- a/layers/vk_layer_logging.h +++ b/layers/vk_layer_logging.h @@ -336,7 +336,7 @@ static inline VKAPI_ATTR VkBool32 VKAPI_CALL win32_debug_output_msg( print_msg_flags(msgFlags, msg_flags); _snprintf(buf, sizeof(buf) - 1, "%s (%s): object: 0x%" PRIxPTR " type: %d location: " PRINTF_SIZE_T_SPECIFIER " msgCode: %d: %s\n", - pLayerPrefix, msg_flags, srcObject, objType, location, msgCode, pMsg); + pLayerPrefix, msg_flags, (size_t)srcObject, objType, location, msgCode, pMsg); OutputDebugString(buf); #endif -- cgit v1.2.3