bug 14362: VK_NULL_HANDLE does not work in C (WIP)
Drop type safety on 32-bit.
https://cvs.khronos.org/bugzilla/show_bug.cgi?id=14362
diff --git a/include/vulkan.h b/include/vulkan.h
index 074f7e5..e17207b 100644
--- a/include/vulkan.h
+++ b/include/vulkan.h
@@ -44,46 +44,17 @@
#define VK_API_VERSION VK_MAKE_VERSION(0, 185, 0)
-#if defined(__cplusplus) && ((defined(_MSC_VER) && _MSC_VER >= 1800) || __cplusplus >= 201103L)
- #define VK_NULL_HANDLE nullptr
-#else
- #define VK_NULL_HANDLE 0
-#endif
+#define VK_NULL_HANDLE 0
+
#define VK_DEFINE_HANDLE(obj) typedef struct obj##_T* obj;
-#if defined(__cplusplus)
- #if ((defined(_MSC_VER) && _MSC_VER >= 1800) || __cplusplus >= 201103L)
- // The bool operator only works if there are no implicit conversions from an obj to
- // a bool-compatible type, which can then be used to unintentionally violate type safety.
- // C++11 and above supports the "explicit" keyword on conversion operators to stop this
- // from happening. Otherwise users of C++ below C++11 won't get direct access to evaluating
- // the object handle as a bool in expressions like:
- // if (obj) vkDestroy(obj);
- #define VK_NONDISP_HANDLE_OPERATOR_BOOL() explicit operator bool() const { return handle != 0; }
- #define VK_NONDISP_HANDLE_CONSTRUCTOR_FROM_UINT64(obj) \
- explicit obj(uint64_t x) : handle(x) { } \
- obj(decltype(nullptr)) : handle(0) { }
- #else
- #define VK_NONDISP_HANDLE_OPERATOR_BOOL()
- #define VK_NONDISP_HANDLE_CONSTRUCTOR_FROM_UINT64(obj) \
- obj(uint64_t x) : handle(x) { }
- #endif
- #define VK_DEFINE_NONDISP_HANDLE(obj) \
- struct obj { \
- obj() : handle(0) { } \
- VK_NONDISP_HANDLE_CONSTRUCTOR_FROM_UINT64(obj) \
- obj& operator =(uint64_t x) { handle = x; return *this; } \
- bool operator==(const obj& other) const { return handle == other.handle; } \
- bool operator!=(const obj& other) const { return handle != other.handle; } \
- bool operator!() const { return !handle; } \
- VK_NONDISP_HANDLE_OPERATOR_BOOL() \
- uint64_t handle; \
- };
+#if defined(__LP64__) || defined(_WIN64) || defined(__x86_64__) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
+ #define VK_DEFINE_NONDISP_HANDLE(obj) typedef struct obj##_T *obj;
#else
- #define VK_DEFINE_NONDISP_HANDLE(obj) typedef struct obj##_T { uint64_t handle; } obj;
+ #define VK_DEFINE_NONDISP_HANDLE(obj) typedef uint64_t obj;
#endif
diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp
index a928547..2b6d55e 100755
--- a/layers/draw_state.cpp
+++ b/layers/draw_state.cpp
@@ -63,21 +63,21 @@
VkLayerInstanceDispatchTable* instance_dispatch_table;
devExts device_extensions;
// Layer specific data
- unordered_map<uint64_t, unique_ptr<SAMPLER_NODE>> sampleMap;
- unordered_map<uint64_t, unique_ptr<VkImageViewCreateInfo>> imageViewMap;
- unordered_map<uint64_t, unique_ptr<VkImageCreateInfo>> imageMap;
- unordered_map<uint64_t, unique_ptr<VkBufferViewCreateInfo>> bufferViewMap;
- unordered_map<uint64_t, unique_ptr<VkBufferCreateInfo>> bufferMap;
- unordered_map<uint64_t, PIPELINE_NODE*> pipelineMap;
- unordered_map<uint64_t, POOL_NODE*> poolMap;
- unordered_map<uint64_t, SET_NODE*> setMap;
- unordered_map<uint64_t, LAYOUT_NODE*> layoutMap;
- unordered_map<uint64_t, PIPELINE_LAYOUT_NODE> pipelineLayoutMap;
- unordered_map<uint64_t, VkShaderStageFlagBits> shaderStageMap;
+ unordered_map<VkSampler, unique_ptr<SAMPLER_NODE>> sampleMap;
+ unordered_map<VkImageView, unique_ptr<VkImageViewCreateInfo>> imageViewMap;
+ unordered_map<VkImage, unique_ptr<VkImageCreateInfo>> imageMap;
+ unordered_map<VkBufferView, unique_ptr<VkBufferViewCreateInfo>> bufferViewMap;
+ unordered_map<VkBuffer, unique_ptr<VkBufferCreateInfo>> bufferMap;
+ unordered_map<VkPipeline, PIPELINE_NODE*> pipelineMap;
+ unordered_map<VkDescriptorPool, POOL_NODE*> poolMap;
+ unordered_map<VkDescriptorSet, SET_NODE*> setMap;
+ unordered_map<VkDescriptorSetLayout, LAYOUT_NODE*> layoutMap;
+ unordered_map<VkPipelineLayout, PIPELINE_LAYOUT_NODE> pipelineLayoutMap;
+ unordered_map<VkShader, VkShaderStageFlagBits> shaderStageMap;
// Map for layout chains
unordered_map<void*, GLOBAL_CB_NODE*> cmdBufferMap;
- unordered_map<uint64_t, VkRenderPassCreateInfo*> renderPassMap;
- unordered_map<uint64_t, VkFramebufferCreateInfo*> frameBufferMap;
+ unordered_map<VkRenderPass, VkRenderPassCreateInfo*> renderPassMap;
+ unordered_map<VkFramebuffer, VkFramebufferCreateInfo*> frameBufferMap;
layer_data() :
report_data(nullptr),
@@ -283,12 +283,12 @@
static PIPELINE_NODE* getPipeline(layer_data* my_data, const VkPipeline pipeline)
{
loader_platform_thread_lock_mutex(&globalLock);
- if (my_data->pipelineMap.find(pipeline.handle) == my_data->pipelineMap.end()) {
+ if (my_data->pipelineMap.find(pipeline) == my_data->pipelineMap.end()) {
loader_platform_thread_unlock_mutex(&globalLock);
return NULL;
}
loader_platform_thread_unlock_mutex(&globalLock);
- return my_data->pipelineMap[pipeline.handle];
+ return my_data->pipelineMap[pipeline];
}
// Return VK_TRUE if for a given PSO, the given state enum is dynamic, else return VK_FALSE
static VkBool32 isDynamic(const PIPELINE_NODE* pPipeline, const VkDynamicState state)
@@ -328,8 +328,8 @@
// We should have that check separately and then gate this check based on that check
if (pPipe && (pCB->lastBoundPipelineLayout) && (pCB->lastBoundPipelineLayout != pPipe->graphicsPipelineCI.layout)) {
result = VK_FALSE;
- result |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE_LAYOUT, pCB->lastBoundPipelineLayout.handle, 0, DRAWSTATE_PIPELINE_LAYOUT_MISMATCH, "DS",
- "Pipeline layout from last vkCmdBindDescriptorSets() (%#" PRIxLEAST64 ") does not match PSO Pipeline layout (%#" PRIxLEAST64 ") ", pCB->lastBoundPipelineLayout.handle, pPipe->graphicsPipelineCI.layout.handle);
+ result |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE_LAYOUT, (uint64_t) pCB->lastBoundPipelineLayout, 0, DRAWSTATE_PIPELINE_LAYOUT_MISMATCH, "DS",
+ "Pipeline layout from last vkCmdBindDescriptorSets() (%#" PRIxLEAST64 ") does not match PSO Pipeline layout (%#" PRIxLEAST64 ") ", (uint64_t) pCB->lastBoundPipelineLayout, (uint64_t) pPipe->graphicsPipelineCI.layout);
}
// Verify Vtx binding
if (MAX_BINDING != pCB->lastVtxBinding) {
@@ -449,10 +449,10 @@
for (uint32_t i = 0; i < pCreateInfo->stageCount; i++) {
const VkPipelineShaderStageCreateInfo *pPSSCI = &pCreateInfo->pStages[i];
- if (dev_data->shaderStageMap.find(pPSSCI->shader.handle) == dev_data->shaderStageMap.end())
+ if (dev_data->shaderStageMap.find(pPSSCI->shader) == dev_data->shaderStageMap.end())
continue;
- switch (dev_data->shaderStageMap[pPSSCI->shader.handle]) {
+ switch (dev_data->shaderStageMap[pPSSCI->shader]) {
case VK_SHADER_STAGE_VERTEX_BIT:
memcpy(&pPipeline->vsCI, pPSSCI, sizeof(VkPipelineShaderStageCreateInfo));
pPipeline->active_shaders |= VK_SHADER_STAGE_VERTEX_BIT;
@@ -582,7 +582,7 @@
// For given pipeline, return number of MSAA samples, or one if MSAA disabled
static uint32_t getNumSamples(layer_data* my_data, const VkPipeline pipeline)
{
- PIPELINE_NODE* pPipe = my_data->pipelineMap[pipeline.handle];
+ PIPELINE_NODE* pPipe = my_data->pipelineMap[pipeline];
if (VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO == pPipe->msStateCI.sType) {
return pPipe->msStateCI.rasterSamples;
}
@@ -595,7 +595,7 @@
// Verify that any MSAA request in PSO matches sample# in bound FB
uint32_t psoNumSamples = getNumSamples(my_data, pipeline);
if (pCB->activeRenderPass) {
- const VkRenderPassCreateInfo* pRPCI = my_data->renderPassMap[pCB->activeRenderPass.handle];
+ const VkRenderPassCreateInfo* pRPCI = my_data->renderPassMap[pCB->activeRenderPass];
const VkSubpassDescription* pSD = &pRPCI->pSubpasses[pCB->activeSubpass];
int subpassNumSamples = 0;
uint32_t i;
@@ -623,9 +623,9 @@
}
if (psoNumSamples != subpassNumSamples) {
- return log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE, pipeline.handle, 0, DRAWSTATE_NUM_SAMPLES_MISMATCH, "DS",
+ return log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE, (uint64_t) pipeline, 0, DRAWSTATE_NUM_SAMPLES_MISMATCH, "DS",
"Num samples mismatch! Binding PSO (%#" PRIxLEAST64 ") with %u samples while current RenderPass (%#" PRIxLEAST64 ") w/ %u samples!",
- pipeline.handle, psoNumSamples, pCB->activeRenderPass.handle, subpassNumSamples);
+ (uint64_t) pipeline, psoNumSamples, (uint64_t) pCB->activeRenderPass, subpassNumSamples);
}
} else {
// TODO : I believe it's an error if we reach this point and don't have an activeRenderPass
@@ -644,33 +644,33 @@
static POOL_NODE* getPoolNode(layer_data* my_data, const VkDescriptorPool pool)
{
loader_platform_thread_lock_mutex(&globalLock);
- if (my_data->poolMap.find(pool.handle) == my_data->poolMap.end()) {
+ if (my_data->poolMap.find(pool) == my_data->poolMap.end()) {
loader_platform_thread_unlock_mutex(&globalLock);
return NULL;
}
loader_platform_thread_unlock_mutex(&globalLock);
- return my_data->poolMap[pool.handle];
+ return my_data->poolMap[pool];
}
// Return Set node ptr for specified set or else NULL
static SET_NODE* getSetNode(layer_data* my_data, const VkDescriptorSet set)
{
loader_platform_thread_lock_mutex(&globalLock);
- if (my_data->setMap.find(set.handle) == my_data->setMap.end()) {
+ if (my_data->setMap.find(set) == my_data->setMap.end()) {
loader_platform_thread_unlock_mutex(&globalLock);
return NULL;
}
loader_platform_thread_unlock_mutex(&globalLock);
- return my_data->setMap[set.handle];
+ return my_data->setMap[set];
}
static LAYOUT_NODE* getLayoutNode(layer_data* my_data, const VkDescriptorSetLayout layout) {
loader_platform_thread_lock_mutex(&globalLock);
- if (my_data->layoutMap.find(layout.handle) == my_data->layoutMap.end()) {
+ if (my_data->layoutMap.find(layout) == my_data->layoutMap.end()) {
loader_platform_thread_unlock_mutex(&globalLock);
return NULL;
}
loader_platform_thread_unlock_mutex(&globalLock);
- return my_data->layoutMap[layout.handle];
+ return my_data->layoutMap[layout];
}
// Return VK_FALSE if update struct is of valid type, otherwise flag error and return code from callback
static VkBool32 validUpdateStruct(layer_data* my_data, const VkDevice device, const GENERIC_HEADER* pUpdateStruct)
@@ -836,14 +836,14 @@
static VkBool32 validateSampler(const layer_data* my_data, const VkSampler* pSampler, const VkBool32 immutable)
{
VkBool32 skipCall = VK_FALSE;
- auto sampIt = my_data->sampleMap.find(pSampler->handle);
+ auto sampIt = my_data->sampleMap.find(*pSampler);
if (sampIt == my_data->sampleMap.end()) {
if (!immutable) {
- skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_SAMPLER, pSampler->handle, 0, DRAWSTATE_SAMPLER_DESCRIPTOR_ERROR, "DS",
- "vkUpdateDescriptorSets: Attempt to update descriptor with invalid sampler %#" PRIxLEAST64, pSampler->handle);
+ skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_SAMPLER, (uint64_t) *pSampler, 0, DRAWSTATE_SAMPLER_DESCRIPTOR_ERROR, "DS",
+ "vkUpdateDescriptorSets: Attempt to update descriptor with invalid sampler %#" PRIxLEAST64, (uint64_t) *pSampler);
} else { // immutable
- skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_SAMPLER, pSampler->handle, 0, DRAWSTATE_SAMPLER_DESCRIPTOR_ERROR, "DS",
- "vkUpdateDescriptorSets: Attempt to update descriptor whose binding has an invalid immutable sampler %#" PRIxLEAST64, pSampler->handle);
+ skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_SAMPLER, (uint64_t) *pSampler, 0, DRAWSTATE_SAMPLER_DESCRIPTOR_ERROR, "DS",
+ "vkUpdateDescriptorSets: Attempt to update descriptor whose binding has an invalid immutable sampler %#" PRIxLEAST64, (uint64_t) *pSampler);
}
} else {
// TODO : Any further checks we want to do on the sampler?
@@ -854,19 +854,19 @@
static VkBool32 validateImageView(const layer_data* my_data, const VkImageView* pImageView, const VkImageLayout imageLayout)
{
VkBool32 skipCall = VK_FALSE;
- auto ivIt = my_data->imageViewMap.find(pImageView->handle);
+ auto ivIt = my_data->imageViewMap.find(*pImageView);
if (ivIt == my_data->imageViewMap.end()) {
- skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE_VIEW, pImageView->handle, 0, DRAWSTATE_IMAGEVIEW_DESCRIPTOR_ERROR, "DS",
- "vkUpdateDescriptorSets: Attempt to update descriptor with invalid imageView %#" PRIxLEAST64, pImageView->handle);
+ skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE_VIEW, (uint64_t) *pImageView, 0, DRAWSTATE_IMAGEVIEW_DESCRIPTOR_ERROR, "DS",
+ "vkUpdateDescriptorSets: Attempt to update descriptor with invalid imageView %#" PRIxLEAST64, (uint64_t) *pImageView);
} else {
// Validate that imageLayout is compatible with aspectMask and image format
VkImageAspectFlags aspectMask = ivIt->second->subresourceRange.aspectMask;
- uint64_t imageHandle = ivIt->second->image.handle;
+ VkImage image = ivIt->second->image;
// TODO : Check here in case we have a bad image handle
- auto imgIt = my_data->imageMap.find(imageHandle);
+ auto imgIt = my_data->imageMap.find(image);
if (imgIt == my_data->imageMap.end()) {
- skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE, imageHandle, 0, DRAWSTATE_IMAGEVIEW_DESCRIPTOR_ERROR, "DS",
- "vkUpdateDescriptorSets: Attempt to update descriptor with invalid image handle %#" PRIxLEAST64 " in imageView %#" PRIxLEAST64, imageHandle, pImageView->handle);
+ skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE, (uint64_t) image, 0, DRAWSTATE_IMAGEVIEW_DESCRIPTOR_ERROR, "DS",
+ "vkUpdateDescriptorSets: Attempt to update descriptor with invalid image handle %#" PRIxLEAST64 " in imageView %#" PRIxLEAST64, (uint64_t) image, (uint64_t) *pImageView);
} else {
VkFormat format = (*imgIt).second->format;
bool ds = vk_format_is_depth_or_stencil(format);
@@ -874,15 +874,15 @@
case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
// Only Color bit must be set
if ((aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) != VK_IMAGE_ASPECT_COLOR_BIT) {
- skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE_VIEW, pImageView->handle, 0,
+ skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE_VIEW, (uint64_t) *pImageView, 0,
DRAWSTATE_INVALID_IMAGE_ASPECT, "DS", "vkUpdateDescriptorSets: Updating descriptor with layout VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL and imageView %#" PRIxLEAST64 ""
- " that does not have VK_IMAGE_ASPECT_COLOR_BIT set.", pImageView->handle);
+ " that does not have VK_IMAGE_ASPECT_COLOR_BIT set.", (uint64_t) *pImageView);
}
// format must NOT be DS
if (ds) {
- skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE_VIEW, pImageView->handle, 0,
+ skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE_VIEW, (uint64_t) *pImageView, 0,
DRAWSTATE_IMAGEVIEW_DESCRIPTOR_ERROR, "DS", "vkUpdateDescriptorSets: Updating descriptor with layout VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL and imageView %#" PRIxLEAST64 ""
- " but the image format is %s which is not a color format.", pImageView->handle, string_VkFormat(format));
+ " but the image format is %s which is not a color format.", (uint64_t) *pImageView, string_VkFormat(format));
}
break;
case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
@@ -891,21 +891,21 @@
if (aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) {
if (aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) {
// both must NOT be set
- skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE_VIEW, pImageView->handle, 0,
+ skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE_VIEW, (uint64_t) *pImageView, 0,
DRAWSTATE_INVALID_IMAGE_ASPECT, "DS", "vkUpdateDescriptorSets: Updating descriptor with imageView %#" PRIxLEAST64 ""
- " that has both STENCIL and DEPTH aspects set", pImageView->handle);
+ " that has both STENCIL and DEPTH aspects set", (uint64_t) *pImageView);
}
} else if (!(aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT)) {
// Neither were set
- skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE_VIEW, pImageView->handle, 0,
+ skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE_VIEW, (uint64_t) *pImageView, 0,
DRAWSTATE_INVALID_IMAGE_ASPECT, "DS", "vkUpdateDescriptorSets: Updating descriptor with layout %s and imageView %#" PRIxLEAST64 ""
- " that does not have STENCIL or DEPTH aspect set.", string_VkImageLayout(imageLayout), pImageView->handle);
+ " that does not have STENCIL or DEPTH aspect set.", string_VkImageLayout(imageLayout), (uint64_t) *pImageView);
}
// format must be DS
if (!ds) {
- skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE_VIEW, pImageView->handle, 0,
+ skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE_VIEW, (uint64_t) *pImageView, 0,
DRAWSTATE_IMAGEVIEW_DESCRIPTOR_ERROR, "DS", "vkUpdateDescriptorSets: Updating descriptor with layout %s and imageView %#" PRIxLEAST64 ""
- " but the image format is %s which is not a depth/stencil format.", string_VkImageLayout(imageLayout), pImageView->handle, string_VkFormat(format));
+ " but the image format is %s which is not a depth/stencil format.", string_VkImageLayout(imageLayout), (uint64_t) *pImageView, string_VkFormat(format));
}
break;
default:
@@ -920,10 +920,10 @@
static VkBool32 validateBufferView(const layer_data* my_data, const VkBufferView* pBufferView)
{
VkBool32 skipCall = VK_FALSE;
- auto sampIt = my_data->bufferViewMap.find(pBufferView->handle);
+ auto sampIt = my_data->bufferViewMap.find(*pBufferView);
if (sampIt == my_data->bufferViewMap.end()) {
- skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_BUFFER_VIEW, pBufferView->handle, 0, DRAWSTATE_BUFFERVIEW_DESCRIPTOR_ERROR, "DS",
- "vkUpdateDescriptorSets: Attempt to update descriptor with invalid bufferView %#" PRIxLEAST64, pBufferView->handle);
+ skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_BUFFER_VIEW, (uint64_t) *pBufferView, 0, DRAWSTATE_BUFFERVIEW_DESCRIPTOR_ERROR, "DS",
+ "vkUpdateDescriptorSets: Attempt to update descriptor with invalid bufferView %#" PRIxLEAST64, (uint64_t) *pBufferView);
} else {
// TODO : Any further checks we want to do on the bufferView?
}
@@ -933,10 +933,10 @@
static VkBool32 validateBufferInfo(const layer_data* my_data, const VkDescriptorBufferInfo* pBufferInfo)
{
VkBool32 skipCall = VK_FALSE;
- auto sampIt = my_data->bufferMap.find(pBufferInfo->buffer.handle);
+ auto sampIt = my_data->bufferMap.find(pBufferInfo->buffer);
if (sampIt == my_data->bufferMap.end()) {
- skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_BUFFER, pBufferInfo->buffer.handle, 0, DRAWSTATE_BUFFERINFO_DESCRIPTOR_ERROR, "DS",
- "vkUpdateDescriptorSets: Attempt to update descriptor where bufferInfo has invalid buffer %#" PRIxLEAST64, pBufferInfo->buffer.handle);
+ skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_BUFFER, (uint64_t) pBufferInfo->buffer, 0, DRAWSTATE_BUFFERINFO_DESCRIPTOR_ERROR, "DS",
+ "vkUpdateDescriptorSets: Attempt to update descriptor where bufferInfo has invalid buffer %#" PRIxLEAST64, (uint64_t) pBufferInfo->buffer);
} else {
// TODO : Any further checks we want to do on the bufferView?
}
@@ -965,14 +965,14 @@
if (NULL == pLayoutBinding->pImmutableSamplers) {
pSampler = &(pWDS->pImageInfo[i].sampler);
if (immutable) {
- skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_SAMPLER, pSampler->handle, 0, DRAWSTATE_INCONSISTENT_IMMUTABLE_SAMPLER_UPDATE, "DS",
+ skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_SAMPLER, (uint64_t) *pSampler, 0, DRAWSTATE_INCONSISTENT_IMMUTABLE_SAMPLER_UPDATE, "DS",
"vkUpdateDescriptorSets: Update #%u is not an immutable sampler %#" PRIxLEAST64 ", but previous update(s) from this "
"VkWriteDescriptorSet struct used an immutable sampler. All updates from a single struct must either "
- "use immutable or non-immutable samplers.", i, pSampler->handle);
+ "use immutable or non-immutable samplers.", i, (uint64_t) *pSampler);
}
} else {
if (i>0 && !immutable) {
- skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_SAMPLER, pSampler->handle, 0, DRAWSTATE_INCONSISTENT_IMMUTABLE_SAMPLER_UPDATE, "DS",
+ skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_SAMPLER, (uint64_t) *pSampler, 0, DRAWSTATE_INCONSISTENT_IMMUTABLE_SAMPLER_UPDATE, "DS",
"vkUpdateDescriptorSets: Update #%u is an immutable sampler, but previous update(s) from this "
"VkWriteDescriptorSet struct used a non-immutable sampler. All updates from a single struct must either "
"use immutable or non-immutable samplers.", i);
@@ -1019,7 +1019,7 @@
uint32_t i = 0;
for (i=0; i < writeCount; i++) {
VkDescriptorSet ds = pWDS[i].destSet;
- SET_NODE* pSet = my_data->setMap[ds.handle];
+ SET_NODE* pSet = my_data->setMap[ds];
GENERIC_HEADER* pUpdate = (GENERIC_HEADER*) &pWDS[i];
pLayout = pSet->pLayout;
// First verify valid update struct
@@ -1030,7 +1030,7 @@
binding = pWDS[i].destBinding;
// Make sure that layout being updated has the binding being updated
if (pLayout->createInfo.count < binding) {
- skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, ds.handle, 0, DRAWSTATE_INVALID_UPDATE_INDEX, "DS",
+ skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) ds, 0, DRAWSTATE_INVALID_UPDATE_INDEX, "DS",
"Descriptor Set %p does not have binding to match update binding %u for update type %s!", ds, binding, string_VkStructureType(pUpdate->sType));
} else {
// Next verify that update falls within size of given binding
@@ -1038,7 +1038,7 @@
if (getBindingEndIndex(pLayout, binding) < endIndex) {
pLayoutCI = &pLayout->createInfo;
string DSstr = vk_print_vkdescriptorsetlayoutcreateinfo(pLayoutCI, "{DS} ");
- skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, ds.handle, 0, DRAWSTATE_DESCRIPTOR_UPDATE_OUT_OF_BOUNDS, "DS",
+ skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) ds, 0, 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;
@@ -1052,7 +1052,7 @@
GENERIC_HEADER* pNewNode = NULL;
skipCall |= shadowUpdateNode(my_data, device, pUpdate, &pNewNode);
if (NULL == pNewNode) {
- skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, ds.handle, 0, DRAWSTATE_OUT_OF_MEMORY, "DS",
+ skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) ds, 0, 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
@@ -1075,19 +1075,19 @@
LAYOUT_NODE *pSrcLayout = NULL, *pDstLayout = NULL;
uint32_t srcStartIndex = 0, srcEndIndex = 0, dstStartIndex = 0, dstEndIndex = 0;
// For each copy make sure that update falls within given layout and that types match
- pSrcSet = my_data->setMap[pCDS[i].srcSet.handle];
- pDstSet = my_data->setMap[pCDS[i].destSet.handle];
+ pSrcSet = my_data->setMap[pCDS[i].srcSet];
+ pDstSet = my_data->setMap[pCDS[i].destSet];
pSrcLayout = pSrcSet->pLayout;
pDstLayout = pDstSet->pLayout;
// Validate that src binding is valid for src set layout
if (pSrcLayout->createInfo.count < pCDS[i].srcBinding) {
- skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, pSrcSet->set.handle, 0, DRAWSTATE_INVALID_UPDATE_INDEX, "DS",
+ skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pSrcSet->set, 0, DRAWSTATE_INVALID_UPDATE_INDEX, "DS",
"Copy descriptor update %u has srcBinding %u which is out of bounds for underlying SetLayout %#" PRIxLEAST64 " which only has bindings 0-%u.",
- i, pCDS[i].srcBinding, pSrcLayout->layout.handle, pSrcLayout->createInfo.count-1);
+ i, pCDS[i].srcBinding, (uint64_t) pSrcLayout->layout, pSrcLayout->createInfo.count-1);
} else if (pDstLayout->createInfo.count < pCDS[i].destBinding) {
- skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, pDstSet->set.handle, 0, DRAWSTATE_INVALID_UPDATE_INDEX, "DS",
+ skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pDstSet->set, 0, DRAWSTATE_INVALID_UPDATE_INDEX, "DS",
"Copy descriptor update %u has destBinding %u which is out of bounds for underlying SetLayout %#" PRIxLEAST64 " which only has bindings 0-%u.",
- i, pCDS[i].destBinding, pDstLayout->layout.handle, pDstLayout->createInfo.count-1);
+ i, pCDS[i].destBinding, (uint64_t) pDstLayout->layout, pDstLayout->createInfo.count-1);
} else {
// Proceed with validation. Bindings are ok, but make sure update is within bounds of given layout
srcEndIndex = getUpdateEndIndex(my_data, device, pSrcLayout, pCDS[i].srcBinding, pCDS[i].srcArrayElement, (const GENERIC_HEADER*)&(pCDS[i]));
@@ -1095,12 +1095,12 @@
if (getBindingEndIndex(pSrcLayout, pCDS[i].srcBinding) < srcEndIndex) {
pLayoutCI = &pSrcLayout->createInfo;
string DSstr = vk_print_vkdescriptorsetlayoutcreateinfo(pLayoutCI, "{DS} ");
- skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, pSrcSet->set.handle, 0, DRAWSTATE_DESCRIPTOR_UPDATE_OUT_OF_BOUNDS, "DS",
+ skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pSrcSet->set, 0, DRAWSTATE_DESCRIPTOR_UPDATE_OUT_OF_BOUNDS, "DS",
"Copy descriptor src update is out of bounds for matching binding %u in Layout w/ CI:\n%s!", pCDS[i].srcBinding, DSstr.c_str());
} else if (getBindingEndIndex(pDstLayout, pCDS[i].destBinding) < dstEndIndex) {
pLayoutCI = &pDstLayout->createInfo;
string DSstr = vk_print_vkdescriptorsetlayoutcreateinfo(pLayoutCI, "{DS} ");
- skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, pDstSet->set.handle, 0, DRAWSTATE_DESCRIPTOR_UPDATE_OUT_OF_BOUNDS, "DS",
+ skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pDstSet->set, 0, DRAWSTATE_DESCRIPTOR_UPDATE_OUT_OF_BOUNDS, "DS",
"Copy descriptor dest update is out of bounds for matching binding %u in Layout w/ CI:\n%s!", pCDS[i].destBinding, DSstr.c_str());
} else {
srcStartIndex = getUpdateStartIndex(my_data, device, pSrcLayout, pCDS[i].srcBinding, pCDS[i].srcArrayElement, (const GENERIC_HEADER*)&(pCDS[i]));
@@ -1130,17 +1130,17 @@
for (i=0; i<count; ++i) {
LAYOUT_NODE* pLayout = getLayoutNode(dev_data, pSetLayouts[i]);
if (NULL == pLayout) {
- skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, pSetLayouts[i].handle, 0, DRAWSTATE_INVALID_LAYOUT, "DS",
- "Unable to find set layout node for layout %#" PRIxLEAST64 " specified in vkAllocDescriptorSets() call", pSetLayouts[i].handle);
+ skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, (uint64_t) pSetLayouts[i], 0, DRAWSTATE_INVALID_LAYOUT, "DS",
+ "Unable to find set layout node for layout %#" PRIxLEAST64 " specified in vkAllocDescriptorSets() call", (uint64_t) pSetLayouts[i]);
} else {
uint32_t typeIndex = 0, typeCount = 0;
for (j=0; j<pLayout->createInfo.count; ++j) {
typeIndex = static_cast<uint32_t>(pLayout->createInfo.pBinding[j].descriptorType);
typeCount = pLayout->createInfo.pBinding[j].arraySize;
if (typeCount > pPoolNode->availableDescriptorTypeCount[typeIndex]) {
- skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, pLayout->layout.handle, 0, DRAWSTATE_DESCRIPTOR_POOL_EMPTY, "DS",
+ skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, (uint64_t) pLayout->layout, 0, DRAWSTATE_DESCRIPTOR_POOL_EMPTY, "DS",
"Unable to allocate %u descriptors of type %s from pool %#" PRIxLEAST64 ". This pool only has %u descriptors of this type remaining.",
- typeCount, string_VkDescriptorType(pLayout->createInfo.pBinding[j].descriptorType), pPoolNode->pool.handle, pPoolNode->availableDescriptorTypeCount[typeIndex]);
+ typeCount, string_VkDescriptorType(pLayout->createInfo.pBinding[j].descriptorType), (uint64_t) pPoolNode->pool, pPoolNode->availableDescriptorTypeCount[typeIndex]);
} else { // Decrement available descriptors of this type
pPoolNode->availableDescriptorTypeCount[typeIndex] -= typeCount;
}
@@ -1249,8 +1249,8 @@
{
POOL_NODE* pPool = getPoolNode(my_data, pool);
if (!pPool) {
- log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_POOL, pool.handle, 0, DRAWSTATE_INVALID_POOL, "DS",
- "Unable to find pool node for pool %#" PRIxLEAST64 " specified in vkResetDescriptorPool() call", pool.handle);
+ log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_POOL, (uint64_t) pool, 0, DRAWSTATE_INVALID_POOL, "DS",
+ "Unable to find pool node for pool %#" PRIxLEAST64 " specified in vkResetDescriptorPool() call", (uint64_t) pool);
} else {
// TODO: validate flags
// For every set off of this pool, clear it
@@ -1422,7 +1422,7 @@
POOL_NODE* pPool = getPoolNode(my_data, pSet->pool);
// Print out pool details
skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS",
- "Details for pool %#" PRIxLEAST64 ".", pPool->pool.handle);
+ "Details for pool %#" PRIxLEAST64 ".", (uint64_t) pPool->pool);
string poolStr = vk_print_vkdescriptorpoolcreateinfo(&pPool->createInfo, " ");
skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS",
"%s", poolStr.c_str());
@@ -1430,11 +1430,11 @@
char prefix[10];
uint32_t index = 0;
skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS",
- "Details for descriptor set %#" PRIxLEAST64 ".", pSet->set.handle);
+ "Details for descriptor set %#" PRIxLEAST64 ".", (uint64_t) pSet->set);
LAYOUT_NODE* pLayout = pSet->pLayout;
// Print layout details
skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS",
- "Layout #%u, (object %#" PRIxLEAST64 ") for DS %#" PRIxLEAST64 ".", index+1, (void*)pLayout->layout.handle, (void*)pSet->set.handle);
+ "Layout #%u, (object %#" PRIxLEAST64 ") for DS %#" PRIxLEAST64 ".", index+1, (void*)pLayout->layout, (void*)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_DBG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS",
@@ -1443,7 +1443,7 @@
GENERIC_HEADER* pUpdate = pSet->pUpdateStructs;
if (pUpdate) {
skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS",
- "Update Chain [UC] for descriptor set %#" PRIxLEAST64 ":", pSet->set.handle);
+ "Update Chain [UC] for descriptor set %#" PRIxLEAST64 ":", (uint64_t) pSet->set);
sprintf(prefix, " [UC] ");
skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS",
dynamic_display(pUpdate, prefix).c_str());
@@ -1451,10 +1451,10 @@
} else {
if (0 != pSet->descriptorCount) {
skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS",
- "No Update Chain for descriptor set %#" PRIxLEAST64 " which has %u descriptors (vkUpdateDescriptors has not been called)", pSet->set.handle, pSet->descriptorCount);
+ "No Update Chain for descriptor set %#" PRIxLEAST64 " which has %u descriptors (vkUpdateDescriptors has not been called)", (uint64_t) pSet->set, pSet->descriptorCount);
} else {
skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS",
- "FYI: No descriptors in descriptor set %#" PRIxLEAST64 ".", pSet->set.handle);
+ "FYI: No descriptors in descriptor set %#" PRIxLEAST64 ".", (uint64_t) pSet->set);
}
}
}
@@ -1498,7 +1498,7 @@
inside = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
(uint64_t)pCB->cmdBuffer, 0, DRAWSTATE_INVALID_RENDERPASS_CMD, "DS",
"%s: It is invalid to issue this call inside an active render pass (%#" PRIxLEAST64 ")",
- apiName, pCB->activeRenderPass.handle);
+ apiName, (uint64_t) pCB->activeRenderPass);
}
return inside;
}
@@ -1767,25 +1767,22 @@
VK_LAYER_EXPORT void VKAPI vkDestroyBuffer(VkDevice device, VkBuffer buffer)
{
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
- uint64_t handle = buffer.handle;
dev_data->device_dispatch_table->DestroyBuffer(device, buffer);
- dev_data->bufferMap.erase(handle);
+ dev_data->bufferMap.erase(buffer);
}
VK_LAYER_EXPORT void VKAPI vkDestroyBufferView(VkDevice device, VkBufferView bufferView)
{
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
- uint64_t handle = bufferView.handle;
dev_data->device_dispatch_table->DestroyBufferView(device, bufferView);
- dev_data->bufferViewMap.erase(handle);
+ dev_data->bufferViewMap.erase(bufferView);
}
VK_LAYER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image)
{
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
- uint64_t handle = image.handle;
dev_data->device_dispatch_table->DestroyImage(device, image);
- dev_data->imageMap.erase(handle);
+ dev_data->imageMap.erase(image);
}
VK_LAYER_EXPORT void VKAPI vkDestroyImageView(VkDevice device, VkImageView imageView)
@@ -1803,9 +1800,8 @@
VK_LAYER_EXPORT void VKAPI vkDestroyShader(VkDevice device, VkShader shader)
{
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
- uint64_t handle = shader.handle;
dev_data->device_dispatch_table->DestroyShader(device, shader);
- dev_data->shaderStageMap.erase(handle);
+ dev_data->shaderStageMap.erase(shader);
}
VK_LAYER_EXPORT void VKAPI vkDestroyPipeline(VkDevice device, VkPipeline pipeline)
@@ -1863,7 +1859,7 @@
if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
// TODO : This doesn't create deep copy of pQueueFamilyIndices so need to fix that if/when we want that data to be valid
- dev_data->bufferMap[pBuffer->handle] = unique_ptr<VkBufferCreateInfo>(new VkBufferCreateInfo(*pCreateInfo));
+ dev_data->bufferMap[*pBuffer] = unique_ptr<VkBufferCreateInfo>(new VkBufferCreateInfo(*pCreateInfo));
loader_platform_thread_unlock_mutex(&globalLock);
}
return result;
@@ -1875,7 +1871,7 @@
VkResult result = dev_data->device_dispatch_table->CreateBufferView(device, pCreateInfo, pView);
if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
- dev_data->bufferViewMap[pView->handle] = unique_ptr<VkBufferViewCreateInfo>(new VkBufferViewCreateInfo(*pCreateInfo));
+ dev_data->bufferViewMap[*pView] = unique_ptr<VkBufferViewCreateInfo>(new VkBufferViewCreateInfo(*pCreateInfo));
loader_platform_thread_unlock_mutex(&globalLock);
}
return result;
@@ -1887,7 +1883,7 @@
VkResult result = dev_data->device_dispatch_table->CreateImage(device, pCreateInfo, pImage);
if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
- dev_data->imageMap[pImage->handle] = unique_ptr<VkImageCreateInfo>(new VkImageCreateInfo(*pCreateInfo));
+ dev_data->imageMap[*pImage] = unique_ptr<VkImageCreateInfo>(new VkImageCreateInfo(*pCreateInfo));
loader_platform_thread_unlock_mutex(&globalLock);
}
return result;
@@ -1899,7 +1895,7 @@
VkResult result = dev_data->device_dispatch_table->CreateImageView(device, pCreateInfo, pView);
if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
- dev_data->imageViewMap[pView->handle] = unique_ptr<VkImageViewCreateInfo>(new VkImageViewCreateInfo(*pCreateInfo));
+ dev_data->imageViewMap[*pView] = unique_ptr<VkImageViewCreateInfo>(new VkImageViewCreateInfo(*pCreateInfo));
loader_platform_thread_unlock_mutex(&globalLock);
}
return result;
@@ -1915,7 +1911,7 @@
if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
- dev_data->shaderStageMap[pShader->handle] = pCreateInfo->stage;
+ dev_data->shaderStageMap[*pShader] = pCreateInfo->stage;
loader_platform_thread_unlock_mutex(&globalLock);
}
@@ -1987,7 +1983,7 @@
loader_platform_thread_lock_mutex(&globalLock);
for (i=0; i<count; i++) {
pPipeNode[i]->pipeline = pPipelines[i];
- dev_data->pipelineMap[pPipeNode[i]->pipeline.handle] = pPipeNode[i];
+ dev_data->pipelineMap[pPipeNode[i]->pipeline] = pPipeNode[i];
}
loader_platform_thread_unlock_mutex(&globalLock);
} else {
@@ -2011,7 +2007,7 @@
VkResult result = dev_data->device_dispatch_table->CreateSampler(device, pCreateInfo, pSampler);
if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
- dev_data->sampleMap[pSampler->handle] = unique_ptr<SAMPLER_NODE>(new SAMPLER_NODE(pSampler, pCreateInfo));
+ dev_data->sampleMap[*pSampler] = unique_ptr<SAMPLER_NODE>(new SAMPLER_NODE(pSampler, pCreateInfo));
loader_platform_thread_unlock_mutex(&globalLock);
}
return result;
@@ -2024,7 +2020,7 @@
if (VK_SUCCESS == result) {
LAYOUT_NODE* pNewNode = new LAYOUT_NODE;
if (NULL == pNewNode) {
- if (log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, (*pSetLayout).handle, 0, DRAWSTATE_OUT_OF_MEMORY, "DS",
+ if (log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, (uint64_t) *pSetLayout, 0, DRAWSTATE_OUT_OF_MEMORY, "DS",
"Out of memory while attempting to allocate LAYOUT_NODE in vkCreateDescriptorSetLayout()"))
return VK_ERROR_VALIDATION_FAILED;
}
@@ -2060,7 +2056,7 @@
assert(pNewNode->endIndex >= pNewNode->startIndex);
// Put new node at Head of global Layer list
loader_platform_thread_lock_mutex(&globalLock);
- dev_data->layoutMap[pSetLayout->handle] = pNewNode;
+ dev_data->layoutMap[*pSetLayout] = pNewNode;
loader_platform_thread_unlock_mutex(&globalLock);
}
return result;
@@ -2071,7 +2067,7 @@
layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
VkResult result = dev_data->device_dispatch_table->CreatePipelineLayout(device, pCreateInfo, pPipelineLayout);
if (VK_SUCCESS == result) {
- PIPELINE_LAYOUT_NODE plNode = dev_data->pipelineLayoutMap[pPipelineLayout->handle];
+ PIPELINE_LAYOUT_NODE plNode = dev_data->pipelineLayoutMap[*pPipelineLayout];
plNode.descriptorSetLayouts.resize(pCreateInfo->descriptorSetCount);
uint32_t i = 0;
for (i=0; i<pCreateInfo->descriptorSetCount; ++i) {
@@ -2091,17 +2087,17 @@
VkResult result = dev_data->device_dispatch_table->CreateDescriptorPool(device, pCreateInfo, pDescriptorPool);
if (VK_SUCCESS == result) {
// Insert this pool into Global Pool LL at head
- if (log_msg(dev_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DESCRIPTOR_POOL, (*pDescriptorPool).handle, 0, DRAWSTATE_OUT_OF_MEMORY, "DS",
- "Created Descriptor Pool %#" PRIxLEAST64, (*pDescriptorPool).handle))
+ if (log_msg(dev_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DESCRIPTOR_POOL, (uint64_t) *pDescriptorPool, 0, DRAWSTATE_OUT_OF_MEMORY, "DS",
+ "Created Descriptor Pool %#" PRIxLEAST64, (uint64_t) *pDescriptorPool))
return VK_ERROR_VALIDATION_FAILED;
loader_platform_thread_lock_mutex(&globalLock);
POOL_NODE* pNewNode = new POOL_NODE(*pDescriptorPool, pCreateInfo);
if (NULL == pNewNode) {
- if (log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_POOL, (*pDescriptorPool).handle, 0, DRAWSTATE_OUT_OF_MEMORY, "DS",
+ if (log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_POOL, (uint64_t) *pDescriptorPool, 0, DRAWSTATE_OUT_OF_MEMORY, "DS",
"Out of memory while attempting to allocate POOL_NODE in vkCreateDescriptorPool()"))
return VK_ERROR_VALIDATION_FAILED;
} else {
- dev_data->poolMap[pDescriptorPool->handle] = pNewNode;
+ dev_data->poolMap[*pDescriptorPool] = pNewNode;
}
loader_platform_thread_unlock_mutex(&globalLock);
} else {
@@ -2127,8 +2123,8 @@
// Verify that requested descriptorSets are available in pool
POOL_NODE *pPoolNode = getPoolNode(dev_data, pAllocInfo->descriptorPool);
if (!pPoolNode) {
- skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_POOL, pAllocInfo->descriptorPool.handle, 0, DRAWSTATE_INVALID_POOL, "DS",
- "Unable to find pool node for pool %#" PRIxLEAST64 " specified in vkAllocDescriptorSets() call", pAllocInfo->descriptorPool.handle);
+ skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_POOL, (uint64_t) pAllocInfo->descriptorPool, 0, DRAWSTATE_INVALID_POOL, "DS",
+ "Unable to find pool node for pool %#" PRIxLEAST64 " specified in vkAllocDescriptorSets() call", (uint64_t) pAllocInfo->descriptorPool);
} else { // Make sure pool has all the available descriptors before calling down chain
skipCall |= validate_descriptor_availability_in_pool(dev_data, pPoolNode, pAllocInfo->count, pAllocInfo->pSetLayouts);
}
@@ -2143,12 +2139,12 @@
"AllocDescriptorSets called with 0 count");
}
for (uint32_t i = 0; i < pAllocInfo->count; i++) {
- log_msg(dev_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, pDescriptorSets[i].handle, 0, DRAWSTATE_NONE, "DS",
- "Created Descriptor Set %#" PRIxLEAST64, pDescriptorSets[i].handle);
+ log_msg(dev_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pDescriptorSets[i], 0, DRAWSTATE_NONE, "DS",
+ "Created Descriptor Set %#" PRIxLEAST64, (uint64_t) pDescriptorSets[i]);
// Create new set node and add to head of pool nodes
SET_NODE* pNewNode = new SET_NODE;
if (NULL == pNewNode) {
- if (log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, pDescriptorSets[i].handle, 0, DRAWSTATE_OUT_OF_MEMORY, "DS",
+ if (log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pDescriptorSets[i], 0, DRAWSTATE_OUT_OF_MEMORY, "DS",
"Out of memory while attempting to allocate SET_NODE in vkAllocDescriptorSets()"))
return VK_ERROR_VALIDATION_FAILED;
} else {
@@ -2161,8 +2157,8 @@
pPoolNode->pSets = pNewNode;
LAYOUT_NODE* pLayout = getLayoutNode(dev_data, pAllocInfo->pSetLayouts[i]);
if (NULL == pLayout) {
- if (log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, pAllocInfo->pSetLayouts[i].handle, 0, DRAWSTATE_INVALID_LAYOUT, "DS",
- "Unable to find set layout node for layout %#" PRIxLEAST64 " specified in vkAllocDescriptorSets() call", pAllocInfo->pSetLayouts[i].handle))
+ if (log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, (uint64_t) pAllocInfo->pSetLayouts[i], 0, DRAWSTATE_INVALID_LAYOUT, "DS",
+ "Unable to find set layout node for layout %#" PRIxLEAST64 " specified in vkAllocDescriptorSets() call", (uint64_t) pAllocInfo->pSetLayouts[i]))
return VK_ERROR_VALIDATION_FAILED;
}
pNewNode->pLayout = pLayout;
@@ -2174,7 +2170,7 @@
pNewNode->ppDescriptors = new GENERIC_HEADER*[descriptorArraySize];
memset(pNewNode->ppDescriptors, 0, descriptorArraySize);
}
- dev_data->setMap[pDescriptorSets[i].handle] = pNewNode;
+ dev_data->setMap[pDescriptorSets[i]] = pNewNode;
}
}
}
@@ -2198,7 +2194,7 @@
if (VK_SUCCESS == result) {
// For each freed descriptor add it back into the pool as available
for (uint32_t i=0; i<count; ++i) {
- SET_NODE* pSet = dev_data->setMap[pDescriptorSets[i].handle]; // getSetNode() without locking
+ SET_NODE* pSet = dev_data->setMap[pDescriptorSets[i]]; // getSetNode() without locking
LAYOUT_NODE* pLayout = pSet->pLayout;
uint32_t typeIndex = 0, typeCount = 0;
for (uint32_t j=0; j<pLayout->createInfo.count; ++j) {
@@ -2248,13 +2244,13 @@
GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
if (pCB) {
if (pCB->level == VK_CMD_BUFFER_LEVEL_PRIMARY) {
- if (pBeginInfo->renderPass.handle || pBeginInfo->framebuffer.handle) {
+ if (pBeginInfo->renderPass || pBeginInfo->framebuffer) {
// These should be NULL for a Primary CB
skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_BEGIN_CB_INVALID_STATE, "DS",
"vkAllocCommandBuffers(): Primary Command Buffer (%p) may not specify framebuffer or renderpass parameters", (void*)cmdBuffer);
}
} else {
- if (!pBeginInfo->renderPass.handle || !pBeginInfo->framebuffer.handle) {
+ if (!pBeginInfo->renderPass || !pBeginInfo->framebuffer) {
// These should NOT be null for an Secondary CB
skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_BEGIN_CB_INVALID_STATE, "DS",
"vkAllocCommandBuffers(): Secondary Command Buffers (%p) must specify framebuffer and renderpass parameters", (void*)cmdBuffer);
@@ -2327,14 +2323,14 @@
updateCBTracking(pCB);
skipCall |= addCmd(dev_data, pCB, CMD_BINDPIPELINE);
if ((VK_PIPELINE_BIND_POINT_COMPUTE == pipelineBindPoint) && (pCB->activeRenderPass)) {
- skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE, pipeline.handle,
+ skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE, (uint64_t) pipeline,
0, DRAWSTATE_INVALID_RENDERPASS_CMD, "DS",
"Incorrectly binding compute pipeline (%#" PRIxLEAST64 ") during active RenderPass (%#" PRIxLEAST64 ")",
- pipeline.handle, pCB->activeRenderPass.handle);
+ (uint64_t) pipeline, (uint64_t) pCB->activeRenderPass);
} else if ((VK_PIPELINE_BIND_POINT_GRAPHICS == pipelineBindPoint) && (!pCB->activeRenderPass)) {
- skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE, pipeline.handle,
+ skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE, (uint64_t) pipeline,
0, DRAWSTATE_NO_ACTIVE_RENDERPASS, "DS", "Incorrectly binding graphics pipeline "
- " (%#" PRIxLEAST64 ") without an active RenderPass", pipeline.handle);
+ " (%#" PRIxLEAST64 ") without an active RenderPass", (uint64_t) pipeline);
} else {
PIPELINE_NODE* pPN = getPipeline(dev_data, pipeline);
if (pPN) {
@@ -2345,9 +2341,9 @@
loader_platform_thread_unlock_mutex(&globalLock);
skipCall |= validatePipelineState(dev_data, pCB, pipelineBindPoint, pipeline);
} else {
- skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE, pipeline.handle,
+ skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE, (uint64_t) pipeline,
0, DRAWSTATE_INVALID_PIPELINE, "DS",
- "Attempt to bind Pipeline %#" PRIxLEAST64 " that doesn't exist!", (void*)pipeline.handle);
+ "Attempt to bind Pipeline %#" PRIxLEAST64 " that doesn't exist!", (void*)pipeline);
}
}
} else {
@@ -2595,7 +2591,7 @@
if (pCB->state == CB_UPDATE_ACTIVE) {
if ((VK_PIPELINE_BIND_POINT_COMPUTE == pipelineBindPoint) && (pCB->activeRenderPass)) {
skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_RENDERPASS_CMD, "DS",
- "Incorrectly binding compute DescriptorSets during active RenderPass (%#" PRIxLEAST64 ")", pCB->activeRenderPass.handle);
+ "Incorrectly binding compute DescriptorSets during active RenderPass (%#" PRIxLEAST64 ")", (uint64_t) pCB->activeRenderPass);
} else if ((VK_PIPELINE_BIND_POINT_GRAPHICS == pipelineBindPoint) && (!pCB->activeRenderPass)) {
skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NO_ACTIVE_RENDERPASS, "DS",
"Incorrectly binding graphics DescriptorSets without an active RenderPass");
@@ -2608,14 +2604,14 @@
pCB->lastBoundPipelineLayout = layout;
pCB->boundDescriptorSets.push_back(pDescriptorSets[i]);
loader_platform_thread_unlock_mutex(&globalLock);
- skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, pDescriptorSets[i].handle, 0, DRAWSTATE_NONE, "DS",
- "DS %#" PRIxLEAST64 " bound on pipeline %s", pDescriptorSets[i].handle, string_VkPipelineBindPoint(pipelineBindPoint));
+ skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pDescriptorSets[i], 0, DRAWSTATE_NONE, "DS",
+ "DS %#" PRIxLEAST64 " bound on pipeline %s", (uint64_t) pDescriptorSets[i], string_VkPipelineBindPoint(pipelineBindPoint));
if (!pSet->pUpdateStructs)
- skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, pDescriptorSets[i].handle, 0, DRAWSTATE_DESCRIPTOR_SET_NOT_UPDATED, "DS",
- "DS %#" PRIxLEAST64 " bound but it was never updated. You may want to either update it or not bind it.", pDescriptorSets[i].handle);
+ skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pDescriptorSets[i], 0, DRAWSTATE_DESCRIPTOR_SET_NOT_UPDATED, "DS",
+ "DS %#" PRIxLEAST64 " bound but it was never updated. You may want to either update it or not bind it.", (uint64_t) pDescriptorSets[i]);
} else {
- skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, pDescriptorSets[i].handle, 0, DRAWSTATE_INVALID_SET, "DS",
- "Attempt to bind DS %#" PRIxLEAST64 " that doesn't exist!", pDescriptorSets[i].handle);
+ skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pDescriptorSets[i], 0, DRAWSTATE_INVALID_SET, "DS",
+ "Attempt to bind DS %#" PRIxLEAST64 " that doesn't exist!", (uint64_t) pDescriptorSets[i]);
}
}
updateCBTracking(pCB);
@@ -2997,7 +2993,7 @@
// Validate that attachment is in reference list of active subpass
if (pCB->activeRenderPass) {
- const VkRenderPassCreateInfo *pRPCI = dev_data->renderPassMap[pCB->activeRenderPass.handle];
+ const VkRenderPassCreateInfo *pRPCI = dev_data->renderPassMap[pCB->activeRenderPass];
const VkSubpassDescription *pSD = &pRPCI->pSubpasses[pCB->activeSubpass];
for (uint32_t attachment_idx = 0; attachment_idx < attachmentCount; attachment_idx++) {
@@ -3268,7 +3264,7 @@
localFBCI->pAttachments = new VkImageView[localFBCI->attachmentCount];
memcpy((void*)localFBCI->pAttachments, pCreateInfo->pAttachments, localFBCI->attachmentCount*sizeof(VkImageView));
}
- dev_data->frameBufferMap[pFramebuffer->handle] = localFBCI;
+ dev_data->frameBufferMap[*pFramebuffer] = localFBCI;
}
return result;
}
@@ -3475,7 +3471,7 @@
localRPCI->pDependencies = new VkSubpassDependency[localRPCI->dependencyCount];
memcpy((void*)localRPCI->pDependencies, pCreateInfo->pDependencies, localRPCI->dependencyCount*sizeof(VkSubpassDependency));
}
- dev_data->renderPassMap[pRenderPass->handle] = localRPCI;
+ dev_data->renderPassMap[*pRenderPass] = localRPCI;
}
return result;
}
diff --git a/layers/image.cpp b/layers/image.cpp
index 26f58fd..b741a4c 100644
--- a/layers/image.cpp
+++ b/layers/image.cpp
@@ -51,7 +51,7 @@
debug_report_data *report_data;
std::vector<VkDbgMsgCallback> logging_callback;
VkPhysicalDevice physicalDevice;
- unordered_map<uint64_t, IMAGE_STATE> imageMap;
+ unordered_map<VkImage, IMAGE_STATE> imageMap;
layer_data() :
report_data(nullptr),
@@ -295,7 +295,7 @@
VkResult result = get_dispatch_table(image_device_table_map, device)->CreateImage(device, pCreateInfo, pImage);
if(result == VK_SUCCESS) {
- device_data->imageMap[pImage->handle] = IMAGE_STATE(pCreateInfo);
+ device_data->imageMap[*pImage] = IMAGE_STATE(pCreateInfo);
}
return result;
}
@@ -303,7 +303,7 @@
VK_LAYER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image)
{
layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
- device_data->imageMap.erase(image.handle);
+ device_data->imageMap.erase(image);
get_dispatch_table(image_device_table_map, device)->DestroyImage(device, image);
}
@@ -388,18 +388,18 @@
{
VkBool32 skipCall = VK_FALSE;
layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
- auto imageEntry = device_data->imageMap.find(pCreateInfo->image.handle);
+ auto imageEntry = device_data->imageMap.find(pCreateInfo->image);
if (imageEntry != device_data->imageMap.end()) {
if (pCreateInfo->subresourceRange.baseMipLevel >= imageEntry->second.mipLevels) {
std::stringstream ss;
ss << "vkCreateImageView called with baseMipLevel " << pCreateInfo->subresourceRange.baseMipLevel
- << " for image " << pCreateInfo->image.handle << " that only has " << imageEntry->second.mipLevels << " mip levels.";
+ << " for image " << pCreateInfo->image << " that only has " << imageEntry->second.mipLevels << " mip levels.";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, IMAGE_VIEW_CREATE_ERROR, "IMAGE", ss.str().c_str());
}
if (pCreateInfo->subresourceRange.baseArrayLayer >= imageEntry->second.arraySize) {
std::stringstream ss;
ss << "vkCreateImageView called with baseArrayLayer " << pCreateInfo->subresourceRange.baseArrayLayer << " for image "
- << pCreateInfo->image.handle << " that only has " << imageEntry->second.arraySize << " mip levels.";
+ << pCreateInfo->image << " that only has " << imageEntry->second.arraySize << " mip levels.";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, IMAGE_VIEW_CREATE_ERROR, "IMAGE", ss.str().c_str());
}
if (!pCreateInfo->subresourceRange.numLevels) {
@@ -423,20 +423,20 @@
std::stringstream ss;
ss << "vkCreateImageView: Color image formats must have the VK_IMAGE_ASPECT_COLOR_BIT set";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE,
- (uint64_t)pCreateInfo->image.handle, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
+ (uint64_t)pCreateInfo->image, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
}
if ((aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) != aspectMask) {
std::stringstream ss;
ss << "vkCreateImageView: Color image formats must have ONLY the VK_IMAGE_ASPECT_COLOR_BIT set";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE,
- (uint64_t)pCreateInfo->image.handle, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
+ (uint64_t)pCreateInfo->image, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
}
if (VK_FALSE == vk_format_is_color(ivciFormat)) {
std::stringstream ss;
ss << "vkCreateImageView: The image view's format can differ from the parent image's format, but both must be "
<< "color formats. ImageFormat is " << string_VkFormat(imageFormat) << " ImageViewFormat is " << string_VkFormat(ivciFormat);
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE,
- (uint64_t)pCreateInfo->image.handle, 0, IMAGE_INVALID_FORMAT, "IMAGE", ss.str().c_str());
+ (uint64_t)pCreateInfo->image, 0, IMAGE_INVALID_FORMAT, "IMAGE", ss.str().c_str());
}
// TODO: Uncompressed formats are compatible if they occupy they same number of bits per pixel.
// Compressed formats are compatible if the only difference between them is the numerical type of
@@ -447,39 +447,39 @@
std::stringstream ss;
ss << "vkCreateImageView: Combination depth/stencil image formats must have both VK_IMAGE_ASPECT_DEPTH_BIT and VK_IMAGE_ASPECT_STENCIL_BIT set";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE,
- (uint64_t)pCreateInfo->image.handle, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
+ (uint64_t)pCreateInfo->image, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
}
if ((aspectMask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) != aspectMask) {
std::stringstream ss;
ss << "vkCreateImageView: Combination depth/stencil image formats can have only the VK_IMAGE_ASPECT_DEPTH_BIT and VK_IMAGE_ASPECT_STENCIL_BIT set";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE,
- (uint64_t)pCreateInfo->image.handle, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
+ (uint64_t)pCreateInfo->image, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
}
} else if (vk_format_is_depth_only(imageFormat)) {
if ((aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) != VK_IMAGE_ASPECT_DEPTH_BIT) {
std::stringstream ss;
ss << "vkCreateImageView: Depth-only image formats must have the VK_IMAGE_ASPECT_DEPTH_BIT set";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE,
- (uint64_t)pCreateInfo->image.handle, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
+ (uint64_t)pCreateInfo->image, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
}
if ((aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) != aspectMask) {
std::stringstream ss;
ss << "vkCreateImageView: Depth-only image formats can have only the VK_IMAGE_ASPECT_DEPTH_BIT set";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE,
- (uint64_t)pCreateInfo->image.handle, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
+ (uint64_t)pCreateInfo->image, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
}
} else if (vk_format_is_stencil_only(imageFormat)) {
if ((aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) != VK_IMAGE_ASPECT_STENCIL_BIT) {
std::stringstream ss;
ss << "vkCreateImageView: Stencil-only image formats must have the VK_IMAGE_ASPECT_STENCIL_BIT set";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE,
- (uint64_t)pCreateInfo->image.handle, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
+ (uint64_t)pCreateInfo->image, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
}
if ((aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) != aspectMask) {
std::stringstream ss;
ss << "vkCreateImageView: Stencil-only image formats can have only the VK_IMAGE_ASPECT_STENCIL_BIT set";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE,
- (uint64_t)pCreateInfo->image.handle, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
+ (uint64_t)pCreateInfo->image, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
}
}
}
@@ -557,8 +557,8 @@
{
VkBool32 skipCall = VK_FALSE;
layer_data *device_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- auto srcImageEntry = device_data->imageMap.find(srcImage.handle);
- auto destImageEntry = device_data->imageMap.find(destImage.handle);
+ auto srcImageEntry = device_data->imageMap.find(srcImage);
+ auto destImageEntry = device_data->imageMap.find(destImage);
// For each region, src and dst number of layers should not be zero
// For each region, src and dst number of layers must match
@@ -758,8 +758,8 @@
VkBool32 skipCall = VK_FALSE;
layer_data *device_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- auto srcImageEntry = device_data->imageMap.find(srcImage.handle);
- auto destImageEntry = device_data->imageMap.find(destImage.handle);
+ auto srcImageEntry = device_data->imageMap.find(srcImage);
+ auto destImageEntry = device_data->imageMap.find(destImage);
if ((srcImageEntry != device_data->imageMap.end()) &&
(destImageEntry != device_data->imageMap.end())) {
@@ -877,8 +877,8 @@
{
VkBool32 skipCall = VK_FALSE;
layer_data *device_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
- auto srcImageEntry = device_data->imageMap.find(srcImage.handle);
- auto destImageEntry = device_data->imageMap.find(destImage.handle);
+ auto srcImageEntry = device_data->imageMap.find(srcImage);
+ auto destImageEntry = device_data->imageMap.find(destImage);
// For each region, the number of layers in the image subresource should not be zero
// For each region, src and dest image aspect must be color only
@@ -945,7 +945,7 @@
layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
VkFormat format;
- auto imageEntry = device_data->imageMap.find(image.handle);
+ auto imageEntry = device_data->imageMap.find(image);
// Validate that image aspects match formats
if (imageEntry != device_data->imageMap.end()) {
@@ -955,7 +955,7 @@
std::stringstream ss;
ss << "vkGetImageSubresourceLayout: For color formats, the aspect field of VkImageSubresource must be VK_IMAGE_ASPECT_COLOR.";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE,
- (uint64_t)image.handle, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
+ (uint64_t)image, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
}
} else if (vk_format_is_depth_or_stencil(format)) {
if ((pSubresource->aspect != VK_IMAGE_ASPECT_DEPTH_BIT) &&
@@ -963,7 +963,7 @@
std::stringstream ss;
ss << "vkGetImageSubresourceLayout: For depth/stencil formats, the aspect selects either the depth or stencil image aspect.";
skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE,
- (uint64_t)image.handle, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
+ (uint64_t)image, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
}
}
}
diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp
index ffadf24..bd4cb96 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -46,7 +46,7 @@
// WSI Image Objects bypass usual Image Object creation methods. A special Memory
// Object value will be used to identify them internally.
-static const VkDeviceMemory MEMTRACKER_SWAP_CHAIN_IMAGE_KEY = static_cast<VkDeviceMemory>(-1);
+static const VkDeviceMemory MEMTRACKER_SWAP_CHAIN_IMAGE_KEY = (VkDeviceMemory)(-1);
struct layer_data {
debug_report_data *report_data;
@@ -74,11 +74,11 @@
// Maps for tracking key structs related to MemTracker state
unordered_map<VkCmdBuffer, MT_CB_INFO> cbMap;
-unordered_map<uint64_t, MT_MEM_OBJ_INFO> memObjMap;
-unordered_map<uint64_t, MT_FENCE_INFO> fenceMap; // Map fence to fence info
+unordered_map<VkDeviceMemory, MT_MEM_OBJ_INFO> memObjMap;
+unordered_map<VkFence, MT_FENCE_INFO> fenceMap; // Map fence to fence info
unordered_map<VkQueue, MT_QUEUE_INFO> queueMap;
-unordered_map<uint64_t, MT_SWAP_CHAIN_INFO*> swapchainMap;
-unordered_map<uint64_t, MtSemaphoreState> semaphoreMap;
+unordered_map<VkSwapchainKHR, MT_SWAP_CHAIN_INFO*> swapchainMap;
+unordered_map<VkSemaphore, MtSemaphoreState> semaphoreMap;
// Images and Buffers are 2 objects that can have memory bound to them so they get special treatment
unordered_map<uint64_t, MT_OBJ_BINDING_INFO> imageMap;
@@ -153,7 +153,7 @@
{
MT_SWAP_CHAIN_INFO* pInfo = new MT_SWAP_CHAIN_INFO;
memcpy(&pInfo->createInfo, pCI, sizeof(VkSwapchainCreateInfoKHR));
- swapchainMap[swapchain.handle] = pInfo;
+ swapchainMap[swapchain] = pInfo;
}
// Add new CBInfo for this cb to map container
@@ -240,14 +240,14 @@
*fenceId = g_currentFenceId++;
// If no fence, create an internal fence to track the submissions
- if (fence.handle != 0) {
- fenceMap[fence.handle].fenceId = *fenceId;
- fenceMap[fence.handle].queue = queue;
+ if (fence != VK_NULL_HANDLE) {
+ fenceMap[fence].fenceId = *fenceId;
+ fenceMap[fence].queue = queue;
// Validate that fence is in UNSIGNALED state
- VkFenceCreateInfo* pFenceCI = &(fenceMap[fence.handle].createInfo);
+ VkFenceCreateInfo* pFenceCI = &(fenceMap[fence].createInfo);
if (pFenceCI->flags & VK_FENCE_CREATE_SIGNALED_BIT) {
- skipCall = log_msg(mdd(queue), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_FENCE, fence.handle, 0, MEMTRACK_INVALID_FENCE_STATE, "MEM",
- "Fence %#" PRIxLEAST64 " submitted in SIGNALED state. Fences must be reset before being submitted", fence.handle);
+ skipCall = log_msg(mdd(queue), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_FENCE, (uint64_t) fence, 0, MEMTRACK_INVALID_FENCE_STATE, "MEM",
+ "Fence %#" PRIxLEAST64 " submitted in SIGNALED state. Fences must be reset before being submitted", (uint64_t) fence);
}
} else {
// TODO : Do we need to create an internal fence here for tracking purposes?
@@ -261,14 +261,14 @@
static void delete_fence_info(
VkFence fence)
{
- fenceMap.erase(fence.handle);
+ fenceMap.erase(fence);
}
// Record information when a fence is known to be signalled
static void update_fence_tracking(
VkFence fence)
{
- auto fence_item = fenceMap.find(fence.handle);
+ auto fence_item = fenceMap.find(fence);
if (fence_item != fenceMap.end()) {
MT_FENCE_INFO *pCurFenceInfo = &(*fence_item).second;
VkQueue queue = pCurFenceInfo->queue;
@@ -282,7 +282,7 @@
}
// Update fence state in fenceCreateInfo structure
- auto pFCI = &(fenceMap[fence.handle].createInfo);
+ auto pFCI = &(fenceMap[fence].createInfo);
pFCI->flags = static_cast<VkFenceCreateFlags>(pFCI->flags | VK_FENCE_CREATE_SIGNALED_BIT);
}
@@ -337,10 +337,10 @@
char const* func_name, char const* usage_string)
{
VkBool32 skipCall = VK_FALSE;
- MT_OBJ_BINDING_INFO* pBindInfo = get_object_binding_info(image.handle, VK_OBJECT_TYPE_IMAGE);
+ MT_OBJ_BINDING_INFO* pBindInfo = get_object_binding_info((uint64_t) image, VK_OBJECT_TYPE_IMAGE);
if (pBindInfo) {
skipCall = validate_usage_flags(disp_obj, pBindInfo->create_info.image.usage, desired, strict,
- image.handle, VK_OBJECT_TYPE_IMAGE, "image", func_name, usage_string);
+ (uint64_t) image, VK_OBJECT_TYPE_IMAGE, "image", func_name, usage_string);
}
return skipCall;
}
@@ -352,10 +352,10 @@
char const* func_name, char const* usage_string)
{
VkBool32 skipCall = VK_FALSE;
- MT_OBJ_BINDING_INFO* pBindInfo = get_object_binding_info(buffer.handle, VK_OBJECT_TYPE_BUFFER);
+ MT_OBJ_BINDING_INFO* pBindInfo = get_object_binding_info((uint64_t) buffer, VK_OBJECT_TYPE_BUFFER);
if (pBindInfo) {
skipCall = validate_usage_flags(disp_obj, pBindInfo->create_info.buffer.usage, desired, strict,
- buffer.handle, VK_OBJECT_TYPE_BUFFER, "buffer", func_name, usage_string);
+ (uint64_t) buffer, VK_OBJECT_TYPE_BUFFER, "buffer", func_name, usage_string);
}
return skipCall;
}
@@ -363,9 +363,9 @@
// Return ptr to info in map container containing mem, or NULL if not found
// Calls to this function should be wrapped in mutex
static MT_MEM_OBJ_INFO* get_mem_obj_info(
- const uint64_t device_mem_handle)
+ VkDeviceMemory mem)
{
- auto item = memObjMap.find(device_mem_handle);
+ auto item = memObjMap.find(mem);
if (item != memObjMap.end()) {
return &(*item).second;
} else {
@@ -380,12 +380,12 @@
{
assert(object != NULL);
- memcpy(&memObjMap[mem.handle].allocInfo, pAllocInfo, sizeof(VkMemoryAllocInfo));
+ memcpy(&memObjMap[mem].allocInfo, pAllocInfo, sizeof(VkMemoryAllocInfo));
// TODO: Update for real hardware, actually process allocation info structures
- memObjMap[mem.handle].allocInfo.pNext = NULL;
- memObjMap[mem.handle].object = object;
- memObjMap[mem.handle].refCount = 0;
- memObjMap[mem.handle].mem = mem;
+ memObjMap[mem].allocInfo.pNext = NULL;
+ memObjMap[mem].object = object;
+ memObjMap[mem].refCount = 0;
+ memObjMap[mem].mem = mem;
}
// Find CB Info and add mem reference to list container
@@ -401,11 +401,11 @@
if (mem != MEMTRACKER_SWAP_CHAIN_IMAGE_KEY) {
// First update CB binding in MemObj mini CB list
- MT_MEM_OBJ_INFO* pMemInfo = get_mem_obj_info(mem.handle);
+ MT_MEM_OBJ_INFO* pMemInfo = get_mem_obj_info(mem);
if (!pMemInfo) {
skipCall = log_msg(mdd(cb), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)cb, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM",
"In %s, trying to bind mem obj %#" PRIxLEAST64 " to CB %p but no info for that mem obj.\n "
- "Was it correctly allocated? Did it already get freed?", apiName, mem.handle, cb);
+ "Was it correctly allocated? Did it already get freed?", apiName, (uint64_t) mem, cb);
} else {
// Search for cmd buffer object in memory object's binding list
VkBool32 found = VK_FALSE;
@@ -427,7 +427,7 @@
// TODO: keep track of all destroyed CBs so we know if this is a stale or simply invalid object
if (!pCBInfo) {
skipCall = log_msg(mdd(cb), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)cb, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM",
- "Trying to bind mem obj %#" PRIxLEAST64 " to CB %p but no info for that CB. Was CB incorrectly destroyed?", mem.handle, cb);
+ "Trying to bind mem obj %#" PRIxLEAST64 " to CB %p but no info for that CB. Was CB incorrectly destroyed?", (uint64_t) mem, cb);
} else {
// Search for memory object in cmd buffer's reference list
VkBool32 found = VK_FALSE;
@@ -462,7 +462,7 @@
if (pCBInfo->pMemObjList.size() > 0) {
list<VkDeviceMemory> mem_obj_list = pCBInfo->pMemObjList;
for (list<VkDeviceMemory>::iterator it=mem_obj_list.begin(); it!=mem_obj_list.end(); ++it) {
- MT_MEM_OBJ_INFO* pInfo = get_mem_obj_info((*it).handle);
+ MT_MEM_OBJ_INFO* pInfo = get_mem_obj_info(*it);
pInfo->pCmdBufferBindings.remove(cb);
pInfo->refCount--;
}
@@ -493,16 +493,16 @@
size_t objRefCount = pMemObjInfo->pObjBindings.size();
if ((pMemObjInfo->pCmdBufferBindings.size() + pMemObjInfo->pObjBindings.size()) != 0) {
- skipCall = log_msg(mdd(pMemObjInfo->object), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, pMemObjInfo->mem.handle, 0, MEMTRACK_FREED_MEM_REF, "MEM",
+ skipCall = log_msg(mdd(pMemObjInfo->object), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t) pMemObjInfo->mem, 0, MEMTRACK_FREED_MEM_REF, "MEM",
"Attempting to free memory object %#" PRIxLEAST64 " which still contains %lu references",
- pMemObjInfo->mem.handle, (cmdBufRefCount + objRefCount));
+ (uint64_t) pMemObjInfo->mem, (cmdBufRefCount + objRefCount));
}
if (cmdBufRefCount > 0 && pMemObjInfo->pCmdBufferBindings.size() > 0) {
for (list<VkCmdBuffer>::const_iterator it = pMemObjInfo->pCmdBufferBindings.begin(); it != pMemObjInfo->pCmdBufferBindings.end(); ++it) {
// TODO : cmdBuffer should be source Obj here
log_msg(mdd(pMemObjInfo->object), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)(*it), 0, MEMTRACK_FREED_MEM_REF, "MEM",
- "Command Buffer %p still has a reference to mem obj %#" PRIxLEAST64, (*it), pMemObjInfo->mem.handle);
+ "Command Buffer %p still has a reference to mem obj %#" PRIxLEAST64, (*it), (uint64_t) pMemObjInfo->mem);
}
// Clear the list of hanging references
pMemObjInfo->pCmdBufferBindings.clear();
@@ -511,7 +511,7 @@
if (objRefCount > 0 && pMemObjInfo->pObjBindings.size() > 0) {
for (auto it = pMemObjInfo->pObjBindings.begin(); it != pMemObjInfo->pObjBindings.end(); ++it) {
log_msg(mdd(pMemObjInfo->object), VK_DBG_REPORT_INFO_BIT, it->type, it->handle, 0, MEMTRACK_FREED_MEM_REF, "MEM",
- "VK Object %#" PRIxLEAST64 " still has a reference to mem obj %#" PRIxLEAST64, it->handle, pMemObjInfo->mem.handle);
+ "VK Object %#" PRIxLEAST64 " still has a reference to mem obj %#" PRIxLEAST64, it->handle, (uint64_t) pMemObjInfo->mem);
}
// Clear the list of hanging references
pMemObjInfo->pObjBindings.clear();
@@ -521,15 +521,15 @@
static VkBool32 deleteMemObjInfo(
void* object,
- const uint64_t device_mem_handle)
+ VkDeviceMemory mem)
{
VkBool32 skipCall = VK_FALSE;
- auto item = memObjMap.find(device_mem_handle);
+ auto item = memObjMap.find(mem);
if (item != memObjMap.end()) {
memObjMap.erase(item);
} else {
- skipCall = log_msg(mdd(object), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, device_mem_handle, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM",
- "Request to delete memory object %#" PRIxLEAST64 " not present in memory Object Map", device_mem_handle);
+ skipCall = log_msg(mdd(object), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t) mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM",
+ "Request to delete memory object %#" PRIxLEAST64 " not present in memory Object Map", (uint64_t) mem);
}
return skipCall;
}
@@ -552,7 +552,7 @@
if (pCBInfo->fenceId > pQueueInfo->lastRetiredId) {
log_msg(mdd(cb), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)cb, 0,
MEMTRACK_NONE, "MEM", "fence %#" PRIxLEAST64 " for CB %p has not been checked for completion",
- pCBInfo->lastSubmittedFence.handle, cb);
+ (uint64_t) pCBInfo->lastSubmittedFence, cb);
*complete = VK_FALSE;
}
}
@@ -566,16 +566,16 @@
{
VkBool32 skipCall = VK_FALSE;
// Parse global list to find info w/ mem
- MT_MEM_OBJ_INFO* pInfo = get_mem_obj_info(mem.handle);
+ MT_MEM_OBJ_INFO* pInfo = get_mem_obj_info(mem);
if (!pInfo) {
- skipCall = log_msg(mdd(object), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, mem.handle, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM",
+ skipCall = log_msg(mdd(object), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t) mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM",
"Couldn't find mem info object for %#" PRIxLEAST64 "\n Was %#" PRIxLEAST64 " never allocated or previously freed?",
- mem.handle, mem.handle);
+ (uint64_t) mem, (uint64_t) mem);
} else {
if (pInfo->allocInfo.allocationSize == 0 && !internal) {
- skipCall = log_msg(mdd(pInfo->object), VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, mem.handle, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM",
+ skipCall = log_msg(mdd(pInfo->object), VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t) mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM",
"Attempting to free memory associated with a Persistent Image, %#" PRIxLEAST64 ", "
- "this should not be explicitly freed\n", mem.handle);
+ "this should not be explicitly freed\n", (uint64_t) mem);
} else {
// Clear any CB bindings for completed CBs
// TODO : Is there a better place to do this?
@@ -601,7 +601,7 @@
skipCall |= reportMemReferencesAndCleanUp(pInfo);
}
// Delete mem obj info
- skipCall |= deleteMemObjInfo(object, mem.handle);
+ skipCall |= deleteMemObjInfo(object, mem);
}
}
return skipCall;
@@ -635,7 +635,7 @@
VkBool32 skipCall = VK_FALSE;
MT_OBJ_BINDING_INFO* pObjBindInfo = get_object_binding_info(handle, type);
if (pObjBindInfo) {
- MT_MEM_OBJ_INFO* pMemObjInfo = get_mem_obj_info(pObjBindInfo->mem.handle);
+ MT_MEM_OBJ_INFO* pMemObjInfo = get_mem_obj_info(pObjBindInfo->mem);
if (!pMemObjInfo) {
skipCall = log_msg(mdd(dispObj), VK_DBG_REPORT_WARN_BIT, type, handle, 0, MEMTRACK_MEM_OBJ_CLEAR_EMPTY_BINDINGS, "MEM",
"Attempting to clear mem binding on %s obj %#" PRIxLEAST64 " but it has no binding.",
@@ -649,7 +649,7 @@
pMemObjInfo->refCount--;
pMemObjInfo->pObjBindings.erase(it);
// TODO : Make sure this is a reasonable way to reset mem binding
- pObjBindInfo->mem.handle = 0;
+ pObjBindInfo->mem = VK_NULL_HANDLE;
clearSucceeded = VK_TRUE;
break;
}
@@ -657,7 +657,7 @@
if (VK_FALSE == clearSucceeded ) {
skipCall |= log_msg(mdd(dispObj), VK_DBG_REPORT_ERROR_BIT, type, handle, 0, MEMTRACK_INVALID_OBJECT, "MEM",
"While trying to clear mem binding for %s obj %#" PRIxLEAST64 ", unable to find that object referenced by mem obj %#" PRIxLEAST64,
- object_type_to_string(type), handle, pMemObjInfo->mem.handle);
+ object_type_to_string(type), handle, (uint64_t) pMemObjInfo->mem);
}
}
}
@@ -691,18 +691,18 @@
object_type_to_string(type), apiName, handle);
} else {
// non-null case so should have real mem obj
- MT_MEM_OBJ_INFO* pMemInfo = get_mem_obj_info(mem.handle);
+ MT_MEM_OBJ_INFO* pMemInfo = get_mem_obj_info(mem);
if (!pMemInfo) {
- skipCall |= log_msg(mdd(dispatch_object), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, mem.handle,
+ skipCall |= log_msg(mdd(dispatch_object), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t) mem,
0, MEMTRACK_INVALID_MEM_OBJ, "MEM", "In %s, while trying to bind mem for %s obj %#" PRIxLEAST64 ", couldn't find info for mem obj %#" PRIxLEAST64,
- object_type_to_string(type), apiName, handle, mem.handle);
+ object_type_to_string(type), apiName, handle, (uint64_t) mem);
} else {
// TODO : Need to track mem binding for obj and report conflict here
- MT_MEM_OBJ_INFO* pPrevBinding = get_mem_obj_info(pObjBindInfo->mem.handle);
+ MT_MEM_OBJ_INFO* pPrevBinding = get_mem_obj_info(pObjBindInfo->mem);
if (pPrevBinding != NULL) {
- skipCall |= log_msg(mdd(dispatch_object), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, mem.handle, 0, MEMTRACK_REBIND_OBJECT, "MEM",
+ skipCall |= log_msg(mdd(dispatch_object), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t) mem, 0, MEMTRACK_REBIND_OBJECT, "MEM",
"In %s, attempting to bind memory (%#" PRIxLEAST64 ") to object (%#" PRIxLEAST64 ") which has already been bound to mem object %#" PRIxLEAST64,
- apiName, mem.handle, handle, pPrevBinding->mem.handle);
+ apiName, (uint64_t) mem, handle, (uint64_t) pPrevBinding->mem);
}
else {
MT_OBJ_HANDLE_TYPE oht;
@@ -751,10 +751,10 @@
"In %s, attempting to update Binding of Obj(%#" PRIxLEAST64 ") that's not in global list()", apiName, handle);
}
// non-null case so should have real mem obj
- MT_MEM_OBJ_INFO* pInfo = get_mem_obj_info(mem.handle);
+ MT_MEM_OBJ_INFO* pInfo = get_mem_obj_info(mem);
if (!pInfo) {
- skipCall |= log_msg(mdd(dispObject), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, mem.handle, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM",
- "In %s, While trying to bind mem for obj %#" PRIxLEAST64 ", couldn't find info for mem obj %#" PRIxLEAST64, apiName, handle, mem.handle);
+ skipCall |= log_msg(mdd(dispObject), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t) mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM",
+ "In %s, While trying to bind mem for obj %#" PRIxLEAST64 ", couldn't find info for mem obj %#" PRIxLEAST64, apiName, handle, (uint64_t) mem);
} else {
// Search for object in memory object's binding list
VkBool32 found = VK_FALSE;
@@ -775,7 +775,7 @@
pInfo->refCount++;
}
// Need to set mem binding for this object
- MT_MEM_OBJ_INFO* pPrevBinding = get_mem_obj_info(pObjBindInfo->mem.handle);
+ MT_MEM_OBJ_INFO* pPrevBinding = get_mem_obj_info(pObjBindInfo->mem);
pObjBindInfo->mem = mem;
}
}
@@ -800,7 +800,7 @@
void* dispObj, const uint64_t handle, const VkDbgObjectType type, VkDeviceMemory *mem)
{
VkBool32 skipCall = VK_FALSE;
- mem->handle = 0;
+ *mem = VK_NULL_HANDLE;
MT_OBJ_BINDING_INFO* pObjBindInfo = get_object_binding_info(handle, type);
if (pObjBindInfo) {
if (pObjBindInfo->mem) {
@@ -843,7 +843,7 @@
log_msg(mdd(dispObj), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM",
" ===MemObjInfo at %p===", (void*)pInfo);
log_msg(mdd(dispObj), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM",
- " Mem object: %#" PRIxLEAST64, (void*)pInfo->mem.handle);
+ " Mem object: %#" PRIxLEAST64, (void*)pInfo->mem);
log_msg(mdd(dispObj), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM",
" Ref Count: %u", pInfo->refCount);
if (0 != pInfo->allocInfo.allocationSize) {
@@ -900,7 +900,7 @@
log_msg(mdd(dispObj), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM",
" CB Info (%p) has CB %p, fenceId %" PRIx64", and fence %#" PRIxLEAST64,
(void*)pCBInfo, (void*)pCBInfo->cmdBuffer, pCBInfo->fenceId,
- pCBInfo->lastSubmittedFence.handle);
+ (uint64_t) pCBInfo->lastSubmittedFence);
if (pCBInfo->pMemObjList.size() <= 0)
continue;
@@ -1048,7 +1048,7 @@
for (auto ii=memObjMap.begin(); ii!=memObjMap.end(); ++ii) {
pInfo = &(*ii).second;
if (pInfo->allocInfo.allocationSize != 0) {
- skipCall |= log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, pInfo->mem.handle, 0, MEMTRACK_MEMORY_LEAK, "MEM",
+ skipCall |= log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t) pInfo->mem, 0, MEMTRACK_MEMORY_LEAK, "MEM",
"Mem Object %p has not been freed. You should clean up this memory by calling "
"vkFreeMemory(%p) prior to vkDestroyDevice().", pInfo->mem, pInfo->mem);
}
@@ -1167,25 +1167,25 @@
for (uint32_t i = 0; i < submit->waitSemCount; i++) {
VkSemaphore sem = submit->pWaitSemaphores[i];
- if (semaphoreMap.find(sem.handle) != semaphoreMap.end()) {
- if (semaphoreMap[sem.handle] != MEMTRACK_SEMAPHORE_STATE_SIGNALLED) {
- skipCall = log_msg(mdd(queue), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_SEMAPHORE, sem.handle,
+ if (semaphoreMap.find(sem) != semaphoreMap.end()) {
+ if (semaphoreMap[sem] != MEMTRACK_SEMAPHORE_STATE_SIGNALLED) {
+ skipCall = log_msg(mdd(queue), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_SEMAPHORE, (uint64_t) sem,
0, MEMTRACK_NONE, "SEMAPHORE",
"vkQueueSubmit: Semaphore must be in signaled state before passing to pWaitSemaphores");
}
- semaphoreMap[sem.handle] = MEMTRACK_SEMAPHORE_STATE_WAIT;
+ semaphoreMap[sem] = MEMTRACK_SEMAPHORE_STATE_WAIT;
}
}
for (uint32_t i = 0; i < submit->signalSemCount; i++) {
VkSemaphore sem = submit->pWaitSemaphores[i];
- if (semaphoreMap.find(sem.handle) != semaphoreMap.end()) {
- if (semaphoreMap[sem.handle] != MEMTRACK_SEMAPHORE_STATE_UNSET) {
- skipCall = log_msg(mdd(queue), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_SEMAPHORE, sem.handle,
+ if (semaphoreMap.find(sem) != semaphoreMap.end()) {
+ if (semaphoreMap[sem] != MEMTRACK_SEMAPHORE_STATE_UNSET) {
+ skipCall = log_msg(mdd(queue), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_SEMAPHORE, (uint64_t) sem,
0, MEMTRACK_NONE, "SEMAPHORE",
"vkQueueSubmit: Semaphore must not be currently signaled or in a wait state");
}
- semaphoreMap[sem.handle] = MEMTRACK_SEMAPHORE_STATE_SIGNALLED;
+ semaphoreMap[sem] = MEMTRACK_SEMAPHORE_STATE_SIGNALLED;
}
}
}
@@ -1202,8 +1202,8 @@
for (uint32_t i = 0; i < submit->waitSemCount; i++) {
VkSemaphore sem = submit->pWaitSemaphores[i];
- if (semaphoreMap.find(sem.handle) != semaphoreMap.end()) {
- semaphoreMap[sem.handle] = MEMTRACK_SEMAPHORE_STATE_UNSET;
+ if (semaphoreMap.find(sem) != semaphoreMap.end()) {
+ semaphoreMap[sem] = MEMTRACK_SEMAPHORE_STATE_UNSET;
}
}
}
@@ -1254,11 +1254,11 @@
VkBool32 skipCall = VK_FALSE;
VkResult result = VK_ERROR_VALIDATION_FAILED;
loader_platform_thread_lock_mutex(&globalLock);
- MT_MEM_OBJ_INFO *pMemObj = get_mem_obj_info(mem.handle);
+ MT_MEM_OBJ_INFO *pMemObj = get_mem_obj_info(mem);
if ((memProps.memoryTypes[pMemObj->allocInfo.memoryTypeIndex].propertyFlags &
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0) {
- skipCall = log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, mem.handle, 0, MEMTRACK_INVALID_STATE, "MEM",
- "Mapping Memory without VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT set: mem obj %#" PRIxLEAST64, mem.handle);
+ skipCall = log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t) mem, 0, MEMTRACK_INVALID_STATE, "MEM",
+ "Mapping Memory without VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT set: mem obj %#" PRIxLEAST64, (uint64_t) mem);
}
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
@@ -1280,7 +1280,7 @@
{
loader_platform_thread_lock_mutex(&globalLock);
delete_fence_info(fence);
- auto item = fenceMap.find(fence.handle);
+ auto item = fenceMap.find(fence);
if (item != fenceMap.end()) {
fenceMap.erase(item);
}
@@ -1292,9 +1292,9 @@
{
VkBool32 skipCall = VK_FALSE;
loader_platform_thread_lock_mutex(&globalLock);
- auto item = bufferMap.find(buffer.handle);
+ auto item = bufferMap.find((uint64_t) buffer);
if (item != bufferMap.end()) {
- skipCall = clear_object_binding(device, buffer.handle, VK_OBJECT_TYPE_BUFFER);
+ skipCall = clear_object_binding(device, (uint64_t) buffer, VK_OBJECT_TYPE_BUFFER);
bufferMap.erase(item);
}
loader_platform_thread_unlock_mutex(&globalLock);
@@ -1307,9 +1307,9 @@
{
VkBool32 skipCall = VK_FALSE;
loader_platform_thread_lock_mutex(&globalLock);
- auto item = imageMap.find(image.handle);
+ auto item = imageMap.find((uint64_t) image);
if (item != imageMap.end()) {
- skipCall = clear_object_binding(device, image.handle, VK_OBJECT_TYPE_IMAGE);
+ skipCall = clear_object_binding(device, (uint64_t) image, VK_OBJECT_TYPE_IMAGE);
imageMap.erase(item);
}
loader_platform_thread_unlock_mutex(&globalLock);
@@ -1327,8 +1327,8 @@
VkResult result = VK_ERROR_VALIDATION_FAILED;
loader_platform_thread_lock_mutex(&globalLock);
// Track objects tied to memory
- VkBool32 skipCall = set_mem_binding(device, mem, buffer.handle, VK_OBJECT_TYPE_BUFFER, "vkBindBufferMemory");
- add_object_binding_info(buffer.handle, VK_OBJECT_TYPE_BUFFER, mem);
+ VkBool32 skipCall = set_mem_binding(device, mem, (uint64_t) buffer, VK_OBJECT_TYPE_BUFFER, "vkBindBufferMemory");
+ add_object_binding_info((uint64_t) buffer, VK_OBJECT_TYPE_BUFFER, mem);
print_mem_list(device);
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
@@ -1346,8 +1346,8 @@
VkResult result = VK_ERROR_VALIDATION_FAILED;
loader_platform_thread_lock_mutex(&globalLock);
// Track objects tied to memory
- VkBool32 skipCall = set_mem_binding(device, mem, image.handle, VK_OBJECT_TYPE_IMAGE, "vkBindImageMemory");
- add_object_binding_info(image.handle, VK_OBJECT_TYPE_IMAGE, mem);
+ VkBool32 skipCall = set_mem_binding(device, mem, (uint64_t) image, VK_OBJECT_TYPE_IMAGE, "vkBindImageMemory");
+ add_object_binding_info((uint64_t) image, VK_OBJECT_TYPE_IMAGE, mem);
print_mem_list(device);
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
@@ -1385,7 +1385,7 @@
VkResult result = VK_ERROR_VALIDATION_FAILED;
loader_platform_thread_lock_mutex(&globalLock);
// Track objects tied to memory
- VkBool32 skipCall = set_sparse_mem_binding(queue, pBindInfo->mem, image.handle, VK_OBJECT_TYPE_IMAGE, "vkQueueBindSparseImageOpaqeMemory");
+ VkBool32 skipCall = set_sparse_mem_binding(queue, pBindInfo->mem, (uint64_t) image, VK_OBJECT_TYPE_IMAGE, "vkQueueBindSparseImageOpaqeMemory");
print_mem_list(queue);
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
@@ -1403,7 +1403,7 @@
VkResult result = VK_ERROR_VALIDATION_FAILED;
loader_platform_thread_lock_mutex(&globalLock);
// Track objects tied to memory
- VkBool32 skipCall = set_sparse_mem_binding(queue, pBindInfo->mem, image.handle, VK_OBJECT_TYPE_IMAGE, "vkQueueBindSparseImageMemory");
+ VkBool32 skipCall = set_sparse_mem_binding(queue, pBindInfo->mem, (uint64_t) image, VK_OBJECT_TYPE_IMAGE, "vkQueueBindSparseImageMemory");
print_mem_list(queue);
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
@@ -1422,7 +1422,7 @@
VkResult result = VK_ERROR_VALIDATION_FAILED;
loader_platform_thread_lock_mutex(&globalLock);
// Track objects tied to memory
- VkBool32 skipCall = set_sparse_mem_binding(queue, pBindInfo->mem, buffer.handle, VK_OBJECT_TYPE_BUFFER, "VkQueueBindSparseBufferMemory");
+ VkBool32 skipCall = set_sparse_mem_binding(queue, pBindInfo->mem, (uint64_t) buffer, VK_OBJECT_TYPE_BUFFER, "VkQueueBindSparseBufferMemory");
print_mem_list(queue);
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
@@ -1440,7 +1440,7 @@
VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateFence(device, pCreateInfo, pFence);
if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
- MT_FENCE_INFO* pFI = &fenceMap[pFence->handle];
+ MT_FENCE_INFO* pFI = &fenceMap[*pFence];
memset(pFI, 0, sizeof(MT_FENCE_INFO));
memcpy(&(pFI->createInfo), pCreateInfo, sizeof(VkFenceCreateInfo));
loader_platform_thread_unlock_mutex(&globalLock);
@@ -1459,12 +1459,12 @@
loader_platform_thread_lock_mutex(&globalLock);
// Reset fence state in fenceCreateInfo structure
for (uint32_t i = 0; i < fenceCount; i++) {
- auto fence_item = fenceMap.find(pFences[i].handle);
+ auto fence_item = fenceMap.find(pFences[i]);
if (fence_item != fenceMap.end()) {
// Validate fences in SIGNALED state
if (!(fence_item->second.createInfo.flags & VK_FENCE_CREATE_SIGNALED_BIT)) {
- skipCall = log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_FENCE, pFences[i].handle, 0, MEMTRACK_INVALID_FENCE_STATE, "MEM",
- "Fence %#" PRIxLEAST64 " submitted to VkResetFences in UNSIGNALED STATE", pFences[i].handle);
+ skipCall = log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_FENCE, (uint64_t) pFences[i], 0, MEMTRACK_INVALID_FENCE_STATE, "MEM",
+ "Fence %#" PRIxLEAST64 " submitted to VkResetFences in UNSIGNALED STATE", (uint64_t) pFences[i]);
}
else {
fence_item->second.createInfo.flags =
@@ -1482,15 +1482,15 @@
static inline VkBool32 verifyFenceStatus(VkDevice device, VkFence fence, const char* apiCall)
{
VkBool32 skipCall = VK_FALSE;
- auto pFenceInfo = fenceMap.find(fence.handle);
+ auto pFenceInfo = fenceMap.find(fence);
if (pFenceInfo != fenceMap.end()) {
if (pFenceInfo->second.createInfo.flags & VK_FENCE_CREATE_SIGNALED_BIT) {
- skipCall |= log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_FENCE, fence.handle, 0, MEMTRACK_INVALID_FENCE_STATE, "MEM",
- "%s specified fence %#" PRIxLEAST64 " already in SIGNALED state.", apiCall, fence.handle);
+ skipCall |= log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_FENCE, (uint64_t) fence, 0, MEMTRACK_INVALID_FENCE_STATE, "MEM",
+ "%s specified fence %#" PRIxLEAST64 " already in SIGNALED state.", apiCall, (uint64_t) fence);
}
if (!pFenceInfo->second.queue) { // Checking status of unsubmitted fence
- skipCall |= log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_FENCE, fence.handle, 0, MEMTRACK_INVALID_FENCE_STATE, "MEM",
- "%s called for fence %#" PRIxLEAST64 " which has not been submitted on a Queue.", apiCall, fence.handle);
+ skipCall |= log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_FENCE, (uint64_t) fence, 0, MEMTRACK_INVALID_FENCE_STATE, "MEM",
+ "%s called for fence %#" PRIxLEAST64 " which has not been submitted on a Queue.", apiCall, (uint64_t) fence);
}
}
return skipCall;
@@ -1572,7 +1572,7 @@
VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateBuffer(device, pCreateInfo, pBuffer);
if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
- add_object_create_info(pBuffer->handle, VK_OBJECT_TYPE_BUFFER, pCreateInfo);
+ add_object_create_info((uint64_t) *pBuffer, VK_OBJECT_TYPE_BUFFER, pCreateInfo);
loader_platform_thread_unlock_mutex(&globalLock);
}
return result;
@@ -1586,7 +1586,7 @@
VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateImage(device, pCreateInfo, pImage);
if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
- add_object_create_info(pImage->handle, VK_OBJECT_TYPE_IMAGE, pCreateInfo);
+ add_object_create_info((uint64_t) *pImage, VK_OBJECT_TYPE_IMAGE, pCreateInfo);
loader_platform_thread_unlock_mutex(&globalLock);
}
return result;
@@ -1931,7 +1931,7 @@
{
VkDeviceMemory mem;
loader_platform_thread_lock_mutex(&globalLock);
- VkBool32 skipCall = get_mem_binding_from_object(cmdBuffer, buffer.handle, VK_OBJECT_TYPE_BUFFER, &mem);
+ VkBool32 skipCall = get_mem_binding_from_object(cmdBuffer, (uint64_t) buffer, VK_OBJECT_TYPE_BUFFER, &mem);
skipCall |= update_cmd_buf_and_mem_references(cmdBuffer, mem, "vkCmdDrawIndirect");
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
@@ -1948,7 +1948,7 @@
{
VkDeviceMemory mem;
loader_platform_thread_lock_mutex(&globalLock);
- VkBool32 skipCall = get_mem_binding_from_object(cmdBuffer, buffer.handle, VK_OBJECT_TYPE_BUFFER, &mem);
+ VkBool32 skipCall = get_mem_binding_from_object(cmdBuffer, (uint64_t) buffer, VK_OBJECT_TYPE_BUFFER, &mem);
skipCall |= update_cmd_buf_and_mem_references(cmdBuffer, mem, "vkCmdDrawIndexedIndirect");
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
@@ -1963,7 +1963,7 @@
{
VkDeviceMemory mem;
loader_platform_thread_lock_mutex(&globalLock);
- VkBool32 skipCall = get_mem_binding_from_object(cmdBuffer, buffer.handle, VK_OBJECT_TYPE_BUFFER, &mem);
+ VkBool32 skipCall = get_mem_binding_from_object(cmdBuffer, (uint64_t) buffer, VK_OBJECT_TYPE_BUFFER, &mem);
skipCall |= update_cmd_buf_and_mem_references(cmdBuffer, mem, "vkCmdDispatchIndirect");
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
@@ -1981,9 +1981,9 @@
VkDeviceMemory mem;
VkBool32 skipCall = VK_FALSE;
loader_platform_thread_lock_mutex(&globalLock);
- skipCall = get_mem_binding_from_object(cmdBuffer, srcBuffer.handle, VK_OBJECT_TYPE_BUFFER, &mem);
+ skipCall = get_mem_binding_from_object(cmdBuffer, (uint64_t) srcBuffer, VK_OBJECT_TYPE_BUFFER, &mem);
skipCall |= update_cmd_buf_and_mem_references(cmdBuffer, mem, "vkCmdCopyBuffer");
- skipCall |= get_mem_binding_from_object(cmdBuffer, destBuffer.handle, VK_OBJECT_TYPE_BUFFER, &mem);
+ skipCall |= get_mem_binding_from_object(cmdBuffer, (uint64_t) destBuffer, VK_OBJECT_TYPE_BUFFER, &mem);
skipCall |= update_cmd_buf_and_mem_references(cmdBuffer, mem, "vkCmdCopyBuffer");
// Validate that SRC & DST buffers have correct usage flags set
skipCall |= validate_buffer_usage_flags(cmdBuffer, srcBuffer, VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT, true, "vkCmdCopyBuffer()", "VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT");
@@ -2007,7 +2007,7 @@
VkDeviceMemory mem;
VkBool32 skipCall = VK_FALSE;
loader_platform_thread_lock_mutex(&globalLock);
- skipCall |= get_mem_binding_from_object(cmdBuffer, destBuffer.handle, VK_OBJECT_TYPE_BUFFER, &mem);
+ skipCall |= get_mem_binding_from_object(cmdBuffer, (uint64_t) destBuffer, VK_OBJECT_TYPE_BUFFER, &mem);
skipCall |= update_cmd_buf_and_mem_references(cmdBuffer, mem, "vkCmdCopyQueryPoolResults");
// Validate that DST buffer has correct usage flags set
skipCall |= validate_buffer_usage_flags(cmdBuffer, destBuffer, VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT, true, "vkCmdCopyQueryPoolResults()", "VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT");
@@ -2030,9 +2030,9 @@
VkBool32 skipCall = VK_FALSE;
loader_platform_thread_lock_mutex(&globalLock);
// Validate that src & dst images have correct usage flags set
- skipCall = get_mem_binding_from_object(cmdBuffer, srcImage.handle, VK_OBJECT_TYPE_IMAGE, &mem);
+ skipCall = get_mem_binding_from_object(cmdBuffer, (uint64_t) srcImage, VK_OBJECT_TYPE_IMAGE, &mem);
skipCall |= update_cmd_buf_and_mem_references(cmdBuffer, mem, "vkCmdCopyImage");
- skipCall |= get_mem_binding_from_object(cmdBuffer, destImage.handle, VK_OBJECT_TYPE_IMAGE, &mem);
+ skipCall |= get_mem_binding_from_object(cmdBuffer, (uint64_t) destImage, VK_OBJECT_TYPE_IMAGE, &mem);
skipCall |= update_cmd_buf_and_mem_references(cmdBuffer, mem, "vkCmdCopyImage");
skipCall |= validate_image_usage_flags(cmdBuffer, srcImage, VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT, true, "vkCmdCopyImage()", "VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT");
skipCall |= validate_image_usage_flags(cmdBuffer, destImage, VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT, true, "vkCmdCopyImage()", "VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT");
@@ -2057,9 +2057,9 @@
VkBool32 skipCall = VK_FALSE;
loader_platform_thread_lock_mutex(&globalLock);
// Validate that src & dst images have correct usage flags set
- skipCall = get_mem_binding_from_object(cmdBuffer, srcImage.handle, VK_OBJECT_TYPE_IMAGE, &mem);
+ skipCall = get_mem_binding_from_object(cmdBuffer, (uint64_t) srcImage, VK_OBJECT_TYPE_IMAGE, &mem);
skipCall |= update_cmd_buf_and_mem_references(cmdBuffer, mem, "vkCmdBlitImage");
- skipCall |= get_mem_binding_from_object(cmdBuffer, destImage.handle, VK_OBJECT_TYPE_IMAGE, &mem);
+ skipCall |= get_mem_binding_from_object(cmdBuffer, (uint64_t) destImage, VK_OBJECT_TYPE_IMAGE, &mem);
skipCall |= update_cmd_buf_and_mem_references(cmdBuffer, mem, "vkCmdBlitImage");
skipCall |= validate_image_usage_flags(cmdBuffer, srcImage, VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT, true, "vkCmdBlitImage()", "VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT");
skipCall |= validate_image_usage_flags(cmdBuffer, destImage, VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT, true, "vkCmdBlitImage()", "VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT");
@@ -2081,9 +2081,9 @@
VkDeviceMemory mem;
VkBool32 skipCall = VK_FALSE;
loader_platform_thread_lock_mutex(&globalLock);
- skipCall = get_mem_binding_from_object(cmdBuffer, destImage.handle, VK_OBJECT_TYPE_IMAGE, &mem);
+ skipCall = get_mem_binding_from_object(cmdBuffer, (uint64_t) destImage, VK_OBJECT_TYPE_IMAGE, &mem);
skipCall |= update_cmd_buf_and_mem_references(cmdBuffer, mem, "vkCmdCopyBufferToImage");
- skipCall |= get_mem_binding_from_object(cmdBuffer, srcBuffer.handle, VK_OBJECT_TYPE_BUFFER, &mem);
+ skipCall |= get_mem_binding_from_object(cmdBuffer, (uint64_t) srcBuffer, VK_OBJECT_TYPE_BUFFER, &mem);
skipCall |= update_cmd_buf_and_mem_references(cmdBuffer, mem, "vkCmdCopyBufferToImage");
// Validate that src buff & dst image have correct usage flags set
skipCall |= validate_buffer_usage_flags(cmdBuffer, srcBuffer, VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT, true, "vkCmdCopyBufferToImage()", "VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT");
@@ -2106,9 +2106,9 @@
VkDeviceMemory mem;
VkBool32 skipCall = VK_FALSE;
loader_platform_thread_lock_mutex(&globalLock);
- skipCall = get_mem_binding_from_object(cmdBuffer, srcImage.handle, VK_OBJECT_TYPE_IMAGE, &mem);
+ skipCall = get_mem_binding_from_object(cmdBuffer, (uint64_t) srcImage, VK_OBJECT_TYPE_IMAGE, &mem);
skipCall |= update_cmd_buf_and_mem_references(cmdBuffer, mem, "vkCmdCopyImageToBuffer");
- skipCall |= get_mem_binding_from_object(cmdBuffer, destBuffer.handle, VK_OBJECT_TYPE_BUFFER, &mem);
+ skipCall |= get_mem_binding_from_object(cmdBuffer, (uint64_t) destBuffer, VK_OBJECT_TYPE_BUFFER, &mem);
skipCall |= update_cmd_buf_and_mem_references(cmdBuffer, mem, "vkCmdCopyImageToBuffer");
// Validate that dst buff & src image have correct usage flags set
skipCall |= validate_image_usage_flags(cmdBuffer, srcImage, VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT, true, "vkCmdCopyImageToBuffer()", "VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT");
@@ -2130,7 +2130,7 @@
VkDeviceMemory mem;
VkBool32 skipCall = VK_FALSE;
loader_platform_thread_lock_mutex(&globalLock);
- skipCall = get_mem_binding_from_object(cmdBuffer, destBuffer.handle, VK_OBJECT_TYPE_BUFFER, &mem);
+ skipCall = get_mem_binding_from_object(cmdBuffer, (uint64_t) destBuffer, VK_OBJECT_TYPE_BUFFER, &mem);
skipCall |= update_cmd_buf_and_mem_references(cmdBuffer, mem, "vkCmdUpdateBuffer");
// Validate that dst buff has correct usage flags set
skipCall |= validate_buffer_usage_flags(cmdBuffer, destBuffer, VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT, true, "vkCmdUpdateBuffer()", "VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT");
@@ -2150,7 +2150,7 @@
VkDeviceMemory mem;
VkBool32 skipCall = VK_FALSE;
loader_platform_thread_lock_mutex(&globalLock);
- skipCall = get_mem_binding_from_object(cmdBuffer, destBuffer.handle, VK_OBJECT_TYPE_BUFFER, &mem);
+ skipCall = get_mem_binding_from_object(cmdBuffer, (uint64_t) destBuffer, VK_OBJECT_TYPE_BUFFER, &mem);
skipCall |= update_cmd_buf_and_mem_references(cmdBuffer, mem, "vkCmdFillBuffer");
// Validate that dst buff has correct usage flags set
skipCall |= validate_buffer_usage_flags(cmdBuffer, destBuffer, VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT, true, "vkCmdFillBuffer()", "VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT");
@@ -2172,7 +2172,7 @@
VkDeviceMemory mem;
VkBool32 skipCall = VK_FALSE;
loader_platform_thread_lock_mutex(&globalLock);
- skipCall = get_mem_binding_from_object(cmdBuffer, image.handle, VK_OBJECT_TYPE_IMAGE, &mem);
+ skipCall = get_mem_binding_from_object(cmdBuffer, (uint64_t) image, VK_OBJECT_TYPE_IMAGE, &mem);
skipCall |= update_cmd_buf_and_mem_references(cmdBuffer, mem, "vkCmdClearColorImage");
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
@@ -2192,7 +2192,7 @@
VkDeviceMemory mem;
VkBool32 skipCall = VK_FALSE;
loader_platform_thread_lock_mutex(&globalLock);
- skipCall = get_mem_binding_from_object(cmdBuffer, image.handle, VK_OBJECT_TYPE_IMAGE, &mem);
+ skipCall = get_mem_binding_from_object(cmdBuffer, (uint64_t) image, VK_OBJECT_TYPE_IMAGE, &mem);
skipCall |= update_cmd_buf_and_mem_references(cmdBuffer, mem, "vkCmdClearDepthStencilImage");
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
@@ -2213,9 +2213,9 @@
VkBool32 skipCall = VK_FALSE;
loader_platform_thread_lock_mutex(&globalLock);
VkDeviceMemory mem;
- skipCall = get_mem_binding_from_object(cmdBuffer, srcImage.handle, VK_OBJECT_TYPE_IMAGE, &mem);
+ skipCall = get_mem_binding_from_object(cmdBuffer, (uint64_t) srcImage, VK_OBJECT_TYPE_IMAGE, &mem);
skipCall |= update_cmd_buf_and_mem_references(cmdBuffer, mem, "vkCmdResolveImage");
- skipCall |= get_mem_binding_from_object(cmdBuffer, destImage.handle, VK_OBJECT_TYPE_IMAGE, &mem);
+ skipCall |= get_mem_binding_from_object(cmdBuffer, (uint64_t) destImage, VK_OBJECT_TYPE_IMAGE, &mem);
skipCall |= update_cmd_buf_and_mem_references(cmdBuffer, mem, "vkCmdResolveImage");
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
@@ -2303,19 +2303,19 @@
VkBool32 skipCall = VK_FALSE;
VkResult result = VK_ERROR_VALIDATION_FAILED;
loader_platform_thread_lock_mutex(&globalLock);
- if (swapchainMap.find(swapchain.handle) != swapchainMap.end()) {
- MT_SWAP_CHAIN_INFO* pInfo = swapchainMap[swapchain.handle];
+ if (swapchainMap.find(swapchain) != swapchainMap.end()) {
+ MT_SWAP_CHAIN_INFO* pInfo = swapchainMap[swapchain];
if (pInfo->images.size() > 0) {
for (auto it = pInfo->images.begin(); it != pInfo->images.end(); it++) {
- skipCall = clear_object_binding(device, it->handle, VK_OBJECT_TYPE_SWAPCHAIN_KHR);
- auto image_item = imageMap.find(it->handle);
+ skipCall = clear_object_binding(device, (uint64_t) *it, VK_OBJECT_TYPE_SWAPCHAIN_KHR);
+ auto image_item = imageMap.find((uint64_t) *it);
if (image_item != imageMap.end())
imageMap.erase(image_item);
}
}
delete pInfo;
- swapchainMap.erase(swapchain.handle);
+ swapchainMap.erase(swapchain);
}
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
@@ -2334,7 +2334,7 @@
if (result == VK_SUCCESS && pSwapchainImages != NULL) {
const size_t count = *pCount;
- MT_SWAP_CHAIN_INFO *pInfo = swapchainMap[swapchain.handle];
+ MT_SWAP_CHAIN_INFO *pInfo = swapchainMap[swapchain];
if (pInfo->images.empty()) {
pInfo->images.resize(count);
@@ -2344,17 +2344,17 @@
for (std::vector<VkImage>::const_iterator it = pInfo->images.begin();
it != pInfo->images.end(); it++) {
// Add image object binding, then insert the new Mem Object and then bind it to created image
- add_object_create_info(it->handle, VK_OBJECT_TYPE_SWAPCHAIN_KHR, &pInfo->createInfo);
+ add_object_create_info((uint64_t) *it, VK_OBJECT_TYPE_SWAPCHAIN_KHR, &pInfo->createInfo);
}
}
} else {
const size_t count = *pCount;
- MT_SWAP_CHAIN_INFO *pInfo = swapchainMap[swapchain.handle];
+ MT_SWAP_CHAIN_INFO *pInfo = swapchainMap[swapchain];
const bool mismatch = (pInfo->images.size() != count ||
memcmp(&pInfo->images[0], pSwapchainImages, sizeof(pInfo->images[0]) * count));
if (mismatch) {
- log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_SWAPCHAIN_KHR, swapchain.handle, 0, MEMTRACK_NONE, "SWAP_CHAIN",
+ log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_SWAPCHAIN_KHR, (uint64_t) swapchain, 0, MEMTRACK_NONE, "SWAP_CHAIN",
"vkGetSwapchainInfoKHR(%p, VK_SWAP_CHAIN_INFO_TYPE_PERSISTENT_IMAGES_KHR) returned mismatching data", swapchain);
}
}
@@ -2373,13 +2373,13 @@
VkBool32 skipCall = VK_FALSE;
loader_platform_thread_lock_mutex(&globalLock);
- if (semaphoreMap.find(semaphore.handle) != semaphoreMap.end()) {
- if (semaphoreMap[semaphore.handle] != MEMTRACK_SEMAPHORE_STATE_UNSET) {
- skipCall = log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_SEMAPHORE, semaphore.handle,
+ if (semaphoreMap.find(semaphore) != semaphoreMap.end()) {
+ if (semaphoreMap[semaphore] != MEMTRACK_SEMAPHORE_STATE_UNSET) {
+ skipCall = log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_SEMAPHORE, (uint64_t) semaphore,
0, MEMTRACK_NONE, "SEMAPHORE",
"vkAcquireNextImageKHR: Semaphore must not be currently signaled or in a wait state");
}
- semaphoreMap[semaphore.handle] = MEMTRACK_SEMAPHORE_STATE_SIGNALLED;
+ semaphoreMap[semaphore] = MEMTRACK_SEMAPHORE_STATE_SIGNALLED;
}
loader_platform_thread_unlock_mutex(&globalLock);
if (VK_FALSE == skipCall) {
@@ -2396,8 +2396,8 @@
{
VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateSemaphore(device, pCreateInfo, pSemaphore);
loader_platform_thread_lock_mutex(&globalLock);
- if (pSemaphore->handle != 0) {
- semaphoreMap[pSemaphore->handle] = MEMTRACK_SEMAPHORE_STATE_UNSET;
+ if (*pSemaphore != VK_NULL_HANDLE) {
+ semaphoreMap[*pSemaphore] = MEMTRACK_SEMAPHORE_STATE_UNSET;
}
loader_platform_thread_unlock_mutex(&globalLock);
return result;
@@ -2408,7 +2408,7 @@
VkSemaphore semaphore)
{
loader_platform_thread_lock_mutex(&globalLock);
- auto item = semaphoreMap.find(semaphore.handle);
+ auto item = semaphoreMap.find(semaphore);
if (item != semaphoreMap.end()) {
semaphoreMap.erase(item);
}
diff --git a/layers/object_track.h b/layers/object_track.h
index c2f0e67..ea75743 100644
--- a/layers/object_track.h
+++ b/layers/object_track.h
@@ -451,20 +451,20 @@
static VkBool32 validate_object(VkQueue dispatchable_object, VkImage object)
{
- if ((VkImageMap.find((void*)object.handle) == VkImageMap.end()) &&
- (swapchainImageMap.find((void*)object.handle) == swapchainImageMap.end())) {
- return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, object.handle, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",
- "Invalid VkImage Object %p", object.handle);
+ if ((VkImageMap.find((void*)object) == VkImageMap.end()) &&
+ (swapchainImageMap.find((void*)object) == swapchainImageMap.end())) {
+ return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, (uint64_t) object, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",
+ "Invalid VkImage Object %p", object);
}
return VK_FALSE;
}
static VkBool32 validate_object(VkCmdBuffer dispatchable_object, VkImage object)
{
- if ((VkImageMap.find((void*)object.handle) == VkImageMap.end()) &&
- (swapchainImageMap.find((void*)object.handle) == swapchainImageMap.end())) {
- return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, object.handle, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",
- "Invalid VkImage Object %p", object.handle);
+ if ((VkImageMap.find((void*)object) == VkImageMap.end()) &&
+ (swapchainImageMap.find((void*)object) == swapchainImageMap.end())) {
+ return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, (uint64_t) object, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",
+ "Invalid VkImage Object %p", object);
}
return VK_FALSE;
}
@@ -480,18 +480,18 @@
static VkBool32 validate_object(VkCmdBuffer dispatchable_object, VkDescriptorSet object)
{
- if (VkDescriptorSetMap.find((void*)object.handle) == VkDescriptorSetMap.end()) {
- return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, object.handle, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",
- "Invalid VkDescriptorSet Object %p", object.handle);
+ if (VkDescriptorSetMap.find((void*)object) == VkDescriptorSetMap.end()) {
+ return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, (uint64_t) object, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",
+ "Invalid VkDescriptorSet Object %p", object);
}
return VK_FALSE;
}
static VkBool32 validate_object(VkQueue dispatchable_object, VkBuffer object)
{
- if (VkBufferMap.find((void*)object.handle) != VkBufferMap.end()) {
- return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, object.handle, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",
- "Invalid VkBuffer Object %p", object.handle);
+ if (VkBufferMap.find((void*)object) != VkBufferMap.end()) {
+ return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, (uint64_t) object, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",
+ "Invalid VkBuffer Object %p", object);
}
return VK_FALSE;
}
@@ -500,15 +500,15 @@
{
VkBool32 skipCall = VK_FALSE;
if (object != VK_NULL_HANDLE) {
- if (VkFenceMap.find((void*)object.handle) != VkFenceMap.end()) {
- OBJTRACK_NODE* pNode = VkFenceMap[(void*)object.handle];
+ if (VkFenceMap.find((void*)object) != VkFenceMap.end()) {
+ OBJTRACK_NODE* pNode = VkFenceMap[(void*)object];
pNode->status |= status_flag;
}
else {
// If we do not find it print an error
- skipCall |= log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, object.handle, 0, OBJTRACK_NONE, "OBJTRACK",
+ skipCall |= log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, (uint64_t) object, 0, OBJTRACK_NONE, "OBJTRACK",
"Unable to set status for non-existent object 0x%" PRIxLEAST64 " of %s type",
- object.handle, string_VkDbgObjectType(objType));
+ (uint64_t) object, string_VkDbgObjectType(objType));
}
}
return skipCall;
@@ -516,9 +516,9 @@
static VkBool32 validate_object(VkQueue dispatchable_object, VkSemaphore object)
{
- if (VkSemaphoreMap.find((void*)object.handle) == VkSemaphoreMap.end()) {
- return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, object.handle, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",
- "Invalid VkSemaphore Object %p", object.handle);
+ if (VkSemaphoreMap.find((void*)object) == VkSemaphoreMap.end()) {
+ return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, (uint64_t) object, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",
+ "Invalid VkSemaphore Object %p", object);
}
return VK_FALSE;
}
@@ -565,15 +565,15 @@
}
static void create_obj(VkDevice dispatchable_object, VkSwapchainKHR vkObj, VkDbgObjectType objType)
{
- log_msg(mdd(dispatchable_object), VK_DBG_REPORT_INFO_BIT, objType, vkObj.handle, 0, OBJTRACK_NONE, "OBJTRACK",
+ log_msg(mdd(dispatchable_object), VK_DBG_REPORT_INFO_BIT, objType, (uint64_t) vkObj, 0, OBJTRACK_NONE, "OBJTRACK",
"OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDbgObjectType(objType),
- vkObj.handle);
+ (uint64_t) vkObj);
OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE;
pNewObjNode->objType = objType;
pNewObjNode->status = OBJSTATUS_NONE;
- pNewObjNode->vkObj = vkObj.handle;
- VkSwapchainKHRMap[(void*) vkObj.handle] = pNewObjNode;
+ pNewObjNode->vkObj = (uint64_t) vkObj;
+ VkSwapchainKHRMap[(void*) vkObj] = pNewObjNode;
uint32_t objIndex = objTypeToIndex(objType);
numObjs[objIndex]++;
numTotalObjs++;
@@ -595,37 +595,37 @@
}
static void create_swapchain_image_obj(VkDevice dispatchable_object, VkImage vkObj, VkSwapchainKHR swapchain)
{
- log_msg(mdd(dispatchable_object), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_IMAGE, vkObj.handle, 0, OBJTRACK_NONE, "OBJTRACK",
+ log_msg(mdd(dispatchable_object), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_IMAGE, (uint64_t) vkObj, 0, OBJTRACK_NONE, "OBJTRACK",
"OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, "SwapchainImage",
- vkObj.handle);
+ (uint64_t) vkObj);
OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE;
pNewObjNode->objType = VK_OBJECT_TYPE_IMAGE;
pNewObjNode->status = OBJSTATUS_NONE;
- pNewObjNode->vkObj = vkObj.handle;
- pNewObjNode->parentObj = swapchain.handle;
- swapchainImageMap[(void*)vkObj.handle] = pNewObjNode;
+ pNewObjNode->vkObj = (uint64_t) vkObj;
+ pNewObjNode->parentObj = (uint64_t) swapchain;
+ swapchainImageMap[(void*)vkObj] = pNewObjNode;
}
static void destroy_obj(VkDevice dispatchable_object, VkSwapchainKHR object)
{
- if (VkSwapchainKHRMap.find((void*) object.handle) != VkSwapchainKHRMap.end()) {
- OBJTRACK_NODE* pNode = VkSwapchainKHRMap[(void*) object.handle];
+ if (VkSwapchainKHRMap.find((void*) object) != VkSwapchainKHRMap.end()) {
+ OBJTRACK_NODE* pNode = VkSwapchainKHRMap[(void*) object];
uint32_t objIndex = objTypeToIndex(pNode->objType);
assert(numTotalObjs > 0);
numTotalObjs--;
assert(numObjs[objIndex] > 0);
numObjs[objIndex]--;
- log_msg(mdd(dispatchable_object), VK_DBG_REPORT_INFO_BIT, pNode->objType, object.handle, 0, OBJTRACK_NONE, "OBJTRACK",
+ log_msg(mdd(dispatchable_object), VK_DBG_REPORT_INFO_BIT, pNode->objType, (uint64_t) object, 0, OBJTRACK_NONE, "OBJTRACK",
"OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%lu total objs remain & %lu %s objs).",
- string_VkDbgObjectType(pNode->objType), object.handle, numTotalObjs, numObjs[objIndex],
+ string_VkDbgObjectType(pNode->objType), (uint64_t) object, numTotalObjs, numObjs[objIndex],
string_VkDbgObjectType(pNode->objType));
delete pNode;
- VkSwapchainKHRMap.erase((void*) object.handle);
+ VkSwapchainKHRMap.erase((void*) object);
} else {
- log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, object.handle, 0, OBJTRACK_NONE, "OBJTRACK",
+ log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, (uint64_t) object, 0, OBJTRACK_NONE, "OBJTRACK",
"Unable to remove obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?",
- object.handle);
+ (uint64_t) object);
}
}
//
@@ -856,7 +856,7 @@
unordered_map<const void*, OBJTRACK_NODE*>::iterator itr = swapchainImageMap.begin();
while (itr != swapchainImageMap.end()) {
OBJTRACK_NODE* pNode = (*itr).second;
- if (pNode->parentObj == swapchain.handle) {
+ if (pNode->parentObj == (uint64_t) swapchain) {
swapchainImageMap.erase(itr++);
} else {
++itr;
diff --git a/layers/screenshot.cpp b/layers/screenshot.cpp
index 0fa3337..cd91034 100644
--- a/layers/screenshot.cpp
+++ b/layers/screenshot.cpp
@@ -63,7 +63,7 @@
VkFormat format;
VkImage *imageList;
} SwapchainMapStruct;
-static unordered_map<uint64_t, SwapchainMapStruct *> swapchainMap;
+static unordered_map<VkSwapchainKHR, SwapchainMapStruct *> swapchainMap;
// unordered map: associates an image with a device, image extent, and format
typedef struct
@@ -72,7 +72,7 @@
VkExtent2D imageExtent;
VkFormat format;
} ImageMapStruct;
-static unordered_map<uint64_t, ImageMapStruct *> imageMap;
+static unordered_map<VkImage, ImageMapStruct *> imageMap;
// unordered map: associates a device with a queue, cmdPool, and physical device
typedef struct
@@ -140,13 +140,13 @@
const char *ptr;
VkDeviceMemory mem2;
VkCmdBuffer cmdBuffer;
- VkDevice device = imageMap[image1.handle]->device;
+ VkDevice device = imageMap[image1]->device;
VkPhysicalDevice physicalDevice = deviceMap[device]->physicalDevice;
VkInstance instance = physDeviceMap[physicalDevice]->instance;
VkQueue queue = deviceMap[device]->queue;
- int width = imageMap[image1.handle]->imageExtent.width;
- int height = imageMap[image1.handle]->imageExtent.height;
- VkFormat format = imageMap[image1.handle]->format;
+ int width = imageMap[image1]->imageExtent.width;
+ int height = imageMap[image1]->imageExtent.height;
+ VkFormat format = imageMap[image1]->format;
const VkImageSubresource sr = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0};
VkSubresourceLayout sr_layout;
const VkImageCreateInfo imgCreateInfo = {
@@ -196,7 +196,7 @@
VkLayerDispatchTable* pTableCmdBuffer;
VkPhysicalDeviceMemoryProperties memory_properties;
- if (imageMap.empty() || imageMap.find(image1.handle) == imageMap.end())
+ if (imageMap.empty() || imageMap.find(image1) == imageMap.end())
return;
// The VkImage image1 we are going to dump may not be mappable,
@@ -504,10 +504,10 @@
swapchainMapElem->device = device;
swapchainMapElem->imageExtent = pCreateInfo->imageExtent;
swapchainMapElem->format = pCreateInfo->imageFormat;
- swapchainMap.insert(make_pair(pSwapchain->handle, swapchainMapElem));
+ swapchainMap.insert(make_pair(*pSwapchain, swapchainMapElem));
// Create a mapping for the swapchain object into the dispatch table
- screenshot_device_table_map.emplace((void *)pSwapchain->handle, pTable);
+ screenshot_device_table_map.emplace((void *)pSwapchain, pTable);
}
loader_platform_thread_unlock_mutex(&globalLock);
@@ -531,32 +531,32 @@
if (result == VK_SUCCESS &&
pSwapchainImages &&
- !swapchainMap.empty() && swapchainMap.find(swapchain.handle) != swapchainMap.end())
+ !swapchainMap.empty() && swapchainMap.find(swapchain) != swapchainMap.end())
{
unsigned i;
for (i=0; i<*pCount; i++)
{
// Create a mapping for an image to a device, image extent, and format
- if (imageMap[pSwapchainImages[i].handle] == NULL)
+ if (imageMap[pSwapchainImages[i]] == NULL)
{
ImageMapStruct *imageMapElem = new ImageMapStruct;
- imageMap[pSwapchainImages[i].handle] = imageMapElem;
+ imageMap[pSwapchainImages[i]] = imageMapElem;
}
- imageMap[pSwapchainImages[i].handle]->device = swapchainMap[swapchain.handle]->device;
- imageMap[pSwapchainImages[i].handle]->imageExtent = swapchainMap[swapchain.handle]->imageExtent;
- imageMap[pSwapchainImages[i].handle]->format = swapchainMap[swapchain.handle]->format;
+ imageMap[pSwapchainImages[i]]->device = swapchainMap[swapchain]->device;
+ imageMap[pSwapchainImages[i]]->imageExtent = swapchainMap[swapchain]->imageExtent;
+ imageMap[pSwapchainImages[i]]->format = swapchainMap[swapchain]->format;
}
// Add list of images to swapchain to image map
- SwapchainMapStruct *swapchainMapElem = swapchainMap[swapchain.handle];
+ SwapchainMapStruct *swapchainMapElem = swapchainMap[swapchain];
if (i >= 1 && swapchainMapElem)
{
VkImage *imageList = new VkImage[i];
swapchainMapElem->imageList = imageList;
for (unsigned j=0; j<i; j++)
{
- swapchainMapElem->imageList[j] = pSwapchainImages[j].handle;
+ swapchainMapElem->imageList[j] = pSwapchainImages[j];
}
}
@@ -615,9 +615,9 @@
fileName = to_string(frameNumber) + ".ppm";
VkImage image;
- uint64_t swapchain;
+ VkSwapchainKHR swapchain;
// We'll dump only one image: the first
- swapchain = pPresentInfo->swapchains[0].handle;
+ swapchain = pPresentInfo->swapchains[0];
image = swapchainMap[swapchain]->imageList[pPresentInfo->imageIndices[0]];
writePPM(fileName.c_str(), image);
screenshotFrames.erase(it);
diff --git a/layers/shader_checker.cpp b/layers/shader_checker.cpp
index 22bb357..91c0336 100644
--- a/layers/shader_checker.cpp
+++ b/layers/shader_checker.cpp
@@ -89,7 +89,7 @@
static loader_platform_thread_mutex globalLock;
-std::unordered_map<uint64_t, std::vector<VkDescriptorSetLayoutBinding>*> descriptor_set_layout_map;
+std::unordered_map<VkDescriptorSetLayout, std::vector<VkDescriptorSetLayoutBinding>*> descriptor_set_layout_map;
VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(
VkDevice device,
@@ -102,7 +102,7 @@
if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
- auto& bindings = descriptor_set_layout_map[pSetLayout->handle];
+ auto& bindings = descriptor_set_layout_map[*pSetLayout];
bindings = new std::vector<VkDescriptorSetLayoutBinding>(
pCreateInfo->pBinding, pCreateInfo->pBinding + pCreateInfo->count);
loader_platform_thread_unlock_mutex(&globalLock);
@@ -112,7 +112,7 @@
}
-std::unordered_map<uint64_t, std::vector<std::vector<VkDescriptorSetLayoutBinding>*>*> pipeline_layout_map;
+std::unordered_map<VkPipelineLayout, std::vector<std::vector<VkDescriptorSetLayoutBinding>*>*> pipeline_layout_map;
VK_LAYER_EXPORT VkResult VKAPI vkCreatePipelineLayout(
VkDevice device,
@@ -124,11 +124,11 @@
if (VK_SUCCESS == result) {
loader_platform_thread_lock_mutex(&globalLock);
- auto& layouts = pipeline_layout_map[pPipelineLayout->handle];
+ auto& layouts = pipeline_layout_map[*pPipelineLayout];
layouts = new std::vector<std::vector<VkDescriptorSetLayoutBinding>*>();
layouts->reserve(pCreateInfo->descriptorSetCount);
for (unsigned i = 0; i < pCreateInfo->descriptorSetCount; i++) {
- layouts->push_back(descriptor_set_layout_map[pCreateInfo->pSetLayouts[i].handle]);
+ layouts->push_back(descriptor_set_layout_map[pCreateInfo->pSetLayouts[i]]);
}
loader_platform_thread_unlock_mutex(&globalLock);
}
@@ -209,7 +209,7 @@
};
-static std::unordered_map<uint64_t, shader_module *> shader_module_map;
+static std::unordered_map<VkShaderModule, shader_module *> shader_module_map;
struct shader_object {
std::string name;
@@ -218,12 +218,12 @@
shader_object(VkShaderCreateInfo const *pCreateInfo)
{
- module = shader_module_map[pCreateInfo->module.handle];
+ module = shader_module_map[pCreateInfo->module];
stage = pCreateInfo->stage;
name = pCreateInfo->pName;
}
};
-static std::unordered_map<uint64_t, shader_object *> shader_object_map;
+static std::unordered_map<VkShader, shader_object *> shader_object_map;
struct render_pass {
std::vector<std::vector<VkFormat>> subpass_color_formats;
@@ -250,7 +250,7 @@
}
}
};
-static std::unordered_map<uint64_t, render_pass *> render_pass_map;
+static std::unordered_map<VkRenderPass, render_pass *> render_pass_map;
static void
@@ -650,7 +650,7 @@
if (res == VK_SUCCESS) {
loader_platform_thread_lock_mutex(&globalLock);
- shader_module_map[pShaderModule->handle] = new shader_module(pCreateInfo);
+ shader_module_map[*pShaderModule] = new shader_module(pCreateInfo);
loader_platform_thread_unlock_mutex(&globalLock);
}
return res;
@@ -664,7 +664,7 @@
VkResult res = get_dispatch_table(shader_checker_device_table_map, device)->CreateShader(device, pCreateInfo, pShader);
loader_platform_thread_lock_mutex(&globalLock);
- shader_object_map[pShader->handle] = new shader_object(pCreateInfo);
+ shader_object_map[*pShader] = new shader_object(pCreateInfo);
loader_platform_thread_unlock_mutex(&globalLock);
return res;
}
@@ -677,7 +677,7 @@
VkResult res = get_dispatch_table(shader_checker_device_table_map, device)->CreateRenderPass(device, pCreateInfo, pRenderPass);
loader_platform_thread_lock_mutex(&globalLock);
- render_pass_map[pRenderPass->handle] = new render_pass(pCreateInfo);
+ render_pass_map[*pRenderPass] = new render_pass(pCreateInfo);
loader_platform_thread_unlock_mutex(&globalLock);
return res;
}
@@ -1080,7 +1080,7 @@
}
}
else {
- struct shader_object *shader = shader_object_map[pStage->shader.handle];
+ struct shader_object *shader = shader_object_map[pStage->shader];
shaders[get_shader_stage_id(shader->stage)] = shader->module;
/* validate descriptor set layout against what the spirv module actually uses */
@@ -1088,8 +1088,8 @@
collect_interface_by_descriptor_slot(dev, shader->module, spv::StorageClassUniform,
descriptor_uses);
- auto layout = pCreateInfo->layout.handle ?
- pipeline_layout_map[pCreateInfo->layout.handle] : nullptr;
+ auto layout = pCreateInfo->layout != VK_NULL_HANDLE ?
+ pipeline_layout_map[pCreateInfo->layout] : nullptr;
for (auto it = descriptor_uses.begin(); it != descriptor_uses.end(); it++) {
@@ -1112,7 +1112,7 @@
}
if (pCreateInfo->renderPass != VK_NULL_HANDLE)
- rp = render_pass_map[pCreateInfo->renderPass.handle];
+ rp = render_pass_map[pCreateInfo->renderPass];
vi = pCreateInfo->pVertexInputState;
diff --git a/layers/swapchain.cpp b/layers/swapchain.cpp
index 38d8e94..0fcac4e 100644
--- a/layers/swapchain.cpp
+++ b/layers/swapchain.cpp
@@ -53,7 +53,7 @@
static std::unordered_map<void *, SwpInstance> instanceMap;
static std::unordered_map<void *, SwpPhysicalDevice> physicalDeviceMap;
static std::unordered_map<void *, SwpDevice> deviceMap;
-static std::unordered_map<uint64_t, SwpSwapchain> swapchainMap;
+static std::unordered_map<VkSwapchainKHR, SwpSwapchain> swapchainMap;
static void createDeviceRegisterExtensions(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice device)
@@ -830,11 +830,11 @@
// Remember the swapchain's handle, and link it to the device:
SwpDevice *pDevice = &deviceMap[device];
- swapchainMap[pSwapchain->handle].swapchain = *pSwapchain;
- pDevice->swapchains[pSwapchain->handle] =
- &swapchainMap[pSwapchain->handle];
- swapchainMap[pSwapchain->handle].pDevice = pDevice;
- swapchainMap[pSwapchain->handle].imageCount = 0;
+ swapchainMap[*pSwapchain].swapchain = *pSwapchain;
+ pDevice->swapchains[*pSwapchain] =
+ &swapchainMap[*pSwapchain];
+ swapchainMap[*pSwapchain].pDevice = pDevice;
+ swapchainMap[*pSwapchain].imageCount = 0;
}
return result;
@@ -864,11 +864,11 @@
}
// Regardless of skipCall value, do some internal cleanup:
- SwpSwapchain *pSwapchain = &swapchainMap[swapchain.handle];
+ SwpSwapchain *pSwapchain = &swapchainMap[swapchain];
if (pSwapchain) {
// Delete the SwpSwapchain associated with this swapchain:
if (pSwapchain->pDevice) {
- pSwapchain->pDevice->swapchains.erase(swapchain.handle);
+ pSwapchain->pDevice->swapchains.erase(swapchain);
if (device != pSwapchain->pDevice->device) {
LOG_ERROR(VK_OBJECT_TYPE_DEVICE, device, "VkDevice",
SWAPCHAIN_DESTROY_SWAP_DIFF_DEVICE,
@@ -880,10 +880,10 @@
if (pSwapchain->imageCount) {
pSwapchain->images.clear();
}
- swapchainMap.erase(swapchain.handle);
+ swapchainMap.erase(swapchain);
} else {
skipCall |= LOG_ERROR_NON_VALID_OBJ(VK_OBJECT_TYPE_SWAPCHAIN_KHR,
- swapchain.handle,
+ swapchain,
"VkSwapchainKHR");
}
@@ -916,7 +916,7 @@
"extension was not enabled for this VkDevice.",
__FUNCTION__);
}
- SwpSwapchain *pSwapchain = &swapchainMap[swapchain.handle];
+ SwpSwapchain *pSwapchain = &swapchainMap[swapchain];
if (!pSwapchain) {
skipCall |= LOG_ERROR_NON_VALID_OBJ(VK_OBJECT_TYPE_SWAPCHAIN_KHR,
swapchain.handle,
@@ -973,10 +973,10 @@
__FUNCTION__);
}
// Validate that a valid VkSwapchainKHR was used:
- SwpSwapchain *pSwapchain = &swapchainMap[swapchain.handle];
+ SwpSwapchain *pSwapchain = &swapchainMap[swapchain];
if (!pSwapchain) {
skipCall |= LOG_ERROR_NON_VALID_OBJ(VK_OBJECT_TYPE_SWAPCHAIN_KHR,
- swapchain.handle,
+ swapchain,
"VkSwapchainKHR");
} else {
// Look to see if the application is trying to own too many images at
@@ -1037,7 +1037,7 @@
for (uint32_t i = 0; i < pPresentInfo->swapchainCount ; i++) {
uint32_t index = pPresentInfo->imageIndices[i];
SwpSwapchain *pSwapchain =
- &swapchainMap[pPresentInfo->swapchains[i].handle];
+ &swapchainMap[pPresentInfo->swapchains[i]];
if (pSwapchain) {
if (!pSwapchain->pDevice->deviceSwapchainExtensionEnabled) {
skipCall |= LOG_ERROR(VK_OBJECT_TYPE_DEVICE,
@@ -1051,7 +1051,7 @@
}
if (index >= pSwapchain->imageCount) {
skipCall |= LOG_ERROR(VK_OBJECT_TYPE_SWAPCHAIN_KHR,
- pPresentInfo->swapchains[i].handle,
+ pPresentInfo->swapchains[i],
"VkSwapchainKHR",
SWAPCHAIN_INDEX_TOO_LARGE,
"%s() called for an index that is too "
@@ -1062,7 +1062,7 @@
} else {
if (!pSwapchain->images[index].ownedByApp) {
skipCall |= LOG_ERROR(VK_OBJECT_TYPE_SWAPCHAIN_KHR,
- pPresentInfo->swapchains[i].handle,
+ pPresentInfo->swapchains[i],
"VkSwapchainKHR",
SWAPCHAIN_INDEX_NOT_IN_USE,
"%s() returned an index (i.e. %d) "
@@ -1073,7 +1073,7 @@
}
} else {
skipCall |= LOG_ERROR_NON_VALID_OBJ(VK_OBJECT_TYPE_SWAPCHAIN_KHR,
- pPresentInfo->swapchains[i].handle,
+ pPresentInfo->swapchains[i],
"VkSwapchainKHR");
}
}
@@ -1087,7 +1087,7 @@
for (uint32_t i = 0; i < pPresentInfo->swapchainCount ; i++) {
int index = pPresentInfo->imageIndices[i];
SwpSwapchain *pSwapchain =
- &swapchainMap[pPresentInfo->swapchains[i].handle];
+ &swapchainMap[pPresentInfo->swapchains[i]];
if (pSwapchain) {
// Change the state of the image (no longer owned by the
// application):
diff --git a/layers/swapchain.h b/layers/swapchain.h
index 21a2fe6..18dc363 100644
--- a/layers/swapchain.h
+++ b/layers/swapchain.h
@@ -183,7 +183,7 @@
// When vkCreateSwapchainKHR is called, the VkSwapchainKHR's are
// remembered:
- unordered_map<uint64_t, SwpSwapchain*> swapchains;
+ unordered_map<VkSwapchainKHR, SwpSwapchain*> swapchains;
};
// Create one of these for each VkImage within a VkSwapchainKHR:
diff --git a/layers/vk_layer_logging.h b/layers/vk_layer_logging.h
index 60d3fb1..70894f7 100644
--- a/layers/vk_layer_logging.h
+++ b/layers/vk_layer_logging.h
@@ -119,7 +119,7 @@
debug_report_log_msg(
debug_data, VK_DBG_REPORT_WARN_BIT,
- VK_OBJECT_TYPE_MSG_CALLBACK, pTrav->msgCallback.handle,
+ VK_OBJECT_TYPE_MSG_CALLBACK, (uint64_t) pTrav->msgCallback,
0, DEBUG_REPORT_CALLBACK_REF,
"DebugReport",
"Debug Report callbacks not removed before DestroyInstance");
@@ -159,7 +159,7 @@
// Handle of 0 is logging_callback so use allocated Node address as unique handle
if (!(*pMsgCallback))
- *pMsgCallback = (uint64_t) pNewDbgFuncNode;
+ *pMsgCallback = (VkDbgMsgCallback) pNewDbgFuncNode;
pNewDbgFuncNode->msgCallback = *pMsgCallback;
pNewDbgFuncNode->pfnMsgCallback = pfnMsgCallback;
pNewDbgFuncNode->msgFlags = msgFlags;
@@ -171,7 +171,7 @@
debug_report_log_msg(
debug_data, VK_DBG_REPORT_DEBUG_BIT,
- VK_OBJECT_TYPE_MSG_CALLBACK, (*pMsgCallback).handle,
+ VK_OBJECT_TYPE_MSG_CALLBACK, (uint64_t) *pMsgCallback,
0, DEBUG_REPORT_CALLBACK_REF,
"DebugReport",
"Added callback");
@@ -196,7 +196,7 @@
}
debug_report_log_msg(
debug_data, VK_DBG_REPORT_DEBUG_BIT,
- VK_OBJECT_TYPE_MSG_CALLBACK, pTrav->msgCallback.handle,
+ VK_OBJECT_TYPE_MSG_CALLBACK, (uint64_t) pTrav->msgCallback,
0, DEBUG_REPORT_NONE,
"DebugReport",
"Destroyed callback");
diff --git a/loader/debug_report.c b/loader/debug_report.c
index f73929a..00069b1 100644
--- a/loader/debug_report.c
+++ b/loader/debug_report.c
@@ -107,7 +107,7 @@
VkResult result = inst->disp->DbgDestroyMsgCallback(instance, msg_callback);
while (pTrav) {
- if (pTrav->msgCallback.handle == msg_callback.handle) {
+ if (pTrav->msgCallback == msg_callback) {
pPrev->pNext = pTrav->pNext;
if (inst->DbgFunctionHead == pTrav)
inst->DbgFunctionHead = pTrav->pNext;
@@ -174,7 +174,7 @@
if (icd) {
storage_idx = 0;
for (icd = inst->icds; icd; icd = icd->next) {
- if (icd_info[storage_idx].handle) {
+ if (icd_info[storage_idx]) {
icd->DbgDestroyMsgCallback(
icd->instance,
icd_info[storage_idx]);
@@ -212,7 +212,7 @@
icd_info = *(VkDbgMsgCallback **) &msgCallback;
storage_idx = 0;
for (icd = inst->icds; icd; icd = icd->next) {
- if (icd_info[storage_idx].handle) {
+ if (icd_info[storage_idx]) {
icd->DbgDestroyMsgCallback(
icd->instance,
icd_info[storage_idx]);
diff --git a/tests/layer_validation_tests.cpp b/tests/layer_validation_tests.cpp
index 8e120ba..f98b068 100644
--- a/tests/layer_validation_tests.cpp
+++ b/tests/layer_validation_tests.cpp
@@ -1102,8 +1102,7 @@
err = vkAllocDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
ASSERT_VK_SUCCESS(err);
- VkBufferView view;
- view.handle = 0xbaadbeef; // invalid bufferView object
+ VkBufferView view = (VkBufferView) 0xbaadbeef; // invalid bufferView object
VkWriteDescriptorSet descriptor_write;
memset(&descriptor_write, 0, sizeof(descriptor_write));
@@ -1739,7 +1738,6 @@
std::string msgString;
VkResult err;
VkCmdBuffer draw_cmd;
- VkCmdPool cmd_pool;
ASSERT_NO_FATAL_FAILURE(InitState());
m_errorMonitor->ClearState();
@@ -3272,8 +3270,7 @@
err = vkAllocDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
ASSERT_VK_SUCCESS(err);
- VkSampler sampler;
- sampler.handle = 0xbaadbeef; // Sampler with invalid handle
+ VkSampler sampler = (VkSampler) 0xbaadbeef; // Sampler with invalid handle
VkDescriptorImageInfo descriptor_info;
memset(&descriptor_info, 0, sizeof(VkDescriptorImageInfo));
@@ -3370,8 +3367,7 @@
err = vkCreateSampler(m_device->device(), &sampler_ci, &sampler);
ASSERT_VK_SUCCESS(err);
- VkImageView view;
- view.handle = 0xbaadbeef; // invalid imageView object
+ VkImageView view = (VkImageView) 0xbaadbeef; // invalid imageView object
VkDescriptorImageInfo descriptor_info;
memset(&descriptor_info, 0, sizeof(VkDescriptorImageInfo));
diff --git a/tests/vktestframework.cpp b/tests/vktestframework.cpp
index f320460..0551600 100644
--- a/tests/vktestframework.cpp
+++ b/tests/vktestframework.cpp
@@ -927,7 +927,7 @@
swap_chain.queueFamilyCount = 0;
swap_chain.pQueueFamilyIndices = NULL;
swap_chain.presentMode = swapchainPresentMode;
- swap_chain.oldSwapchain.handle = 0;
+ swap_chain.oldSwapchain = VK_NULL_HANDLE;
swap_chain.clipped = true;
uint32_t i;
diff --git a/vk-layer-generate.py b/vk-layer-generate.py
index 189360d..afcf4be 100755
--- a/vk-layer-generate.py
+++ b/vk-layer-generate.py
@@ -127,8 +127,8 @@
return ("%lu", name)
if vk_type.strip('*') in vulkan.object_non_dispatch_list:
if '*' in vk_type:
- return ("%lu", "%s->handle" % name)
- return ("%lu", "%s.handle" % name)
+ return ("%lu", "%s" % name)
+ return ("%lu", "%s" % name)
if "size" in vk_type:
if '*' in vk_type:
return ("%lu", "(unsigned long)*%s" % name)
@@ -994,9 +994,9 @@
cp = True
(pft, pfi) = self._get_printf_params(p.ty, p.name, cp, cpp=True)
if p.name == "pSwapchain" or p.name == "pSwapchainImages":
- log_func += '%s = " << ((%s == NULL) ? 0 : %s->handle) << ", ' % (p.name, p.name, p.name)
+ log_func += '%s = " << %s << ", ' % (p.name, p.name)
elif p.name == "swapchain":
- log_func += '%s = " << %s.handle << ", ' % (p.name, p.name)
+ log_func += '%s = " << %s << ", ' % (p.name, p.name)
else:
log_func += '%s = " << %s << ", ' % (p.name, pfi)
if "%p" == pft:
@@ -1067,10 +1067,7 @@
print_cast = ''
print_func = 'string_convert_helper'
#cis_print_func = 'tmp_str = string_convert_helper((void*)%s[i], " ");' % proto.params[sp_index].name
- if proto.params[sp_index].ty.strip('*').replace('const ', '') in vulkan.object_non_dispatch_list:
- cis_print_func = 'tmp_str = %s(%s%s[i].handle, " ");' % (print_func, print_cast, proto.params[sp_index].name)
- else:
- cis_print_func = 'tmp_str = %s(%s%s[i], " ");' % (print_func, print_cast, proto.params[sp_index].name)
+ cis_print_func = 'tmp_str = %s(%s%s[i], " ");' % (print_func, print_cast, proto.params[sp_index].name)
if not i_decl:
log_func += '\n%suint32_t i;' % (indent)
i_decl = True
@@ -1215,26 +1212,18 @@
procs_txt.append('%s' % self.lineinfo.get())
if o in vulkan.object_dispatch_list:
procs_txt.append('static void create_obj(%s dispatchable_object, %s vkObj, VkDbgObjectType objType)' % (o, o))
- procs_txt.append('{')
- procs_txt.append(' log_msg(mdd(dispatchable_object), VK_DBG_REPORT_INFO_BIT, objType, reinterpret_cast<uint64_t>(vkObj), 0, OBJTRACK_NONE, "OBJTRACK",')
- procs_txt.append(' "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDbgObjectType(objType),')
- procs_txt.append(' reinterpret_cast<uint64_t>(vkObj));')
else:
procs_txt.append('static void create_obj(VkDevice dispatchable_object, %s vkObj, VkDbgObjectType objType)' % (o))
- procs_txt.append('{')
- procs_txt.append(' log_msg(mdd(dispatchable_object), VK_DBG_REPORT_INFO_BIT, objType, vkObj.handle, 0, OBJTRACK_NONE, "OBJTRACK",')
- procs_txt.append(' "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDbgObjectType(objType),')
- procs_txt.append(' vkObj.handle);')
+ procs_txt.append('{')
+ procs_txt.append(' log_msg(mdd(dispatchable_object), VK_DBG_REPORT_INFO_BIT, objType, reinterpret_cast<uint64_t>(vkObj), 0, OBJTRACK_NONE, "OBJTRACK",')
+ procs_txt.append(' "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDbgObjectType(objType),')
+ procs_txt.append(' reinterpret_cast<uint64_t>(vkObj));')
procs_txt.append('')
procs_txt.append(' OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE;')
procs_txt.append(' pNewObjNode->objType = objType;')
procs_txt.append(' pNewObjNode->status = OBJSTATUS_NONE;')
- if o in vulkan.object_dispatch_list:
- procs_txt.append(' pNewObjNode->vkObj = reinterpret_cast<uint64_t>(vkObj);')
- procs_txt.append(' %sMap[vkObj] = pNewObjNode;' % (o))
- else:
- procs_txt.append(' pNewObjNode->vkObj = vkObj.handle;')
- procs_txt.append(' %sMap[(void*)vkObj.handle] = pNewObjNode;' % (o))
+ procs_txt.append(' pNewObjNode->vkObj = reinterpret_cast<uint64_t>(vkObj);')
+ procs_txt.append(' %sMap[vkObj] = pNewObjNode;' % (o))
procs_txt.append(' uint32_t objIndex = objTypeToIndex(objType);')
procs_txt.append(' numObjs[objIndex]++;')
procs_txt.append(' numTotalObjs++;')
@@ -1263,12 +1252,12 @@
procs_txt.append('')
if o == "VkImage":
procs_txt.append(' // We need to validate normal image objects and those from the swapchain')
- procs_txt.append(' if ((%sMap.find((void*)object.handle) == %sMap.end()) &&' % (o, o))
- procs_txt.append(' (swapchainImageMap.find((void*)object.handle) == swapchainImageMap.end())) {')
+ procs_txt.append(' if ((%sMap.find((void*)object) == %sMap.end()) &&' % (o, o))
+ procs_txt.append(' (swapchainImageMap.find((void*)object) == swapchainImageMap.end())) {')
else:
- procs_txt.append(' if (%sMap.find((void*)object.handle) == %sMap.end()) {' % (o, o))
- procs_txt.append(' return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, object.handle, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",')
- procs_txt.append(' "Invalid %s Object %%p", object.handle);' % o)
+ procs_txt.append(' if (%sMap.find((void*)object) == %sMap.end()) {' % (o, o))
+ procs_txt.append(' return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, (uint64_t) object, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",')
+ procs_txt.append(' "Invalid %s Object %%p", object);' % o)
procs_txt.append(' }')
procs_txt.append(' return VK_FALSE;')
procs_txt.append('}')
@@ -1280,68 +1269,42 @@
else:
procs_txt.append('static void destroy_obj(VkDevice dispatchable_object, %s object)' % (o))
procs_txt.append('{')
- if o in vulkan.object_dispatch_list:
- procs_txt.append(' if (%sMap.find(object) != %sMap.end()) {' % (o, o))
- procs_txt.append(' OBJTRACK_NODE* pNode = %sMap[object];' % (o))
- else:
- procs_txt.append(' if (%sMap.find((void*)object.handle) != %sMap.end()) {' % (o, o))
- procs_txt.append(' OBJTRACK_NODE* pNode = %sMap[(void*)object.handle];' % (o))
+ procs_txt.append(' if (%sMap.find(object) != %sMap.end()) {' % (o, o))
+ procs_txt.append(' OBJTRACK_NODE* pNode = %sMap[object];' % (o))
procs_txt.append(' uint32_t objIndex = objTypeToIndex(pNode->objType);')
procs_txt.append(' assert(numTotalObjs > 0);')
procs_txt.append(' numTotalObjs--;')
procs_txt.append(' assert(numObjs[objIndex] > 0);')
procs_txt.append(' numObjs[objIndex]--;')
- if o in vulkan.object_dispatch_list:
- procs_txt.append(' log_msg(mdd(dispatchable_object), VK_DBG_REPORT_INFO_BIT, pNode->objType, reinterpret_cast<uint64_t>(object), 0, OBJTRACK_NONE, "OBJTRACK",')
- procs_txt.append(' "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%lu total objs remain & %lu %s objs).",')
- procs_txt.append(' string_VkDbgObjectType(pNode->objType), reinterpret_cast<uint64_t>(object), numTotalObjs, numObjs[objIndex],')
- else:
- procs_txt.append(' log_msg(mdd(dispatchable_object), VK_DBG_REPORT_INFO_BIT, pNode->objType, object.handle, 0, OBJTRACK_NONE, "OBJTRACK",')
- procs_txt.append(' "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%lu total objs remain & %lu %s objs).",')
- procs_txt.append(' string_VkDbgObjectType(pNode->objType), object.handle, numTotalObjs, numObjs[objIndex],')
+ procs_txt.append(' log_msg(mdd(dispatchable_object), VK_DBG_REPORT_INFO_BIT, pNode->objType, reinterpret_cast<uint64_t>(object), 0, OBJTRACK_NONE, "OBJTRACK",')
+ procs_txt.append(' "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%lu total objs remain & %lu %s objs).",')
+ procs_txt.append(' string_VkDbgObjectType(pNode->objType), reinterpret_cast<uint64_t>(object), numTotalObjs, numObjs[objIndex],')
procs_txt.append(' string_VkDbgObjectType(pNode->objType));')
procs_txt.append(' delete pNode;')
- if o in vulkan.object_dispatch_list:
- procs_txt.append(' %sMap.erase(object);' % (o))
- procs_txt.append(' } else {')
- procs_txt.append(' log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, reinterpret_cast<uint64_t>(object), 0, OBJTRACK_NONE, "OBJTRACK",')
- procs_txt.append(' "Unable to remove obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?",')
- procs_txt.append(' reinterpret_cast<uint64_t>(object));')
- procs_txt.append(' }')
- else:
- procs_txt.append(' %sMap.erase((void*)object.handle);' % (o))
- procs_txt.append(' } else {')
- procs_txt.append(' log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, object.handle, 0, OBJTRACK_NONE, "OBJTRACK",')
- procs_txt.append(' "Unable to remove obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?",')
- procs_txt.append(' object.handle);')
- procs_txt.append(' }')
+ procs_txt.append(' %sMap.erase(object);' % (o))
+ procs_txt.append(' } else {')
+ procs_txt.append(' log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, reinterpret_cast<uint64_t>(object), 0, OBJTRACK_NONE, "OBJTRACK",')
+ procs_txt.append(' "Unable to remove obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?",')
+ procs_txt.append(' reinterpret_cast<uint64_t>(object));')
+ procs_txt.append(' }')
procs_txt.append('}')
procs_txt.append('')
procs_txt.append('%s' % self.lineinfo.get())
if o in vulkan.object_dispatch_list:
procs_txt.append('static VkBool32 set_status(%s dispatchable_object, %s object, VkDbgObjectType objType, ObjectStatusFlags status_flag)' % (o, o))
- procs_txt.append('{')
- procs_txt.append(' if (object != VK_NULL_HANDLE) {')
- procs_txt.append(' if (%sMap.find(object) != %sMap.end()) {' % (o, o))
- procs_txt.append(' OBJTRACK_NODE* pNode = %sMap[object];' % (o))
else:
procs_txt.append('static VkBool32 set_status(VkDevice dispatchable_object, %s object, VkDbgObjectType objType, ObjectStatusFlags status_flag)' % (o))
- procs_txt.append('{')
- procs_txt.append(' if (object != VK_NULL_HANDLE) {')
- procs_txt.append(' if (%sMap.find((void*)object.handle) != %sMap.end()) {' % (o, o))
- procs_txt.append(' OBJTRACK_NODE* pNode = %sMap[(void*)object.handle];' % (o))
+ procs_txt.append('{')
+ procs_txt.append(' if (object != VK_NULL_HANDLE) {')
+ procs_txt.append(' if (%sMap.find(object) != %sMap.end()) {' % (o, o))
+ procs_txt.append(' OBJTRACK_NODE* pNode = %sMap[object];' % (o))
procs_txt.append(' pNode->status |= status_flag;')
procs_txt.append(' }')
procs_txt.append(' else {')
procs_txt.append(' // If we do not find it print an error')
- if o in vulkan.object_dispatch_list:
- procs_txt.append(' return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, reinterpret_cast<uint64_t>(object), 0, OBJTRACK_NONE, "OBJTRACK",')
- procs_txt.append(' "Unable to set status for non-existent object 0x%" PRIxLEAST64 " of %s type",')
- procs_txt.append(' reinterpret_cast<uint64_t>(object), string_VkDbgObjectType(objType));')
- else:
- procs_txt.append(' return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, object.handle, 0, OBJTRACK_NONE, "OBJTRACK",')
- procs_txt.append(' "Unable to set status for non-existent object 0x%" PRIxLEAST64 " of %s type",')
- procs_txt.append(' object.handle, string_VkDbgObjectType(objType));')
+ procs_txt.append(' return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, reinterpret_cast<uint64_t>(object), 0, OBJTRACK_NONE, "OBJTRACK",')
+ procs_txt.append(' "Unable to set status for non-existent object 0x%" PRIxLEAST64 " of %s type",')
+ procs_txt.append(' reinterpret_cast<uint64_t>(object), string_VkDbgObjectType(objType));')
procs_txt.append(' }')
procs_txt.append(' }')
procs_txt.append(' return VK_FALSE;')
@@ -1360,35 +1323,21 @@
procs_txt.append(' OBJECT_TRACK_ERROR error_code,')
procs_txt.append(' const char *fail_msg)')
procs_txt.append('{')
- if o in vulkan.object_dispatch_list:
- procs_txt.append(' if (%sMap.find(object) != %sMap.end()) {' % (o, o))
- procs_txt.append(' OBJTRACK_NODE* pNode = %sMap[object];' % (o))
- else:
- procs_txt.append(' if (%sMap.find((void*)object.handle) != %sMap.end()) {' % (o, o))
- procs_txt.append(' OBJTRACK_NODE* pNode = %sMap[(void*)object.handle];' % (o))
+ procs_txt.append(' if (%sMap.find(object) != %sMap.end()) {' % (o, o))
+ procs_txt.append(' OBJTRACK_NODE* pNode = %sMap[object];' % (o))
procs_txt.append(' if ((pNode->status & status_mask) != status_flag) {')
- if o in vulkan.object_dispatch_list:
- procs_txt.append(' log_msg(mdd(dispatchable_object), msg_flags, pNode->objType, reinterpret_cast<uint64_t>(object), 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK",')
- procs_txt.append(' "OBJECT VALIDATION WARNING: %s object 0x%" PRIxLEAST64 ": %s", string_VkDbgObjectType(objType),')
- procs_txt.append(' reinterpret_cast<uint64_t>(object), fail_msg);')
- else:
- procs_txt.append(' log_msg(mdd(dispatchable_object), msg_flags, pNode->objType, object.handle, 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK",')
- procs_txt.append(' "OBJECT VALIDATION WARNING: %s object 0x%" PRIxLEAST64 ": %s", string_VkDbgObjectType(objType),')
- procs_txt.append(' object.handle, fail_msg);')
+ procs_txt.append(' log_msg(mdd(dispatchable_object), msg_flags, pNode->objType, reinterpret_cast<uint64_t>(object), 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK",')
+ procs_txt.append(' "OBJECT VALIDATION WARNING: %s object 0x%" PRIxLEAST64 ": %s", string_VkDbgObjectType(objType),')
+ procs_txt.append(' reinterpret_cast<uint64_t>(object), fail_msg);')
procs_txt.append(' return VK_FALSE;')
procs_txt.append(' }')
procs_txt.append(' return VK_TRUE;')
procs_txt.append(' }')
procs_txt.append(' else {')
procs_txt.append(' // If we do not find it print an error')
- if o in vulkan.object_dispatch_list:
- procs_txt.append(' log_msg(mdd(dispatchable_object), msg_flags, (VkDbgObjectType) 0, reinterpret_cast<uint64_t>(object), 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK",')
- procs_txt.append(' "Unable to obtain status for non-existent object 0x%" PRIxLEAST64 " of %s type",')
- procs_txt.append(' reinterpret_cast<uint64_t>(object), string_VkDbgObjectType(objType));')
- else:
- procs_txt.append(' log_msg(mdd(dispatchable_object), msg_flags, (VkDbgObjectType) 0, object.handle, 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK",')
- procs_txt.append(' "Unable to obtain status for non-existent object 0x%" PRIxLEAST64 " of %s type",')
- procs_txt.append(' object.handle, string_VkDbgObjectType(objType));')
+ procs_txt.append(' log_msg(mdd(dispatchable_object), msg_flags, (VkDbgObjectType) 0, reinterpret_cast<uint64_t>(object), 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK",')
+ procs_txt.append(' "Unable to obtain status for non-existent object 0x%" PRIxLEAST64 " of %s type",')
+ procs_txt.append(' reinterpret_cast<uint64_t>(object), string_VkDbgObjectType(objType));')
procs_txt.append(' return VK_FALSE;')
procs_txt.append(' }')
procs_txt.append('}')
@@ -1396,26 +1345,18 @@
procs_txt.append('%s' % self.lineinfo.get())
if o in vulkan.object_dispatch_list:
procs_txt.append('static VkBool32 reset_status(%s dispatchable_object, %s object, VkDbgObjectType objType, ObjectStatusFlags status_flag)' % (o, o))
- procs_txt.append('{')
- procs_txt.append(' if (%sMap.find(object) != %sMap.end()) {' % (o, o))
- procs_txt.append(' OBJTRACK_NODE* pNode = %sMap[object];' % (o))
else:
procs_txt.append('static VkBool32 reset_status(VkDevice dispatchable_object, %s object, VkDbgObjectType objType, ObjectStatusFlags status_flag)' % (o))
- procs_txt.append('{')
- procs_txt.append(' if (%sMap.find((void*)object.handle) != %sMap.end()) {' % (o, o))
- procs_txt.append(' OBJTRACK_NODE* pNode = %sMap[(void*)object.handle];' % (o))
+ procs_txt.append('{')
+ procs_txt.append(' if (%sMap.find(object) != %sMap.end()) {' % (o, o))
+ procs_txt.append(' OBJTRACK_NODE* pNode = %sMap[object];' % (o))
procs_txt.append(' pNode->status &= ~status_flag;')
procs_txt.append(' }')
procs_txt.append(' else {')
procs_txt.append(' // If we do not find it print an error')
- if o in vulkan.object_dispatch_list:
- procs_txt.append(' return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, objType, reinterpret_cast<uint64_t>(object), 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK",')
- procs_txt.append(' "Unable to reset status for non-existent object 0x%" PRIxLEAST64 " of %s type",')
- procs_txt.append(' reinterpret_cast<uint64_t>(object), string_VkDbgObjectType(objType));')
- else:
- procs_txt.append(' return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, objType, object.handle, 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK",')
- procs_txt.append(' "Unable to reset status for non-existent object 0x%" PRIxLEAST64 " of %s type",')
- procs_txt.append(' object.handle, string_VkDbgObjectType(objType));')
+ procs_txt.append(' return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, objType, reinterpret_cast<uint64_t>(object), 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK",')
+ procs_txt.append(' "Unable to reset status for non-existent object 0x%" PRIxLEAST64 " of %s type",')
+ procs_txt.append(' reinterpret_cast<uint64_t>(object), string_VkDbgObjectType(objType));')
procs_txt.append(' }')
procs_txt.append(' return VK_FALSE;')
procs_txt.append('}')
@@ -1517,9 +1458,9 @@
'VkPipelineLayout', 'VkBuffer', 'VkEvent', 'VkQueryPool', 'VkRenderPass', 'VkFramebuffer']:
cbv_txt.append('static VkBool32 validate_object(VkCmdBuffer dispatchable_object, %s object)' % (o))
cbv_txt.append('{')
- cbv_txt.append(' if (%sMap.find((void*)object.handle) == %sMap.end()) {' % (o, o))
- cbv_txt.append(' return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, object.handle, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",')
- cbv_txt.append(' "Invalid %s Object %%p", object.handle);' % (o))
+ cbv_txt.append(' if (%sMap.find((void*)object) == %sMap.end()) {' % (o, o))
+ cbv_txt.append(' return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, (uint64_t) object, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",')
+ cbv_txt.append(' "Invalid %s Object %%p", object);' % (o))
cbv_txt.append(' }')
cbv_txt.append(' return VK_FALSE;')
cbv_txt.append('}')
@@ -1776,12 +1717,8 @@
}
def generate_useObject(self, ty):
obj_type = self.thread_check_object_types[ty]
- if ty in self.thread_check_dispatchable_objects:
- key = "object"
- msg_object = "reinterpret_cast<uint64_t>(object)"
- else:
- key = "object.handle"
- msg_object = "object.handle"
+ key = "object"
+ msg_object = "reinterpret_cast<uint64_t>(object)"
header_txt = []
header_txt.append('%s' % self.lineinfo.get())
header_txt.append('static void useObject(const void* dispatchable_object, %s object)' % ty)
@@ -1812,10 +1749,7 @@
header_txt.append('}')
return "\n".join(header_txt)
def generate_finishUsingObject(self, ty):
- if ty in self.thread_check_dispatchable_objects:
- key = "object"
- else:
- key = "object.handle"
+ key = "object"
header_txt = []
header_txt.append('%s' % self.lineinfo.get())
header_txt.append('static void finishUsingObject(%s object)' % ty)
@@ -1851,7 +1785,7 @@
for ty in self.thread_check_dispatchable_objects:
header_txt.append('static unordered_map<%s, loader_platform_thread_id> %sObjectsInUse;' % (ty, ty))
for ty in self.thread_check_nondispatchable_objects:
- header_txt.append('static unordered_map<uint64_t, loader_platform_thread_id> %sObjectsInUse;' % ty)
+ header_txt.append('static unordered_map<%s, loader_platform_thread_id> %sObjectsInUse;' % (ty, ty))
header_txt.append('static int threadingLockInitialized = 0;')
header_txt.append('static loader_platform_thread_mutex threadingLock;')
header_txt.append('static loader_platform_thread_cond threadingCond;')
diff --git a/vk_helper.py b/vk_helper.py
index 9cf8c04..122db6b 100755
--- a/vk_helper.py
+++ b/vk_helper.py
@@ -953,7 +953,7 @@
if "addr" in po: # or self.struct_dict[s][m]['ptr']:
sh_funcs.append(' ss[%u].str("addr");' % (index))
elif not self.struct_dict[s][m]['ptr'] and self.struct_dict[s][m]['type'] in vulkan.core.objects:
- sh_funcs.append(' ss[%u] << pStruct->%s.handle;' % (index, self.struct_dict[s][m]['name']))
+ sh_funcs.append(' ss[%u] << pStruct->%s;' % (index, self.struct_dict[s][m]['name']))
else:
sh_funcs.append(' ss[%u] << pStruct->%s;' % (index, self.struct_dict[s][m]['name']))
value_print = 'ss[%u].str()' % index