diff options
Diffstat (limited to 'layers/core_validation.cpp')
| -rw-r--r-- | layers/core_validation.cpp | 1491 |
1 files changed, 744 insertions, 747 deletions
diff --git a/layers/core_validation.cpp b/layers/core_validation.cpp index c4ada62c..3418049a 100644 --- a/layers/core_validation.cpp +++ b/layers/core_validation.cpp @@ -382,18 +382,18 @@ static bool validate_usage_flags(layer_data *my_data, VkFlags actual, VkFlags de uint64_t obj_handle, VkDebugReportObjectTypeEXT obj_type, char const *ty_str, char const *func_name, char const *usage_str) { bool correct_usage = false; - bool skipCall = false; + bool skip_call = false; if (strict) correct_usage = ((actual & desired) == desired); else correct_usage = ((actual & desired) != 0); if (!correct_usage) { - skipCall = log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, obj_type, obj_handle, __LINE__, - MEMTRACK_INVALID_USAGE_FLAG, "MEM", "Invalid usage flag for %s 0x%" PRIxLEAST64 - " used by %s. In this case, %s should have %s set during creation.", - ty_str, obj_handle, func_name, ty_str, usage_str); + skip_call = log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, obj_type, obj_handle, __LINE__, + MEMTRACK_INVALID_USAGE_FLAG, "MEM", "Invalid usage flag for %s 0x%" PRIxLEAST64 + " used by %s. In this case, %s should have %s set during creation.", + ty_str, obj_handle, func_name, ty_str, usage_str); } - return skipCall; + return skip_call; } // Helper function to validate usage flags for images @@ -401,13 +401,13 @@ static bool validate_usage_flags(layer_data *my_data, VkFlags actual, VkFlags de // an error will be flagged if usage is not correct static bool validate_image_usage_flags(layer_data *dev_data, VkImage image, VkFlags desired, VkBool32 strict, char const *func_name, char const *usage_string) { - bool skipCall = false; + bool skip_call = false; auto const image_node = getImageNode(dev_data, image); if (image_node) { - skipCall = validate_usage_flags(dev_data, image_node->createInfo.usage, desired, strict, (uint64_t)image, - VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, "image", func_name, usage_string); + skip_call = validate_usage_flags(dev_data, image_node->createInfo.usage, desired, strict, (uint64_t)image, + VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, "image", func_name, usage_string); } - return skipCall; + return skip_call; } // Helper function to validate usage flags for buffers @@ -415,13 +415,13 @@ static bool validate_image_usage_flags(layer_data *dev_data, VkImage image, VkFl // an error will be flagged if usage is not correct static bool validate_buffer_usage_flags(layer_data *dev_data, VkBuffer buffer, VkFlags desired, VkBool32 strict, char const *func_name, char const *usage_string) { - bool skipCall = false; + bool skip_call = false; auto buffer_node = getBufferNode(dev_data, buffer); if (buffer_node) { - skipCall = validate_usage_flags(dev_data, buffer_node->createInfo.usage, desired, strict, (uint64_t)buffer, - VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, "buffer", func_name, usage_string); + skip_call = validate_usage_flags(dev_data, buffer_node->createInfo.usage, desired, strict, (uint64_t)buffer, + VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, "buffer", func_name, usage_string); } - return skipCall; + return skip_call; } // Return ptr to info in map container containing mem, or NULL if not found @@ -481,7 +481,7 @@ static void set_memory_valid(layer_data *dev_data, VkDeviceMemory mem, bool vali // Find Mem Obj Info and add CB reference to list container static bool update_cmd_buf_and_mem_references(layer_data *dev_data, const VkCommandBuffer cb, const VkDeviceMemory mem, const char *apiName) { - bool skipCall = false; + bool skip_call = false; // Skip validation if this image was created through WSI if (mem != MEMTRACKER_SWAP_CHAIN_IMAGE_KEY) { @@ -498,7 +498,7 @@ static bool update_cmd_buf_and_mem_references(layer_data *dev_data, const VkComm } } } - return skipCall; + return skip_call; } // For every mem obj bound to particular CB, free bindings related to that CB static void clear_cmd_buf_and_mem_references(layer_data *dev_data, GLOBAL_CB_NODE *pCBNode) { @@ -522,16 +522,16 @@ static void clear_cmd_buf_and_mem_references(layer_data *dev_data, const VkComma // For given MemObjInfo, report Obj & CB bindings static bool reportMemReferencesAndCleanUp(layer_data *dev_data, DEVICE_MEM_INFO *pMemObjInfo) { - bool skipCall = false; + bool skip_call = false; size_t cmdBufRefCount = pMemObjInfo->commandBufferBindings.size(); size_t objRefCount = pMemObjInfo->objBindings.size(); if ((pMemObjInfo->commandBufferBindings.size()) != 0) { - skipCall = log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, - (uint64_t)pMemObjInfo->mem, __LINE__, MEMTRACK_FREED_MEM_REF, "MEM", - "Attempting to free memory object 0x%" PRIxLEAST64 " which still contains " PRINTF_SIZE_T_SPECIFIER - " references", - (uint64_t)pMemObjInfo->mem, (cmdBufRefCount + objRefCount)); + skip_call = log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, + (uint64_t)pMemObjInfo->mem, __LINE__, MEMTRACK_FREED_MEM_REF, "MEM", + "Attempting to free memory object 0x%" PRIxLEAST64 " which still contains " PRINTF_SIZE_T_SPECIFIER + " references", + (uint64_t)pMemObjInfo->mem, (cmdBufRefCount + objRefCount)); } if (cmdBufRefCount > 0 && pMemObjInfo->commandBufferBindings.size() > 0) { @@ -553,34 +553,34 @@ static bool reportMemReferencesAndCleanUp(layer_data *dev_data, DEVICE_MEM_INFO // Clear the list of hanging references pMemObjInfo->objBindings.clear(); } - return skipCall; + return skip_call; } static bool deleteMemObjInfo(layer_data *my_data, void *object, VkDeviceMemory mem) { - bool skipCall = false; + bool skip_call = false; auto item = my_data->memObjMap.find(mem); if (item != my_data->memObjMap.end()) { my_data->memObjMap.erase(item); } else { - skipCall = log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, - (uint64_t)mem, __LINE__, MEMTRACK_INVALID_MEM_OBJ, "MEM", - "Request to delete memory object 0x%" PRIxLEAST64 " not present in memory Object Map", (uint64_t)mem); + skip_call = log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, + (uint64_t)mem, __LINE__, MEMTRACK_INVALID_MEM_OBJ, "MEM", + "Request to delete memory object 0x%" PRIxLEAST64 " not present in memory Object Map", (uint64_t)mem); } - return skipCall; + return skip_call; } static bool freeMemObjInfo(layer_data *dev_data, void *object, VkDeviceMemory mem, bool internal) { - bool skipCall = false; + bool skip_call = false; // Parse global list to find info w/ mem DEVICE_MEM_INFO *pInfo = getMemObjInfo(dev_data, mem); if (pInfo) { if (pInfo->allocInfo.allocationSize == 0 && !internal) { // TODO: Verify against Valid Use section - skipCall = log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, - (uint64_t)mem, __LINE__, MEMTRACK_INVALID_MEM_OBJ, "MEM", - "Attempting to free memory associated with a Persistent Image, 0x%" PRIxLEAST64 ", " - "this should not be explicitly freed\n", - (uint64_t)mem); + skip_call = log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, + (uint64_t)mem, __LINE__, MEMTRACK_INVALID_MEM_OBJ, "MEM", + "Attempting to free memory associated with a Persistent Image, 0x%" PRIxLEAST64 ", " + "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? @@ -598,13 +598,13 @@ static bool freeMemObjInfo(layer_data *dev_data, void *object, VkDeviceMemory me // Now verify that no references to this mem obj remain and remove bindings if (pInfo->commandBufferBindings.size() || pInfo->objBindings.size()) { - skipCall |= reportMemReferencesAndCleanUp(dev_data, pInfo); + skip_call |= reportMemReferencesAndCleanUp(dev_data, pInfo); } // Delete mem obj info - skipCall |= deleteMemObjInfo(dev_data, object, mem); + skip_call |= deleteMemObjInfo(dev_data, object, mem); } } - return skipCall; + return skip_call; } static const char *object_type_to_string(VkDebugReportObjectTypeEXT type) { @@ -630,7 +630,7 @@ static const char *object_type_to_string(VkDebugReportObjectTypeEXT type) { // TODO : This only applied to Buffer, Image, and Swapchain objects now, how should it be updated/customized? static bool clear_object_binding(layer_data *dev_data, uint64_t handle, VkDebugReportObjectTypeEXT type) { // TODO : Need to customize images/buffers/swapchains to track mem binding and clear it here appropriately - bool skipCall = false; + bool skip_call = false; VkDeviceMemory *pMemBinding = get_object_mem_binding(dev_data, handle, type); if (pMemBinding) { DEVICE_MEM_INFO *pMemObjInfo = getMemObjInfo(dev_data, *pMemBinding); @@ -640,7 +640,7 @@ static bool clear_object_binding(layer_data *dev_data, uint64_t handle, VkDebugR // This obj is bound to a memory object. Remove the reference to this object in that memory object's list, // and set the objects memory binding pointer to NULL. if (!pMemObjInfo->objBindings.erase({handle, type})) { - skipCall |= + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, type, handle, __LINE__, MEMTRACK_INVALID_OBJECT, "MEM", "While trying to clear mem binding for %s obj 0x%" PRIxLEAST64 ", unable to find that object referenced by mem obj 0x%" PRIxLEAST64, @@ -648,7 +648,7 @@ static bool clear_object_binding(layer_data *dev_data, uint64_t handle, VkDebugR } } } - return skipCall; + return skip_call; } // For NULL mem case, output warning @@ -658,12 +658,12 @@ static bool clear_object_binding(layer_data *dev_data, uint64_t handle, VkDebugR // Add reference off of objInfo static bool set_mem_binding(layer_data *dev_data, VkDeviceMemory mem, uint64_t handle, VkDebugReportObjectTypeEXT type, const char *apiName) { - bool skipCall = false; + bool skip_call = false; // Handle NULL case separately, just clear previous binding & decrement reference if (mem == VK_NULL_HANDLE) { // TODO: Verify against Valid Use section of spec. - skipCall = log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, type, handle, __LINE__, MEMTRACK_INVALID_MEM_OBJ, - "MEM", "In %s, attempting to Bind Obj(0x%" PRIxLEAST64 ") to NULL", apiName, handle); + skip_call = log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, type, handle, __LINE__, MEMTRACK_INVALID_MEM_OBJ, + "MEM", "In %s, attempting to Bind Obj(0x%" PRIxLEAST64 ") to NULL", apiName, handle); } else { VkDeviceMemory *pMemBinding = get_object_mem_binding(dev_data, handle, type); assert(pMemBinding); @@ -671,11 +671,11 @@ static bool set_mem_binding(layer_data *dev_data, VkDeviceMemory mem, uint64_t h if (pMemInfo) { DEVICE_MEM_INFO *pPrevBinding = getMemObjInfo(dev_data, *pMemBinding); if (pPrevBinding != NULL) { - skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, (uint64_t)mem, __LINE__, MEMTRACK_REBIND_OBJECT, - "MEM", "In %s, attempting to bind memory (0x%" PRIxLEAST64 ") to object (0x%" PRIxLEAST64 - ") which has already been bound to mem object 0x%" PRIxLEAST64, - apiName, (uint64_t)mem, handle, (uint64_t)pPrevBinding->mem); + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, (uint64_t)mem, __LINE__, MEMTRACK_REBIND_OBJECT, + "MEM", "In %s, attempting to bind memory (0x%" PRIxLEAST64 ") to object (0x%" PRIxLEAST64 + ") which has already been bound to mem object 0x%" PRIxLEAST64, + apiName, (uint64_t)mem, handle, (uint64_t)pPrevBinding->mem); } else { pMemInfo->objBindings.insert({handle, type}); // For image objects, make sure default memory state is correctly set @@ -693,7 +693,7 @@ static bool set_mem_binding(layer_data *dev_data, VkDeviceMemory mem, uint64_t h } } } - return skipCall; + return skip_call; } // For NULL mem case, clear any previous binding Else... @@ -704,10 +704,10 @@ static bool set_mem_binding(layer_data *dev_data, VkDeviceMemory mem, uint64_t h // Return VK_TRUE if addition is successful, VK_FALSE otherwise static bool set_sparse_mem_binding(layer_data *dev_data, VkDeviceMemory mem, uint64_t handle, VkDebugReportObjectTypeEXT type, const char *apiName) { - bool skipCall = VK_FALSE; + bool skip_call = VK_FALSE; // Handle NULL case separately, just clear previous binding & decrement reference if (mem == VK_NULL_HANDLE) { - skipCall = clear_object_binding(dev_data, handle, type); + skip_call = clear_object_binding(dev_data, handle, type); } else { VkDeviceMemory *pMemBinding = get_object_mem_binding(dev_data, handle, type); assert(pMemBinding); @@ -718,7 +718,7 @@ static bool set_sparse_mem_binding(layer_data *dev_data, VkDeviceMemory mem, uin *pMemBinding = mem; } } - return skipCall; + return skip_call; } // For handle of given object type, return memory binding @@ -2998,7 +2998,7 @@ static bool verifyLineWidth(layer_data *my_data, DRAW_STATE_ERROR dsError, const // Verify that create state for a pipeline is valid static bool verifyPipelineCreateState(layer_data *my_data, const VkDevice device, std::vector<PIPELINE_NODE *> pPipelines, int pipelineIndex) { - bool skipCall = false; + bool skip_call = false; PIPELINE_NODE *pPipeline = pPipelines[pipelineIndex]; @@ -3009,12 +3009,12 @@ static bool verifyPipelineCreateState(layer_data *my_data, const VkDevice device PIPELINE_NODE *pBasePipeline = nullptr; if (!((pPipeline->graphicsPipelineCI.basePipelineHandle != VK_NULL_HANDLE) ^ (pPipeline->graphicsPipelineCI.basePipelineIndex != -1))) { - skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, - DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS", - "Invalid Pipeline CreateInfo: exactly one of base pipeline index and handle must be specified"); + skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, + DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS", + "Invalid Pipeline CreateInfo: exactly one of base pipeline index and handle must be specified"); } else if (pPipeline->graphicsPipelineCI.basePipelineIndex != -1) { if (pPipeline->graphicsPipelineCI.basePipelineIndex >= pipelineIndex) { - skipCall |= + skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS", "Invalid Pipeline CreateInfo: base pipeline must occur earlier in array than derivative pipeline."); @@ -3026,9 +3026,9 @@ static bool verifyPipelineCreateState(layer_data *my_data, const VkDevice device } if (pBasePipeline && !(pBasePipeline->graphicsPipelineCI.flags & VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT)) { - skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, - DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS", - "Invalid Pipeline CreateInfo: base pipeline does not allow derivatives."); + skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, + DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS", + "Invalid Pipeline CreateInfo: base pipeline does not allow derivatives."); } } @@ -3045,17 +3045,17 @@ static bool verifyPipelineCreateState(layer_data *my_data, const VkDevice device (pAttachments[0].dstAlphaBlendFactor != pAttachments[i].dstAlphaBlendFactor) || (pAttachments[0].alphaBlendOp != pAttachments[i].alphaBlendOp) || (pAttachments[0].colorWriteMask != pAttachments[i].colorWriteMask)) { - skipCall |= - log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, - DRAWSTATE_INDEPENDENT_BLEND, "DS", "Invalid Pipeline CreateInfo: If independent blend feature not " - "enabled, all elements of pAttachments must be identical"); + skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, + __LINE__, DRAWSTATE_INDEPENDENT_BLEND, "DS", + "Invalid Pipeline CreateInfo: If independent blend feature not " + "enabled, all elements of pAttachments must be identical"); } } } } if (!my_data->phys_dev_properties.features.logicOp && (pPipeline->graphicsPipelineCI.pColorBlendState->logicOpEnable != VK_FALSE)) { - skipCall |= + skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, DRAWSTATE_DISABLED_LOGIC_OP, "DS", "Invalid Pipeline CreateInfo: If logic operations feature not enabled, logicOpEnable must be VK_FALSE"); @@ -3063,7 +3063,7 @@ static bool verifyPipelineCreateState(layer_data *my_data, const VkDevice device if ((pPipeline->graphicsPipelineCI.pColorBlendState->logicOpEnable == VK_TRUE) && ((pPipeline->graphicsPipelineCI.pColorBlendState->logicOp < VK_LOGIC_OP_CLEAR) || (pPipeline->graphicsPipelineCI.pColorBlendState->logicOp > VK_LOGIC_OP_SET))) { - skipCall |= + skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, DRAWSTATE_INVALID_LOGIC_OP, "DS", "Invalid Pipeline CreateInfo: If logicOpEnable is VK_TRUE, logicOp must be a valid VkLogicOp value"); @@ -3076,88 +3076,89 @@ static bool verifyPipelineCreateState(layer_data *my_data, const VkDevice device auto renderPass = getRenderPass(my_data, pPipeline->graphicsPipelineCI.renderPass); if (renderPass && pPipeline->graphicsPipelineCI.subpass >= renderPass->pCreateInfo->subpassCount) { - skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, - DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS", "Invalid Pipeline CreateInfo State: Subpass index %u " - "is out of range for this renderpass (0..%u)", - pPipeline->graphicsPipelineCI.subpass, renderPass->pCreateInfo->subpassCount - 1); + skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, + DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS", "Invalid Pipeline CreateInfo State: Subpass index %u " + "is out of range for this renderpass (0..%u)", + pPipeline->graphicsPipelineCI.subpass, renderPass->pCreateInfo->subpassCount - 1); } if (!validate_and_capture_pipeline_shader_state(my_data->report_data, pPipeline, &my_data->phys_dev_properties.features, my_data->shaderModuleMap)) { - skipCall = true; + skip_call = true; } // Each shader's stage must be unique if (pPipeline->duplicate_shaders) { for (uint32_t stage = VK_SHADER_STAGE_VERTEX_BIT; stage & VK_SHADER_STAGE_ALL_GRAPHICS; stage <<= 1) { if (pPipeline->duplicate_shaders & stage) { - skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VkDebugReportObjectTypeEXT(0), 0, - __LINE__, DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS", - "Invalid Pipeline CreateInfo State: Multiple shaders provided for stage %s", - string_VkShaderStageFlagBits(VkShaderStageFlagBits(stage))); + skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VkDebugReportObjectTypeEXT(0), 0, + __LINE__, DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS", + "Invalid Pipeline CreateInfo State: Multiple shaders provided for stage %s", + string_VkShaderStageFlagBits(VkShaderStageFlagBits(stage))); } } } // VS is required if (!(pPipeline->active_shaders & VK_SHADER_STAGE_VERTEX_BIT)) { - skipCall |= + skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS", "Invalid Pipeline CreateInfo State: Vtx Shader required"); } // Either both or neither TC/TE shaders should be defined if (((pPipeline->active_shaders & VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) == 0) != ((pPipeline->active_shaders & VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT) == 0)) { - skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, - DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS", - "Invalid Pipeline CreateInfo State: TE and TC shaders must be included or excluded as a pair"); + skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, + DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS", + "Invalid Pipeline CreateInfo State: TE and TC shaders must be included or excluded as a pair"); } // Compute shaders should be specified independent of Gfx shaders if ((pPipeline->active_shaders & VK_SHADER_STAGE_COMPUTE_BIT) && (pPipeline->active_shaders & (VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT | VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT | VK_SHADER_STAGE_GEOMETRY_BIT | VK_SHADER_STAGE_FRAGMENT_BIT))) { - skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, - DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS", - "Invalid Pipeline CreateInfo State: Do not specify Compute Shader for Gfx Pipeline"); + skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, + DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS", + "Invalid Pipeline CreateInfo State: Do not specify Compute Shader for Gfx Pipeline"); } // VK_PRIMITIVE_TOPOLOGY_PATCH_LIST primitive topology is only valid for tessellation pipelines. // Mismatching primitive topology and tessellation fails graphics pipeline creation. if (pPipeline->active_shaders & (VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT | VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT) && (!pPipeline->graphicsPipelineCI.pInputAssemblyState || pPipeline->graphicsPipelineCI.pInputAssemblyState->topology != VK_PRIMITIVE_TOPOLOGY_PATCH_LIST)) { - skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, - DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS", "Invalid Pipeline CreateInfo State: " - "VK_PRIMITIVE_TOPOLOGY_PATCH_LIST must be set as IA " - "topology for tessellation pipelines"); + skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, + DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS", "Invalid Pipeline CreateInfo State: " + "VK_PRIMITIVE_TOPOLOGY_PATCH_LIST must be set as IA " + "topology for tessellation pipelines"); } if (pPipeline->graphicsPipelineCI.pInputAssemblyState && pPipeline->graphicsPipelineCI.pInputAssemblyState->topology == VK_PRIMITIVE_TOPOLOGY_PATCH_LIST) { if (~pPipeline->active_shaders & VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) { - skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, - DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS", "Invalid Pipeline CreateInfo State: " - "VK_PRIMITIVE_TOPOLOGY_PATCH_LIST primitive " - "topology is only valid for tessellation pipelines"); + skip_call |= + log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, + DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS", "Invalid Pipeline CreateInfo State: " + "VK_PRIMITIVE_TOPOLOGY_PATCH_LIST primitive " + "topology is only valid for tessellation pipelines"); } if (!pPipeline->graphicsPipelineCI.pTessellationState) { - skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, - DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS", - "Invalid Pipeline CreateInfo State: " - "pTessellationState is NULL when VK_PRIMITIVE_TOPOLOGY_PATCH_LIST primitive " - "topology used. pTessellationState must not be NULL in this case."); + skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, + DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS", + "Invalid Pipeline CreateInfo State: " + "pTessellationState is NULL when VK_PRIMITIVE_TOPOLOGY_PATCH_LIST primitive " + "topology used. pTessellationState must not be NULL in this case."); } else if (!pPipeline->graphicsPipelineCI.pTessellationState->patchControlPoints || (pPipeline->graphicsPipelineCI.pTessellationState->patchControlPoints > 32)) { - skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, - DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS", "Invalid Pipeline CreateInfo State: " - "VK_PRIMITIVE_TOPOLOGY_PATCH_LIST primitive " - "topology used with patchControlPoints value %u." - " patchControlPoints should be >0 and <=32.", - pPipeline->graphicsPipelineCI.pTessellationState->patchControlPoints); + skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, + DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, "DS", "Invalid Pipeline CreateInfo State: " + "VK_PRIMITIVE_TOPOLOGY_PATCH_LIST primitive " + "topology used with patchControlPoints value %u." + " patchControlPoints should be >0 and <=32.", + pPipeline->graphicsPipelineCI.pTessellationState->patchControlPoints); } } // If a rasterization state is provided, make sure that the line width conforms to the HW. if (pPipeline->graphicsPipelineCI.pRasterizationState) { if (!isDynamic(pPipeline, VK_DYNAMIC_STATE_LINE_WIDTH)) { - skipCall |= verifyLineWidth(my_data, DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, reinterpret_cast<uint64_t &>(pPipeline), - pPipeline->graphicsPipelineCI.pRasterizationState->lineWidth); + skip_call |= verifyLineWidth(my_data, DRAWSTATE_INVALID_PIPELINE_CREATE_STATE, reinterpret_cast<uint64_t &>(pPipeline), + pPipeline->graphicsPipelineCI.pRasterizationState->lineWidth); } } // Viewport state must be included if rasterization is enabled. @@ -3166,17 +3167,17 @@ static bool verifyPipelineCreateState(layer_data *my_data, const VkDevice device if (!pPipeline->graphicsPipelineCI.pRasterizationState || (pPipeline->graphicsPipelineCI.pRasterizationState->rasterizerDiscardEnable == VK_FALSE)) { if (!pPipeline->graphicsPipelineCI.pViewportState) { - skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, - DRAWSTATE_VIEWPORT_SCISSOR_MISMATCH, "DS", "Gfx Pipeline pViewportState is null. Even if viewport " - "and scissors are dynamic PSO must include " - "viewportCount and scissorCount in pViewportState."); + skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, + DRAWSTATE_VIEWPORT_SCISSOR_MISMATCH, "DS", "Gfx Pipeline pViewportState is null. Even if viewport " + "and scissors are dynamic PSO must include " + "viewportCount and scissorCount in pViewportState."); } else if (pPipeline->graphicsPipelineCI.pViewportState->scissorCount != pPipeline->graphicsPipelineCI.pViewportState->viewportCount) { - skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, - DRAWSTATE_VIEWPORT_SCISSOR_MISMATCH, "DS", - "Gfx Pipeline viewport count (%u) must match scissor count (%u).", - pPipeline->graphicsPipelineCI.pViewportState->viewportCount, - pPipeline->graphicsPipelineCI.pViewportState->scissorCount); + skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, + DRAWSTATE_VIEWPORT_SCISSOR_MISMATCH, "DS", + "Gfx Pipeline viewport count (%u) must match scissor count (%u).", + pPipeline->graphicsPipelineCI.pViewportState->viewportCount, + pPipeline->graphicsPipelineCI.pViewportState->scissorCount); } else { // If viewport or scissor are not dynamic, then verify that data is appropriate for count bool dynViewport = isDynamic(pPipeline, VK_DYNAMIC_STATE_VIEWPORT); @@ -3184,28 +3185,29 @@ static bool verifyPipelineCreateState(layer_data *my_data, const VkDevice device if (!dynViewport) { if (pPipeline->graphicsPipelineCI.pViewportState->viewportCount && !pPipeline->graphicsPipelineCI.pViewportState->pViewports) { - skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, - __LINE__, DRAWSTATE_VIEWPORT_SCISSOR_MISMATCH, "DS", - "Gfx Pipeline viewportCount is %u, but pViewports is NULL. For non-zero viewportCount, you " - "must either include pViewports data, or include viewport in pDynamicState and set it with " - "vkCmdSetViewport().", - pPipeline->graphicsPipelineCI.pViewportState->viewportCount); + skip_call |= + log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, + DRAWSTATE_VIEWPORT_SCISSOR_MISMATCH, "DS", + "Gfx Pipeline viewportCount is %u, but pViewports is NULL. For non-zero viewportCount, you " + "must either include pViewports data, or include viewport in pDynamicState and set it with " + "vkCmdSetViewport().", + pPipeline->graphicsPipelineCI.pViewportState->viewportCount); } } if (!dynScissor) { if (pPipeline->graphicsPipelineCI.pViewportState->scissorCount && !pPipeline->graphicsPipelineCI.pViewportState->pScissors) { - skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, - __LINE__, DRAWSTATE_VIEWPORT_SCISSOR_MISMATCH, "DS", - "Gfx Pipeline scissorCount is %u, but pScissors is NULL. For non-zero scissorCount, you " - "must either include pScissors data, or include scissor in pDynamicState and set it with " - "vkCmdSetScissor().", - pPipeline->graphicsPipelineCI.pViewportState->scissorCount); + skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, + __LINE__, DRAWSTATE_VIEWPORT_SCISSOR_MISMATCH, "DS", + "Gfx Pipeline scissorCount is %u, but pScissors is NULL. For non-zero scissorCount, you " + "must either include pScissors data, or include scissor in pDynamicState and set it with " + "vkCmdSetScissor().", + pPipeline->graphicsPipelineCI.pViewportState->scissorCount); } } } } - return skipCall; + return skip_call; } // Free the Pipeline nodes @@ -3271,7 +3273,7 @@ static uint32_t getUpdateEndIndex(layer_data *my_data, const VkDevice device, co static bool validateUpdateConsistency(layer_data *my_data, const VkDevice device, const VkDescriptorType layout_type, const GENERIC_HEADER *pUpdateStruct, uint32_t startIndex, uint32_t endIndex) { // First get actual type of update - bool skipCall = false; + bool skip_call = false; VkDescriptorType actualType = VK_DESCRIPTOR_TYPE_MAX_ENUM; switch (pUpdateStruct->sType) { case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET: @@ -3282,21 +3284,21 @@ static bool validateUpdateConsistency(layer_data *my_data, const VkDevice device return false; break; default: - skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, - DRAWSTATE_INVALID_UPDATE_STRUCT, "DS", - "Unexpected UPDATE struct of type %s (value %u) in vkUpdateDescriptors() struct tree", - string_VkStructureType(pUpdateStruct->sType), pUpdateStruct->sType); + skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, + DRAWSTATE_INVALID_UPDATE_STRUCT, "DS", + "Unexpected UPDATE struct of type %s (value %u) in vkUpdateDescriptors() struct tree", + string_VkStructureType(pUpdateStruct->sType), pUpdateStruct->sType); } - if (!skipCall) { + if (!skip_call) { if (layout_type != actualType) { - skipCall |= log_msg( + skip_call |= log_msg( my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, DRAWSTATE_DESCRIPTOR_TYPE_MISMATCH, "DS", "Write descriptor update has descriptor type %s that does not match overlapping binding descriptor type of %s!", string_VkDescriptorType(actualType), string_VkDescriptorType(layout_type)); } } - return skipCall; + return skip_call; } //TODO: Consolidate functions bool FindLayout(const GLOBAL_CB_NODE *pCB, ImageSubresourcePair imgpair, IMAGE_CMD_BUF_LAYOUT_NODE &node, const VkImageAspectFlags aspectMask) { @@ -3625,7 +3627,7 @@ static bool checkGraphicsOrComputeBit(const layer_data *my_data, VkQueueFlags fl // Add specified CMD to the CmdBuffer in given pCB, flagging errors if CB is not // in the recording state or if there's an issue with the Cmd ordering static bool addCmd(layer_data *my_data, GLOBAL_CB_NODE *pCB, const CMD_TYPE cmd, const char *caller_name) { - bool skipCall = false; + bool skip_call = false; auto pPool = getCommandPoolNode(my_data, pCB->createInfo.commandPool); if (pPool) { VkQueueFlags flags = my_data->phys_dev_properties.queue_family_properties[pPool->queueFamilyIndex].queueFlags; @@ -3643,7 +3645,7 @@ static bool addCmd(layer_data *my_data, GLOBAL_CB_NODE *pCB, const CMD_TYPE cmd, case CMD_RESETQUERYPOOL: case CMD_COPYQUERYPOOLRESULTS: case CMD_WRITETIMESTAMP: - skipCall |= checkGraphicsOrComputeBit(my_data, flags, cmdTypeToString(cmd).c_str()); + skip_call |= checkGraphicsOrComputeBit(my_data, flags, cmdTypeToString(cmd).c_str()); break; case CMD_SETVIEWPORTSTATE: case CMD_SETSCISSORSTATE: @@ -3667,11 +3669,11 @@ static bool addCmd(layer_data *my_data, GLOBAL_CB_NODE *pCB, const CMD_TYPE cmd, case CMD_BEGINRENDERPASS: case CMD_NEXTSUBPASS: case CMD_ENDRENDERPASS: - skipCall |= checkGraphicsBit(my_data, flags, cmdTypeToString(cmd).c_str()); + skip_call |= checkGraphicsBit(my_data, flags, cmdTypeToString(cmd).c_str()); break; case CMD_DISPATCH: case CMD_DISPATCHINDIRECT: - skipCall |= checkComputeBit(my_data, flags, cmdTypeToString(cmd).c_str()); + skip_call |= checkComputeBit(my_data, flags, cmdTypeToString(cmd).c_str()); break; case CMD_COPYBUFFER: case CMD_COPYIMAGE: @@ -3688,16 +3690,16 @@ static bool addCmd(layer_data *my_data, GLOBAL_CB_NODE *pCB, const CMD_TYPE cmd, } } if (pCB->state != CB_RECORDING) { - skipCall |= report_error_no_cb_begin(my_data, pCB->commandBuffer, caller_name); + skip_call |= report_error_no_cb_begin(my_data, pCB->commandBuffer, caller_name); } else { - skipCall |= validateCmdsInCmdBuffer(my_data, pCB, cmd); + skip_call |= validateCmdsInCmdBuffer(my_data, pCB, cmd); CMD_NODE cmdNode = {}; // init cmd node and append to end of cmd LL cmdNode.cmdNumber = ++pCB->numCmds; cmdNode.type = cmd; pCB->cmds.push_back(cmdNode); } - return skipCall; + return skip_call; } // Reset the command buffer state // Maintain the createInfo and set state to CB_NEW, but clear all other state @@ -3817,21 +3819,21 @@ static void set_cb_pso_status(GLOBAL_CB_NODE *pCB, const PIPELINE_NODE *pPipe) { // Print the last bound Gfx Pipeline static bool printPipeline(layer_data *my_data, const VkCommandBuffer cb) { - bool skipCall = false; + bool skip_call = false; GLOBAL_CB_NODE *pCB = getCBNode(my_data, cb); if (pCB) { PIPELINE_NODE *pPipeTrav = getPipeline(my_data, pCB->lastBound[VK_PIPELINE_BIND_POINT_GRAPHICS].pipeline); if (!pPipeTrav) { // nothing to print } else { - skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, - __LINE__, DRAWSTATE_NONE, "DS", "%s", - vk_print_vkgraphicspipelinecreateinfo( - reinterpret_cast<const VkGraphicsPipelineCreateInfo *>(&pPipeTrav->graphicsPipelineCI), "{DS}") - .c_str()); + skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, + __LINE__, DRAWSTATE_NONE, "DS", "%s", + vk_print_vkgraphicspipelinecreateinfo( + reinterpret_cast<const VkGraphicsPipelineCreateInfo *>(&pPipeTrav->graphicsPipelineCI), "{DS}") + .c_str()); } } - return skipCall; + return skip_call; } static void printCB(layer_data *my_data, const VkCommandBuffer cb) { @@ -3851,12 +3853,12 @@ static void printCB(layer_data *my_data, const VkCommandBuffer cb) { } static bool synchAndPrintDSConfig(layer_data *my_data, const VkCommandBuffer cb) { - bool skipCall = false; + bool skip_call = false; if (!(my_data->report_data->active_flags & VK_DEBUG_REPORT_INFORMATION_BIT_EXT)) { - return skipCall; + return skip_call; } - skipCall |= printPipeline(my_data, cb); - return skipCall; + skip_call |= printPipeline(my_data, cb); + return skip_call; } // Flags validation error if the associated call is made inside a render pass. The apiName @@ -4130,7 +4132,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyDevice(VkDevice device, const VkAllocationCall dev_data->queueMap.clear(); lock.unlock(); #if MTMERGESOURCE - bool skipCall = false; + bool skip_call = false; lock.lock(); log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, (uint64_t)device, __LINE__, MEMTRACK_NONE, "MEM", "Printing List details prior to vkDestroyDevice()"); @@ -4145,11 +4147,11 @@ VKAPI_ATTR void VKAPI_CALL DestroyDevice(VkDevice device, const VkAllocationCall pInfo = (*ii).second.get(); if (pInfo->allocInfo.allocationSize != 0) { // Valid Usage: All child objects created on device must have been destroyed prior to destroying device - skipCall |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, (uint64_t)pInfo->mem, __LINE__, MEMTRACK_MEMORY_LEAK, - "MEM", "Mem Object 0x%" PRIx64 " has not been freed. You should clean up this memory by calling " - "vkFreeMemory(0x%" PRIx64 ") prior to vkDestroyDevice().", + skip_call |= + log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, + (uint64_t)pInfo->mem, __LINE__, MEMTRACK_MEMORY_LEAK, "MEM", + "Mem Object 0x%" PRIx64 " has not been freed. You should clean up this memory by calling " + "vkFreeMemory(0x%" PRIx64 ") prior to vkDestroyDevice().", (uint64_t)(pInfo->mem), (uint64_t)(pInfo->mem)); } } @@ -4161,7 +4163,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyDevice(VkDevice device, const VkAllocationCall fprintf(stderr, "Device: 0x%p, key: 0x%p\n", device, key); #endif VkLayerDispatchTable *pDisp = dev_data->device_dispatch_table; - if (!skipCall) { + if (!skip_call) { pDisp->DestroyDevice(device, pAllocator); } #else @@ -4486,14 +4488,14 @@ static bool validateCommandBufferSimultaneousUse(layer_data *dev_data, GLOBAL_CB } static bool validateCommandBufferState(layer_data *dev_data, GLOBAL_CB_NODE *pCB) { - bool skipCall = false; + bool skip_call = false; // Validate ONE_TIME_SUBMIT_BIT CB is not being submitted more than once if ((pCB->beginInfo.flags & VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT) && (pCB->submitCount > 1)) { - skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0, - __LINE__, DRAWSTATE_COMMAND_BUFFER_SINGLE_SUBMIT_VIOLATION, "DS", - "CB 0x%" PRIxLEAST64 " was begun w/ VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT " - "set, but has been submitted 0x%" PRIxLEAST64 " times.", - (uint64_t)(pCB->commandBuffer), pCB->submitCount); + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, + 0, __LINE__, DRAWSTATE_COMMAND_BUFFER_SINGLE_SUBMIT_VIOLATION, "DS", + "CB 0x%" PRIxLEAST64 " was begun w/ VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT " + "set, but has been submitted 0x%" PRIxLEAST64 " times.", + (uint64_t)(pCB->commandBuffer), pCB->submitCount); } // Validate that cmd buffers have been updated if (CB_RECORDED != pCB->state) { @@ -4505,7 +4507,7 @@ static bool validateCommandBufferState(layer_data *dev_data, GLOBAL_CB_NODE *pCB const char *cause_str = (obj.type == VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT) ? "destroyed or updated" : "destroyed"; - skipCall |= + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, reinterpret_cast<uint64_t &>(pCB->commandBuffer), __LINE__, DRAWSTATE_INVALID_COMMAND_BUFFER, "DS", "You are submitting command buffer 0x%" PRIxLEAST64 " that is invalid because bound %s 0x%" PRIxLEAST64 @@ -4513,30 +4515,30 @@ static bool validateCommandBufferState(layer_data *dev_data, GLOBAL_CB_NODE *pCB reinterpret_cast<uint64_t &>(pCB->commandBuffer), type_str, obj.handle, cause_str); } } else { // Flag error for using CB w/o vkEndCommandBuffer() called - skipCall |= + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, (uint64_t)(pCB->commandBuffer), __LINE__, DRAWSTATE_NO_END_COMMAND_BUFFER, "DS", "You must call vkEndCommandBuffer() on CB 0x%" PRIxLEAST64 " before this call to vkQueueSubmit()!", (uint64_t)(pCB->commandBuffer)); } } - return skipCall; + return skip_call; } static bool validatePrimaryCommandBufferState(layer_data *dev_data, GLOBAL_CB_NODE *pCB) { // Track in-use for resources off of primary and any secondary CBs - bool skipCall = false; + bool skip_call = false; // If USAGE_SIMULTANEOUS_USE_BIT not set then CB cannot already be executing // on device - skipCall |= validateCommandBufferSimultaneousUse(dev_data, pCB); + skip_call |= validateCommandBufferSimultaneousUse(dev_data, pCB); - skipCall |= validateAndIncrementResources(dev_data, pCB); + skip_call |= validateAndIncrementResources(dev_data, pCB); if (!pCB->secondaryCommandBuffers.empty()) { for (auto secondaryCmdBuffer : pCB->secondaryCommandBuffers) { GLOBAL_CB_NODE *pSubCB = getCBNode(dev_data, secondaryCmdBuffer); - skipCall |= validateAndIncrementResources(dev_data, pSubCB); + skip_call |= validateAndIncrementResources(dev_data, pSubCB); if ((pSubCB->primaryCommandBuffer != pCB->commandBuffer) && !(pSubCB->beginInfo.flags & VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT)) { log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0, @@ -4551,47 +4553,48 @@ static bool validatePrimaryCommandBufferState(layer_data *dev_data, GLOBAL_CB_NO } } - skipCall |= validateCommandBufferState(dev_data, pCB); + skip_call |= validateCommandBufferState(dev_data, pCB); - return skipCall; + return skip_call; } static bool ValidateFenceForSubmit(layer_data *dev_data, FENCE_NODE *pFence) { - bool skipCall = false; + bool skip_call = false; if (pFence) { if (pFence->state == FENCE_INFLIGHT) { - skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, - (uint64_t)(pFence->fence), __LINE__, DRAWSTATE_INVALID_FENCE, "DS", - "Fence 0x%" PRIx64 " is already in use by another submission.", (uint64_t)(pFence->fence)); + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, + (uint64_t)(pFence->fence), __LINE__, DRAWSTATE_INVALID_FENCE, "DS", + "Fence 0x%" PRIx64 " is already in use by another submission.", (uint64_t)(pFence->fence)); } else if (pFence->state == FENCE_RETIRED) { - skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, - reinterpret_cast<uint64_t &>(pFence->fence), __LINE__, MEMTRACK_INVALID_FENCE_STATE, "MEM", - "Fence 0x%" PRIxLEAST64 " submitted in SIGNALED state. Fences must be reset before being submitted", - reinterpret_cast<uint64_t &>(pFence->fence)); + skip_call |= + log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, + reinterpret_cast<uint64_t &>(pFence->fence), __LINE__, MEMTRACK_INVALID_FENCE_STATE, "MEM", + "Fence 0x%" PRIxLEAST64 " submitted in SIGNALED state. Fences must be reset before being submitted", + reinterpret_cast<uint64_t &>(pFence->fence)); } } - return skipCall; + return skip_call; } VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(queue), layer_data_map); VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; std::unique_lock<std::mutex> lock(global_lock); auto pQueue = getQueueNode(dev_data, queue); auto pFence = getFenceNode(dev_data, fence); - skipCall |= ValidateFenceForSubmit(dev_data, pFence); + skip_call |= ValidateFenceForSubmit(dev_data, pFence); - if (skipCall) { + if (skip_call) { return VK_ERROR_VALIDATION_FAILED_EXT; } @@ -4624,7 +4627,7 @@ QueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, V pSemaphore->signaled = false; pSemaphore->in_use.fetch_add(1); } else { - skipCall |= + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, reinterpret_cast<const uint64_t &>(semaphore), __LINE__, DRAWSTATE_QUEUE_FORWARD_PROGRESS, "DS", "Queue 0x%" PRIx64 " is waiting on semaphore 0x%" PRIx64 " that has no way to be signaled.", @@ -4643,7 +4646,7 @@ QueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, V if (pSemaphore) { semaphoreList.push_back(semaphore); if (pSemaphore->signaled) { - skipCall |= + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, reinterpret_cast<const uint64_t &>(semaphore), __LINE__, DRAWSTATE_QUEUE_FORWARD_PROGRESS, "DS", "Queue 0x%" PRIx64 " is signaling semaphore 0x%" PRIx64 @@ -4662,7 +4665,7 @@ QueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, V for (uint32_t i = 0; i < submit->commandBufferCount; i++) { auto pCBNode = getCBNode(dev_data, submit->pCommandBuffers[i]); - skipCall |= ValidateCmdBufImageLayouts(dev_data, pCBNode); + skip_call |= ValidateCmdBufImageLayouts(dev_data, pCBNode); if (pCBNode) { cbs.push_back(submit->pCommandBuffers[i]); for (auto secondaryCmdBuffer : pCBNode->secondaryCommandBuffers) { @@ -4670,16 +4673,16 @@ QueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, V } pCBNode->submitCount++; // increment submit count - skipCall |= validatePrimaryCommandBufferState(dev_data, pCBNode); + skip_call |= validatePrimaryCommandBufferState(dev_data, pCBNode); // Call submit-time functions to validate/update state for (auto &function : pCBNode->validate_functions) { - skipCall |= function(); + skip_call |= function(); } for (auto &function : pCBNode->eventUpdates) { - skipCall |= function(queue); + skip_call |= function(queue); } for (auto &function : pCBNode->queryUpdates) { - skipCall |= function(queue); + skip_call |= function(queue); } } } @@ -4687,7 +4690,7 @@ QueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, V submitTarget.emplace_back(cbs, semaphoreList); } lock.unlock(); - if (!skipCall) + if (!skip_call) result = dev_data->device_dispatch_table->QueueSubmit(queue, submitCount, pSubmits, fence); return result; @@ -4724,12 +4727,12 @@ FreeMemory(VkDevice device, VkDeviceMemory mem, const VkAllocationCallbacks *pAl } static bool validateMemRange(layer_data *my_data, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size) { - bool skipCall = false; + bool skip_call = false; if (size == 0) { - skipCall = log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, - (uint64_t)mem, __LINE__, MEMTRACK_INVALID_MAP, "MEM", - "VkMapMemory: Attempting to map memory range of size zero"); + skip_call = log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, + (uint64_t)mem, __LINE__, MEMTRACK_INVALID_MAP, "MEM", + "VkMapMemory: Attempting to map memory range of size zero"); } auto mem_element = my_data->memObjMap.find(mem); @@ -4737,23 +4740,23 @@ static bool validateMemRange(layer_data *my_data, VkDeviceMemory mem, VkDeviceSi auto mem_info = mem_element->second.get(); // It is an application error to call VkMapMemory on an object that is already mapped if (mem_info->memRange.size != 0) { - skipCall = log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, - (uint64_t)mem, __LINE__, MEMTRACK_INVALID_MAP, "MEM", - "VkMapMemory: Attempting to map memory on an already-mapped object 0x%" PRIxLEAST64, (uint64_t)mem); + skip_call = log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, + (uint64_t)mem, __LINE__, MEMTRACK_INVALID_MAP, "MEM", + "VkMapMemory: Attempting to map memory on an already-mapped object 0x%" PRIxLEAST64, (uint64_t)mem); } // Validate that offset + size is within object's allocationSize if (size == VK_WHOLE_SIZE) { if (offset >= mem_info->allocInfo.allocationSize) { - skipCall = log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, (uint64_t)mem, __LINE__, MEMTRACK_INVALID_MAP, - "MEM", "Mapping Memory from 0x%" PRIx64 " to 0x%" PRIx64 - " with size of VK_WHOLE_SIZE oversteps total array size 0x%" PRIx64, - offset, mem_info->allocInfo.allocationSize, mem_info->allocInfo.allocationSize); + skip_call = log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, (uint64_t)mem, __LINE__, MEMTRACK_INVALID_MAP, + "MEM", "Mapping Memory from 0x%" PRIx64 " to 0x%" PRIx64 + " with size of VK_WHOLE_SIZE oversteps total array size 0x%" PRIx64, + offset, mem_info->allocInfo.allocationSize, mem_info->allocInfo.allocationSize); } } else { if ((offset + size) > mem_info->allocInfo.allocationSize) { - skipCall = + skip_call = log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, (uint64_t)mem, __LINE__, MEMTRACK_INVALID_MAP, "MEM", "Mapping Memory from 0x%" PRIx64 " to 0x%" PRIx64 " oversteps total array size 0x%" PRIx64, offset, @@ -4761,7 +4764,7 @@ static bool validateMemRange(layer_data *my_data, VkDeviceMemory mem, VkDeviceSi } } } - return skipCall; + return skip_call; } static void storeMemRanges(layer_data *my_data, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size) { @@ -4773,14 +4776,14 @@ static void storeMemRanges(layer_data *my_data, VkDeviceMemory mem, VkDeviceSize } static bool deleteMemRanges(layer_data *my_data, VkDeviceMemory mem) { - bool skipCall = false; + bool skip_call = false; auto mem_info = getMemObjInfo(my_data, mem); if (mem_info) { if (!mem_info->memRange.size) { // Valid Usage: memory must currently be mapped - skipCall = log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, - (uint64_t)mem, __LINE__, MEMTRACK_INVALID_MAP, "MEM", - "Unmapping Memory without memory being mapped: mem obj 0x%" PRIxLEAST64, (uint64_t)mem); + skip_call = log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, + (uint64_t)mem, __LINE__, MEMTRACK_INVALID_MAP, "MEM", + "Unmapping Memory without memory being mapped: mem obj 0x%" PRIxLEAST64, (uint64_t)mem); } mem_info->memRange.size = 0; if (mem_info->pData) { @@ -4788,7 +4791,7 @@ static bool deleteMemRanges(layer_data *my_data, VkDeviceMemory mem) { mem_info->pData = 0; } } - return skipCall; + return skip_call; } static char NoncoherentMemoryFillValue = 0xb; @@ -4815,19 +4818,19 @@ static void initializeAndTrackMemory(layer_data *dev_data, VkDeviceMemory mem, V // a fence being waited on should not already be signalled and // it should have been submitted on a queue or during acquire next image static inline bool verifyWaitFenceState(layer_data *dev_data, VkFence fence, const char *apiCall) { - bool skipCall = false; + bool skip_call = false; auto pFence = getFenceNode(dev_data, fence); if (pFence) { if (pFence->state == FENCE_UNSIGNALED) { - skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, - reinterpret_cast<uint64_t &>(fence), __LINE__, MEMTRACK_INVALID_FENCE_STATE, "MEM", - "%s called for fence 0x%" PRIxLEAST64 " which has not been submitted on a Queue or during " - "acquire next image.", - apiCall, reinterpret_cast<uint64_t &>(fence)); + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, + reinterpret_cast<uint64_t &>(fence), __LINE__, MEMTRACK_INVALID_FENCE_STATE, "MEM", + "%s called for fence 0x%" PRIxLEAST64 " which has not been submitted on a Queue or during " + "acquire next image.", + apiCall, reinterpret_cast<uint64_t &>(fence)); } } - return skipCall; + return skip_call; } VKAPI_ATTR VkResult VKAPI_CALL @@ -4863,20 +4866,18 @@ WaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBo VKAPI_ATTR VkResult VKAPI_CALL GetFenceStatus(VkDevice device, VkFence fence) { layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); - bool skipCall = false; - VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; + bool skip_call = false; std::unique_lock<std::mutex> lock(global_lock); - skipCall = verifyWaitFenceState(dev_data, fence, "vkGetFenceStatus"); + skip_call = verifyWaitFenceState(dev_data, fence, "vkGetFenceStatus"); lock.unlock(); - if (skipCall) - return result; + if (skip_call) + return VK_ERROR_VALIDATION_FAILED_EXT; - result = dev_data->device_dispatch_table->GetFenceStatus(device, fence); - bool skip_call = false; + VkResult result = dev_data->device_dispatch_table->GetFenceStatus(device, fence); lock.lock(); if (result == VK_SUCCESS) { - skipCall |= decrementResources(dev_data, 1, &fence); + skip_call |= decrementResources(dev_data, 1, &fence); } lock.unlock(); if (skip_call) @@ -4926,20 +4927,20 @@ VKAPI_ATTR VkResult VKAPI_CALL DeviceWaitIdle(VkDevice device) { VKAPI_ATTR void VKAPI_CALL DestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator) { layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); - bool skipCall = false; + bool skip_call = false; std::unique_lock<std::mutex> lock(global_lock); auto fence_pair = dev_data->fenceMap.find(fence); if (fence_pair != dev_data->fenceMap.end()) { if (fence_pair->second.state == FENCE_INFLIGHT) { - skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, - (uint64_t)(fence), __LINE__, DRAWSTATE_INVALID_FENCE, "DS", - "Fence 0x%" PRIx64 " is in use.", (uint64_t)(fence)); + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, + (uint64_t)(fence), __LINE__, DRAWSTATE_INVALID_FENCE, "DS", "Fence 0x%" PRIx64 " is in use.", + (uint64_t)(fence)); } dev_data->fenceMap.erase(fence_pair); } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->DestroyFence(device, fence, pAllocator); } @@ -5129,9 +5130,9 @@ static void remove_memory_ranges(uint64_t handle, VkDeviceMemory mem, vector<MEM VKAPI_ATTR void VKAPI_CALL DestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator) { layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); - bool skipCall = false; + bool skip_call = false; std::unique_lock<std::mutex> lock(global_lock); - if (!validateIdleBuffer(dev_data, buffer) && !skipCall) { + if (!validateIdleBuffer(dev_data, buffer) && !skip_call) { lock.unlock(); dev_data->device_dispatch_table->DestroyBuffer(device, buffer, pAllocator); lock.lock(); @@ -5161,8 +5162,8 @@ DestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCa VKAPI_ATTR void VKAPI_CALL DestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator) { layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); - bool skipCall = false; - if (!skipCall) { + bool skip_call = false; + if (!skip_call) { dev_data->device_dispatch_table->DestroyImage(device, image, pAllocator); } @@ -5209,8 +5210,7 @@ BindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceS std::unique_lock<std::mutex> lock(global_lock); // Track objects tied to memory uint64_t buffer_handle = (uint64_t)(buffer); - bool skipCall = - set_mem_binding(dev_data, mem, buffer_handle, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, "vkBindBufferMemory"); + bool skip_call = set_mem_binding(dev_data, mem, buffer_handle, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, "vkBindBufferMemory"); auto buffer_node = getBufferNode(dev_data, buffer); if (buffer_node) { VkMemoryRequirements memRequirements; @@ -5224,13 +5224,13 @@ BindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceS if (mem_info) { const MEMORY_RANGE range = insert_memory_ranges(buffer_handle, mem, memoryOffset, memRequirements, mem_info->bufferRanges); - skipCall |= validate_memory_range(dev_data, mem_info->imageRanges, range, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT); - skipCall |= ValidateMemoryTypes(dev_data, mem_info, memRequirements.memoryTypeBits, "BindBufferMemory"); + skip_call |= validate_memory_range(dev_data, mem_info->imageRanges, range, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT); + skip_call |= ValidateMemoryTypes(dev_data, mem_info, memRequirements.memoryTypeBits, "BindBufferMemory"); } // Validate memory requirements alignment if (vk_safe_modulo(memoryOffset, memRequirements.alignment) != 0) { - skipCall |= + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, 0, __LINE__, DRAWSTATE_INVALID_BUFFER_MEMORY_OFFSET, "DS", "vkBindBufferMemory(): memoryOffset is 0x%" PRIxLEAST64 " but must be an integer multiple of the " @@ -5242,7 +5242,7 @@ BindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceS VkBufferUsageFlags usage = dev_data->bufferMap[buffer].get()->createInfo.usage; if (usage & (VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT)) { if (vk_safe_modulo(memoryOffset, dev_data->phys_dev_properties.properties.limits.minTexelBufferOffsetAlignment) != 0) { - skipCall |= + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, 0, __LINE__, DRAWSTATE_INVALID_TEXEL_BUFFER_OFFSET, "DS", "vkBindBufferMemory(): memoryOffset is 0x%" PRIxLEAST64 " but must be a multiple of " @@ -5253,7 +5253,7 @@ BindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceS if (usage & VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT) { if (vk_safe_modulo(memoryOffset, dev_data->phys_dev_properties.properties.limits.minUniformBufferOffsetAlignment) != 0) { - skipCall |= + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, 0, __LINE__, DRAWSTATE_INVALID_UNIFORM_BUFFER_OFFSET, "DS", "vkBindBufferMemory(): memoryOffset is 0x%" PRIxLEAST64 " but must be a multiple of " @@ -5264,7 +5264,7 @@ BindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceS if (usage & VK_BUFFER_USAGE_STORAGE_BUFFER_BIT) { if (vk_safe_modulo(memoryOffset, dev_data->phys_dev_properties.properties.limits.minStorageBufferOffsetAlignment) != 0) { - skipCall |= + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, 0, __LINE__, DRAWSTATE_INVALID_STORAGE_BUFFER_OFFSET, "DS", "vkBindBufferMemory(): memoryOffset is 0x%" PRIxLEAST64 " but must be a multiple of " @@ -5275,7 +5275,7 @@ BindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceS } print_mem_list(dev_data); lock.unlock(); - if (!skipCall) { + if (!skip_call) { result = dev_data->device_dispatch_table->BindBufferMemory(device, buffer, mem, memoryOffset); } return result; @@ -5455,15 +5455,15 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateQueryPool(VkDevice device, const VkQueryPoo VKAPI_ATTR void VKAPI_CALL DestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator) { layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); - bool skipCall = false; + bool skip_call = false; std::unique_lock<std::mutex> lock(global_lock); // Verify that command buffers in pool are complete (not in-flight) auto pPool = getCommandPoolNode(dev_data, commandPool); - skipCall |= checkCommandBuffersInFlight(dev_data, pPool, "destroy command pool with"); + skip_call |= checkCommandBuffersInFlight(dev_data, pPool, "destroy command pool with"); lock.unlock(); - if (skipCall) + if (skip_call) return; dev_data->device_dispatch_table->DestroyCommandPool(device, commandPool, pAllocator); @@ -5484,14 +5484,14 @@ DestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocatio VKAPI_ATTR VkResult VKAPI_CALL ResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) { layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); - bool skipCall = false; + bool skip_call = false; std::unique_lock<std::mutex> lock(global_lock); auto pPool = getCommandPoolNode(dev_data, commandPool); - skipCall |= checkCommandBuffersInFlight(dev_data, pPool, "reset command pool with"); + skip_call |= checkCommandBuffersInFlight(dev_data, pPool, "reset command pool with"); lock.unlock(); - if (skipCall) + if (skip_call) return VK_ERROR_VALIDATION_FAILED_EXT; VkResult result = dev_data->device_dispatch_table->ResetCommandPool(device, commandPool, flags); @@ -5510,20 +5510,19 @@ ResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetF VKAPI_ATTR VkResult VKAPI_CALL ResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences) { layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); - bool skipCall = false; + bool skip_call = false; std::unique_lock<std::mutex> lock(global_lock); for (uint32_t i = 0; i < fenceCount; ++i) { auto pFence = getFenceNode(dev_data, pFences[i]); if (pFence && pFence->state == FENCE_INFLIGHT) { - skipCall |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, - reinterpret_cast<const uint64_t &>(pFences[i]), __LINE__, DRAWSTATE_INVALID_FENCE, "DS", - "Fence 0x%" PRIx64 " is in use.", reinterpret_cast<const uint64_t &>(pFences[i])); + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, + reinterpret_cast<const uint64_t &>(pFences[i]), __LINE__, DRAWSTATE_INVALID_FENCE, "DS", + "Fence 0x%" PRIx64 " is in use.", reinterpret_cast<const uint64_t &>(pFences[i])); } } lock.unlock(); - if (skipCall) + if (skip_call) return VK_ERROR_VALIDATION_FAILED_EXT; VkResult result = dev_data->device_dispatch_table->ResetFences(device, fenceCount, pFences); @@ -5824,7 +5823,7 @@ CreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t // 1. Pipeline create state is first shadowed into PIPELINE_NODE struct // 2. Create state is then validated (which uses flags setup during shadowing) // 3. If everything looks good, we'll then create the pipeline and add NODE to pipelineMap - bool skipCall = false; + bool skip_call = false; // TODO : Improve this data struct w/ unique_ptrs so cleanup below is automatic vector<PIPELINE_NODE *> pPipeNode(count); layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); @@ -5838,10 +5837,10 @@ CreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t pPipeNode[i]->render_pass_ci.initialize(getRenderPass(dev_data, pCreateInfos[i].renderPass)->pCreateInfo); pPipeNode[i]->pipelineLayout = getPipelineLayout(dev_data, pCreateInfos[i].layout); - skipCall |= verifyPipelineCreateState(dev_data, device, pPipeNode, i); + skip_call |= verifyPipelineCreateState(dev_data, device, pPipeNode, i); } - if (!skipCall) { + if (!skip_call) { lock.unlock(); result = dev_data->device_dispatch_table->CreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pAllocator, pPipelines); @@ -5866,7 +5865,7 @@ CreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t const VkComputePipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) { VkResult result = VK_SUCCESS; - bool skipCall = false; + bool skip_call = false; // TODO : Improve this data struct w/ unique_ptrs so cleanup below is automatic vector<PIPELINE_NODE *> pPipeNode(count); @@ -5884,13 +5883,12 @@ CreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t // memcpy(&pPipeNode[i]->computePipelineCI, (const void *)&pCreateInfos[i], sizeof(VkComputePipelineCreateInfo)); // TODO: Add Compute Pipeline Verification - skipCall |= !validate_compute_pipeline(dev_data->report_data, pPipeNode[i], - &dev_data->phys_dev_properties.features, - dev_data->shaderModuleMap); - // skipCall |= verifyPipelineCreateState(dev_data, device, pPipeNode[i]); + skip_call |= !validate_compute_pipeline(dev_data->report_data, pPipeNode[i], &dev_data->phys_dev_properties.features, + dev_data->shaderModuleMap); + // skip_call |= verifyPipelineCreateState(dev_data, device, pPipeNode[i]); } - if (!skipCall) { + if (!skip_call) { lock.unlock(); result = dev_data->device_dispatch_table->CreateComputePipelines(device, pipelineCache, count, pCreateInfos, pAllocator, pPipelines); @@ -5941,82 +5939,82 @@ CreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo static bool validatePushConstantRange(const layer_data *dev_data, const uint32_t offset, const uint32_t size, const char *caller_name, uint32_t index = 0) { uint32_t const maxPushConstantsSize = dev_data->phys_dev_properties.properties.limits.maxPushConstantsSize; - bool skipCall = false; + bool skip_call = false; // Check that offset + size don't exceed the max. // Prevent arithetic overflow here by avoiding addition and testing in this order. if ((offset >= maxPushConstantsSize) || (size > maxPushConstantsSize - offset)) { // This is a pain just to adapt the log message to the caller, but better to sort it out only when there is a problem. if (0 == strcmp(caller_name, "vkCreatePipelineLayout()")) { - skipCall |= + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, DRAWSTATE_PUSH_CONSTANTS_ERROR, "DS", "%s call has push constants index %u with offset %u and size %u that " "exceeds this device's maxPushConstantSize of %u.", caller_name, index, offset, size, maxPushConstantsSize); } else if (0 == strcmp(caller_name, "vkCmdPushConstants()")) { - skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, - DRAWSTATE_PUSH_CONSTANTS_ERROR, "DS", "%s call has push constants with offset %u and size %u that " - "exceeds this device's maxPushConstantSize of %u.", - caller_name, offset, size, maxPushConstantsSize); + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, + DRAWSTATE_PUSH_CONSTANTS_ERROR, "DS", "%s call has push constants with offset %u and size %u that " + "exceeds this device's maxPushConstantSize of %u.", + caller_name, offset, size, maxPushConstantsSize); } else { - skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, - DRAWSTATE_INTERNAL_ERROR, "DS", "%s caller not supported.", caller_name); + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, + DRAWSTATE_INTERNAL_ERROR, "DS", "%s caller not supported.", caller_name); } } // size needs to be non-zero and a multiple of 4. if ((size == 0) || ((size & 0x3) != 0)) { if (0 == strcmp(caller_name, "vkCreatePipelineLayout()")) { - skipCall |= + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, DRAWSTATE_PUSH_CONSTANTS_ERROR, "DS", "%s call has push constants index %u with " "size %u. Size must be greater than zero and a multiple of 4.", caller_name, index, size); } else if (0 == strcmp(caller_name, "vkCmdPushConstants()")) { - skipCall |= + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, DRAWSTATE_PUSH_CONSTANTS_ERROR, "DS", "%s call has push constants with " "size %u. Size must be greater than zero and a multiple of 4.", caller_name, size); } else { - skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, - DRAWSTATE_INTERNAL_ERROR, "DS", "%s caller not supported.", caller_name); + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, + DRAWSTATE_INTERNAL_ERROR, "DS", "%s caller not supported.", caller_name); } } // offset needs to be a multiple of 4. if ((offset & 0x3) != 0) { if (0 == strcmp(caller_name, "vkCreatePipelineLayout()")) { - skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, - DRAWSTATE_PUSH_CONSTANTS_ERROR, "DS", "%s call has push constants index %u with " - "offset %u. Offset must be a multiple of 4.", - caller_name, index, offset); + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, + DRAWSTATE_PUSH_CONSTANTS_ERROR, "DS", "%s call has push constants index %u with " + "offset %u. Offset must be a multiple of 4.", + caller_name, index, offset); } else if (0 == strcmp(caller_name, "vkCmdPushConstants()")) { - skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, - DRAWSTATE_PUSH_CONSTANTS_ERROR, "DS", "%s call has push constants with " - "offset %u. Offset must be a multiple of 4.", - caller_name, offset); + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, + DRAWSTATE_PUSH_CONSTANTS_ERROR, "DS", "%s call has push constants with " + "offset %u. Offset must be a multiple of 4.", + caller_name, offset); } else { - skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, - DRAWSTATE_INTERNAL_ERROR, "DS", "%s caller not supported.", caller_name); + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, + DRAWSTATE_INTERNAL_ERROR, "DS", "%s caller not supported.", caller_name); } } - return skipCall; + return skip_call; } VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); // Push Constant Range checks uint32_t i = 0; for (i = 0; i < pCreateInfo->pushConstantRangeCount; ++i) { - skipCall |= validatePushConstantRange(dev_data, pCreateInfo->pPushConstantRanges[i].offset, - pCreateInfo->pPushConstantRanges[i].size, "vkCreatePipelineLayout()", i); + skip_call |= validatePushConstantRange(dev_data, pCreateInfo->pPushConstantRanges[i].offset, + pCreateInfo->pPushConstantRanges[i].size, "vkCreatePipelineLayout()", i); if (0 == pCreateInfo->pPushConstantRanges[i].stageFlags) { - skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, - DRAWSTATE_PUSH_CONSTANTS_ERROR, "DS", "vkCreatePipelineLayout() call has no stageFlags set."); + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, + DRAWSTATE_PUSH_CONSTANTS_ERROR, "DS", "vkCreatePipelineLayout() call has no stageFlags set."); } } // Each range has been validated. Now check for overlap between ranges (if they are good). - if (!skipCall) { + if (!skip_call) { uint32_t i, j; for (i = 0; i < pCreateInfo->pushConstantRangeCount; ++i) { for (j = i + 1; j < pCreateInfo->pushConstantRangeCount; ++j) { @@ -6025,7 +6023,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineLayout(VkDevice device, const VkPip const uint32_t minB = pCreateInfo->pPushConstantRanges[j].offset; const uint32_t maxB = minB + pCreateInfo->pPushConstantRanges[j].size; if ((minA <= minB && maxA > minB) || (minB <= minA && maxB > minA)) { - skipCall |= + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, DRAWSTATE_PUSH_CONSTANTS_ERROR, "DS", "vkCreatePipelineLayout() call has push constants with " "overlapping ranges: %u:[%u, %u), %u:[%u, %u)", @@ -6035,7 +6033,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineLayout(VkDevice device, const VkPip } } - if (skipCall) + if (skip_call) return VK_ERROR_VALIDATION_FAILED_EXT; VkResult result = dev_data->device_dispatch_table->CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout); @@ -6174,9 +6172,9 @@ FreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t co layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); // Make sure that no sets being destroyed are in-flight std::unique_lock<std::mutex> lock(global_lock); - bool skipCall = PreCallValidateFreeDescriptorSets(dev_data, descriptorPool, count, pDescriptorSets); + bool skip_call = PreCallValidateFreeDescriptorSets(dev_data, descriptorPool, count, pDescriptorSets); lock.unlock(); - if (skipCall) + if (skip_call) return VK_ERROR_VALIDATION_FAILED_EXT; VkResult result = dev_data->device_dispatch_table->FreeDescriptorSets(device, descriptorPool, count, pDescriptorSets); if (VK_SUCCESS == result) { @@ -6258,7 +6256,7 @@ AllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pCrea VKAPI_ATTR VkResult VKAPI_CALL BeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); // Validate command buffer level @@ -6266,7 +6264,7 @@ BeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo if (pCB) { // This implicitly resets the Cmd Buffer so make sure any fence is done and then clear memory references if (dev_data->globalInFlightCmdBuffers.count(commandBuffer)) { - skipCall |= + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, (uint64_t)commandBuffer, __LINE__, MEMTRACK_RESET_CB_WHILE_IN_FLIGHT, "MEM", "Calling vkBeginCommandBuffer() on active CB 0x%p before it has completed. " @@ -6278,7 +6276,7 @@ BeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo // Secondary Command Buffer const VkCommandBufferInheritanceInfo *pInfo = pBeginInfo->pInheritanceInfo; if (!pInfo) { - skipCall |= + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, reinterpret_cast<uint64_t>(commandBuffer), __LINE__, DRAWSTATE_BEGIN_CB_INVALID_STATE, "DS", "vkBeginCommandBuffer(): Secondary Command Buffer (0x%p) must have inheritance info.", @@ -6286,19 +6284,19 @@ BeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo } else { if (pBeginInfo->flags & VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT) { if (!pInfo->renderPass) { // renderpass should NOT be null for a Secondary CB - skipCall |= log_msg( + skip_call |= log_msg( dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, reinterpret_cast<uint64_t>(commandBuffer), __LINE__, DRAWSTATE_BEGIN_CB_INVALID_STATE, "DS", "vkBeginCommandBuffer(): Secondary Command Buffers (0x%p) must specify a valid renderpass parameter.", reinterpret_cast<void *>(commandBuffer)); } if (!pInfo->framebuffer) { // framebuffer may be null for a Secondary CB, but this affects perf - skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - reinterpret_cast<uint64_t>(commandBuffer), __LINE__, DRAWSTATE_BEGIN_CB_INVALID_STATE, - "DS", "vkBeginCommandBuffer(): Secondary Command Buffers (0x%p) may perform better if a " - "valid framebuffer parameter is specified.", - reinterpret_cast<void *>(commandBuffer)); + skip_call |= log_msg( + dev_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, + reinterpret_cast<uint64_t>(commandBuffer), __LINE__, DRAWSTATE_BEGIN_CB_INVALID_STATE, "DS", + "vkBeginCommandBuffer(): Secondary Command Buffers (0x%p) may perform better if a " + "valid framebuffer parameter is specified.", + reinterpret_cast<void *>(commandBuffer)); } else { string errorString = ""; auto framebuffer = getFramebuffer(dev_data, pInfo->framebuffer); @@ -6308,7 +6306,7 @@ BeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo getRenderPass(dev_data, pInfo->renderPass)->pCreateInfo, errorString)) { // renderPass that framebuffer was created with must be compatible with local renderPass - skipCall |= log_msg( + skip_call |= log_msg( dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, reinterpret_cast<uint64_t>(commandBuffer), __LINE__, DRAWSTATE_RENDERPASS_INCOMPATIBLE, "DS", @@ -6327,31 +6325,31 @@ BeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo if ((pInfo->occlusionQueryEnable == VK_FALSE || dev_data->phys_dev_properties.features.occlusionQueryPrecise == VK_FALSE) && (pInfo->queryFlags & VK_QUERY_CONTROL_PRECISE_BIT)) { - skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, reinterpret_cast<uint64_t>(commandBuffer), - __LINE__, DRAWSTATE_BEGIN_CB_INVALID_STATE, "DS", - "vkBeginCommandBuffer(): Secondary Command Buffer (0x%p) must not have " - "VK_QUERY_CONTROL_PRECISE_BIT if occulusionQuery is disabled or the device does not " - "support precise occlusion queries.", - reinterpret_cast<void *>(commandBuffer)); + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, reinterpret_cast<uint64_t>(commandBuffer), + __LINE__, DRAWSTATE_BEGIN_CB_INVALID_STATE, "DS", + "vkBeginCommandBuffer(): Secondary Command Buffer (0x%p) must not have " + "VK_QUERY_CONTROL_PRECISE_BIT if occulusionQuery is disabled or the device does not " + "support precise occlusion queries.", + reinterpret_cast<void *>(commandBuffer)); } } if (pInfo && pInfo->renderPass != VK_NULL_HANDLE) { auto renderPass = getRenderPass(dev_data, pInfo->renderPass); if (renderPass) { if (pInfo->subpass >= renderPass->pCreateInfo->subpassCount) { - skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, (uint64_t)commandBuffer, __LINE__, - DRAWSTATE_BEGIN_CB_INVALID_STATE, "DS", - "vkBeginCommandBuffer(): Secondary Command Buffers (0x%p) must has a subpass index (%d) " - "that is less than the number of subpasses (%d).", - (void *)commandBuffer, pInfo->subpass, renderPass->pCreateInfo->subpassCount); + skip_call |= log_msg( + dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, + (uint64_t)commandBuffer, __LINE__, DRAWSTATE_BEGIN_CB_INVALID_STATE, "DS", + "vkBeginCommandBuffer(): Secondary Command Buffers (0x%p) must has a subpass index (%d) " + "that is less than the number of subpasses (%d).", + (void *)commandBuffer, pInfo->subpass, renderPass->pCreateInfo->subpassCount); } } } } if (CB_RECORDING == pCB->state) { - skipCall |= + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, (uint64_t)commandBuffer, __LINE__, DRAWSTATE_BEGIN_CB_INVALID_STATE, "DS", "vkBeginCommandBuffer(): Cannot call Begin on CB (0x%" PRIxLEAST64 @@ -6361,7 +6359,7 @@ BeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo VkCommandPool cmdPool = pCB->createInfo.commandPool; auto pPool = getCommandPoolNode(dev_data, cmdPool); if (!(VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT & pPool->createFlags)) { - skipCall |= + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, (uint64_t)commandBuffer, __LINE__, DRAWSTATE_INVALID_COMMAND_BUFFER_RESET, "DS", "Call to vkBeginCommandBuffer() on command buffer (0x%" PRIxLEAST64 @@ -6386,12 +6384,12 @@ BeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo } } } else { - skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - (uint64_t)commandBuffer, __LINE__, DRAWSTATE_INVALID_COMMAND_BUFFER, "DS", - "In vkBeginCommandBuffer() and unable to find CommandBuffer Node for CB 0x%p!", (void *)commandBuffer); + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, + (uint64_t)commandBuffer, __LINE__, DRAWSTATE_INVALID_COMMAND_BUFFER, "DS", + "In vkBeginCommandBuffer() and unable to find CommandBuffer Node for CB 0x%p!", (void *)commandBuffer); } lock.unlock(); - if (skipCall) { + if (skip_call) { return VK_ERROR_VALIDATION_FAILED_EXT; } VkResult result = dev_data->device_dispatch_table->BeginCommandBuffer(commandBuffer, pBeginInfo); @@ -6400,7 +6398,7 @@ BeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo } VKAPI_ATTR VkResult VKAPI_CALL EndCommandBuffer(VkCommandBuffer commandBuffer) { - bool skipCall = false; + bool skip_call = false; VkResult result = VK_SUCCESS; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); @@ -6409,17 +6407,17 @@ VKAPI_ATTR VkResult VKAPI_CALL EndCommandBuffer(VkCommandBuffer commandBuffer) { if ((VK_COMMAND_BUFFER_LEVEL_PRIMARY == pCB->createInfo.level) || !(pCB->beginInfo.flags & VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT)) { // This needs spec clarification to update valid usage, see comments in PR: // https://github.com/KhronosGroup/Vulkan-LoaderAndValidationLayers/pull/516#discussion_r63013756 - skipCall |= insideRenderPass(dev_data, pCB, "vkEndCommandBuffer"); + skip_call |= insideRenderPass(dev_data, pCB, "vkEndCommandBuffer"); } - skipCall |= addCmd(dev_data, pCB, CMD_END, "vkEndCommandBuffer()"); + skip_call |= addCmd(dev_data, pCB, CMD_END, "vkEndCommandBuffer()"); for (auto query : pCB->activeQueries) { - skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, - DRAWSTATE_INVALID_QUERY, "DS", - "Ending command buffer with in progress query: queryPool 0x%" PRIx64 ", index %d", - (uint64_t)(query.pool), query.index); + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, + DRAWSTATE_INVALID_QUERY, "DS", + "Ending command buffer with in progress query: queryPool 0x%" PRIx64 ", index %d", + (uint64_t)(query.pool), query.index); } } - if (!skipCall) { + if (!skip_call) { lock.unlock(); result = dev_data->device_dispatch_table->EndCommandBuffer(commandBuffer); lock.lock(); @@ -6467,14 +6465,14 @@ ResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flag VKAPI_ATTR void VKAPI_CALL CmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { - skipCall |= addCmd(dev_data, pCB, CMD_BINDPIPELINE, "vkCmdBindPipeline()"); + skip_call |= addCmd(dev_data, pCB, CMD_BINDPIPELINE, "vkCmdBindPipeline()"); if ((VK_PIPELINE_BIND_POINT_COMPUTE == pipelineBindPoint) && (pCB->activeRenderPass)) { - skipCall |= + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, (uint64_t)pipeline, __LINE__, DRAWSTATE_INVALID_RENDERPASS_CMD, "DS", "Incorrectly binding compute pipeline (0x%" PRIxLEAST64 ") during active RenderPass (0x%" PRIxLEAST64 ")", @@ -6487,47 +6485,47 @@ CmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindP set_cb_pso_status(pCB, pPN); set_pipeline_state(pPN); } else { - skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - (uint64_t)pipeline, __LINE__, DRAWSTATE_INVALID_PIPELINE, "DS", - "Attempt to bind Pipeline 0x%" PRIxLEAST64 " that doesn't exist!", (uint64_t)(pipeline)); + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, + (uint64_t)pipeline, __LINE__, DRAWSTATE_INVALID_PIPELINE, "DS", + "Attempt to bind Pipeline 0x%" PRIxLEAST64 " that doesn't exist!", (uint64_t)(pipeline)); } } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline); } VKAPI_ATTR void VKAPI_CALL CmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport *pViewports) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { - skipCall |= addCmd(dev_data, pCB, CMD_SETVIEWPORTSTATE, "vkCmdSetViewport()"); + skip_call |= addCmd(dev_data, pCB, CMD_SETVIEWPORTSTATE, "vkCmdSetViewport()"); pCB->status |= CBSTATUS_VIEWPORT_SET; pCB->viewports.resize(viewportCount); memcpy(pCB->viewports.data(), pViewports, viewportCount * sizeof(VkViewport)); } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->CmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports); } VKAPI_ATTR void VKAPI_CALL CmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D *pScissors) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { - skipCall |= addCmd(dev_data, pCB, CMD_SETSCISSORSTATE, "vkCmdSetScissor()"); + skip_call |= addCmd(dev_data, pCB, CMD_SETSCISSORSTATE, "vkCmdSetScissor()"); pCB->status |= CBSTATUS_SCISSOR_SET; pCB->scissors.resize(scissorCount); memcpy(pCB->scissors.data(), pScissors, scissorCount * sizeof(VkRect2D)); } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->CmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors); } @@ -6557,91 +6555,91 @@ VKAPI_ATTR void VKAPI_CALL CmdSetLineWidth(VkCommandBuffer commandBuffer, float VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { - skipCall |= addCmd(dev_data, pCB, CMD_SETDEPTHBIASSTATE, "vkCmdSetDepthBias()"); + skip_call |= addCmd(dev_data, pCB, CMD_SETDEPTHBIASSTATE, "vkCmdSetDepthBias()"); pCB->status |= CBSTATUS_DEPTH_BIAS_SET; } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); } VKAPI_ATTR void VKAPI_CALL CmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { - skipCall |= addCmd(dev_data, pCB, CMD_SETBLENDSTATE, "vkCmdSetBlendConstants()"); + skip_call |= addCmd(dev_data, pCB, CMD_SETBLENDSTATE, "vkCmdSetBlendConstants()"); pCB->status |= CBSTATUS_BLEND_CONSTANTS_SET; } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->CmdSetBlendConstants(commandBuffer, blendConstants); } VKAPI_ATTR void VKAPI_CALL CmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { - skipCall |= addCmd(dev_data, pCB, CMD_SETDEPTHBOUNDSSTATE, "vkCmdSetDepthBounds()"); + skip_call |= addCmd(dev_data, pCB, CMD_SETDEPTHBOUNDSSTATE, "vkCmdSetDepthBounds()"); pCB->status |= CBSTATUS_DEPTH_BOUNDS_SET; } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds); } VKAPI_ATTR void VKAPI_CALL CmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { - skipCall |= addCmd(dev_data, pCB, CMD_SETSTENCILREADMASKSTATE, "vkCmdSetStencilCompareMask()"); + skip_call |= addCmd(dev_data, pCB, CMD_SETSTENCILREADMASKSTATE, "vkCmdSetStencilCompareMask()"); pCB->status |= CBSTATUS_STENCIL_READ_MASK_SET; } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask); } VKAPI_ATTR void VKAPI_CALL CmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { - skipCall |= addCmd(dev_data, pCB, CMD_SETSTENCILWRITEMASKSTATE, "vkCmdSetStencilWriteMask()"); + skip_call |= addCmd(dev_data, pCB, CMD_SETSTENCILWRITEMASKSTATE, "vkCmdSetStencilWriteMask()"); pCB->status |= CBSTATUS_STENCIL_WRITE_MASK_SET; } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask); } VKAPI_ATTR void VKAPI_CALL CmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { - skipCall |= addCmd(dev_data, pCB, CMD_SETSTENCILREFERENCESTATE, "vkCmdSetStencilReference()"); + skip_call |= addCmd(dev_data, pCB, CMD_SETSTENCILREFERENCESTATE, "vkCmdSetStencilReference()"); pCB->status |= CBSTATUS_STENCIL_REFERENCE_SET; } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->CmdSetStencilReference(commandBuffer, faceMask, reference); } @@ -6649,7 +6647,7 @@ VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t *pDynamicOffsets) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); @@ -6671,26 +6669,26 @@ CmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelin pSet->BindCommandBuffer(pCB); pCB->lastBound[pipelineBindPoint].pipelineLayout = layout; pCB->lastBound[pipelineBindPoint].boundDescriptorSets[i + firstSet] = pSet; - skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, (uint64_t)pDescriptorSets[i], __LINE__, - DRAWSTATE_NONE, "DS", "DS 0x%" PRIxLEAST64 " bound on pipeline %s", - (uint64_t)pDescriptorSets[i], string_VkPipelineBindPoint(pipelineBindPoint)); + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, (uint64_t)pDescriptorSets[i], __LINE__, + DRAWSTATE_NONE, "DS", "DS 0x%" PRIxLEAST64 " bound on pipeline %s", + (uint64_t)pDescriptorSets[i], string_VkPipelineBindPoint(pipelineBindPoint)); if (!pSet->IsUpdated() && (pSet->GetTotalDescriptorCount() != 0)) { - skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, (uint64_t)pDescriptorSets[i], - __LINE__, DRAWSTATE_DESCRIPTOR_SET_NOT_UPDATED, "DS", - "DS 0x%" PRIxLEAST64 - " bound but it was never updated. You may want to either update it or not bind it.", - (uint64_t)pDescriptorSets[i]); + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, (uint64_t)pDescriptorSets[i], __LINE__, + DRAWSTATE_DESCRIPTOR_SET_NOT_UPDATED, "DS", + "DS 0x%" PRIxLEAST64 + " bound but it was never updated. You may want to either update it or not bind it.", + (uint64_t)pDescriptorSets[i]); } // Verify that set being bound is compatible with overlapping setLayout of pipelineLayout if (!verify_set_layout_compatibility(dev_data, pSet, layout, i + firstSet, errorString)) { - skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, (uint64_t)pDescriptorSets[i], __LINE__, - DRAWSTATE_PIPELINE_LAYOUTS_INCOMPATIBLE, "DS", - "descriptorSet #%u being bound is not compatible with overlapping descriptorSetLayout " - "at index %u of pipelineLayout 0x%" PRIxLEAST64 " due to: %s", - i, i + firstSet, reinterpret_cast<uint64_t &>(layout), errorString.c_str()); + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, (uint64_t)pDescriptorSets[i], __LINE__, + DRAWSTATE_PIPELINE_LAYOUTS_INCOMPATIBLE, "DS", + "descriptorSet #%u being bound is not compatible with overlapping descriptorSetLayout " + "at index %u of pipelineLayout 0x%" PRIxLEAST64 " due to: %s", + i, i + firstSet, reinterpret_cast<uint64_t &>(layout), errorString.c_str()); } auto setDynamicDescriptorCount = pSet->GetDynamicDescriptorCount(); @@ -6700,7 +6698,7 @@ CmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelin if (setDynamicDescriptorCount) { // First make sure we won't overstep bounds of pDynamicOffsets array if ((totalDynamicDescriptors + setDynamicDescriptorCount) > dynamicOffsetCount) { - skipCall |= + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, (uint64_t)pDescriptorSets[i], __LINE__, DRAWSTATE_INVALID_DYNAMIC_OFFSET_COUNT, "DS", @@ -6717,7 +6715,7 @@ CmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelin if (vk_safe_modulo( pDynamicOffsets[cur_dyn_offset], dev_data->phys_dev_properties.properties.limits.minUniformBufferOffsetAlignment) != 0) { - skipCall |= log_msg( + skip_call |= log_msg( dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, 0, __LINE__, DRAWSTATE_INVALID_UNIFORM_BUFFER_OFFSET, "DS", @@ -6731,7 +6729,7 @@ CmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelin if (vk_safe_modulo( pDynamicOffsets[cur_dyn_offset], dev_data->phys_dev_properties.properties.limits.minStorageBufferOffsetAlignment) != 0) { - skipCall |= log_msg( + skip_call |= log_msg( dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, 0, __LINE__, DRAWSTATE_INVALID_STORAGE_BUFFER_OFFSET, "DS", @@ -6753,19 +6751,19 @@ CmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelin } } } else { - skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, (uint64_t)pDescriptorSets[i], __LINE__, - DRAWSTATE_INVALID_SET, "DS", "Attempt to bind DS 0x%" PRIxLEAST64 " that doesn't exist!", - (uint64_t)pDescriptorSets[i]); + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, (uint64_t)pDescriptorSets[i], __LINE__, + DRAWSTATE_INVALID_SET, "DS", "Attempt to bind DS 0x%" PRIxLEAST64 " that doesn't exist!", + (uint64_t)pDescriptorSets[i]); } - skipCall |= addCmd(dev_data, pCB, CMD_BINDDESCRIPTORSETS, "vkCmdBindDescriptorSets()"); + skip_call |= addCmd(dev_data, pCB, CMD_BINDDESCRIPTORSETS, "vkCmdBindDescriptorSets()"); // For any previously bound sets, need to set them to "invalid" if they were disturbed by this update if (firstSet > 0) { // Check set #s below the first bound set for (uint32_t i = 0; i < firstSet; ++i) { if (pCB->lastBound[pipelineBindPoint].boundDescriptorSets[i] && !verify_set_layout_compatibility(dev_data, pCB->lastBound[pipelineBindPoint].boundDescriptorSets[i], layout, i, errorString)) { - skipCall |= log_msg( + skip_call |= log_msg( dev_data->report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, (uint64_t)pCB->lastBound[pipelineBindPoint].boundDescriptorSets[i], __LINE__, DRAWSTATE_NONE, "DS", @@ -6781,7 +6779,7 @@ CmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelin if (oldFinalBoundSet && !verify_set_layout_compatibility(dev_data, oldFinalBoundSet, layout, lastSetIndex, errorString)) { auto old_set = oldFinalBoundSet->GetSet(); - skipCall |= + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, reinterpret_cast<uint64_t &>(old_set), __LINE__, DRAWSTATE_NONE, "DS", "DescriptorSetDS 0x%" PRIxLEAST64 @@ -6797,36 +6795,36 @@ CmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelin } // dynamicOffsetCount must equal the total number of dynamic descriptors in the sets being bound if (totalDynamicDescriptors != dynamicOffsetCount) { - skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, (uint64_t)commandBuffer, __LINE__, - DRAWSTATE_INVALID_DYNAMIC_OFFSET_COUNT, "DS", - "Attempting to bind %u descriptorSets with %u dynamic descriptors, but dynamicOffsetCount " - "is %u. It should exactly match the number of dynamic descriptors.", - setCount, totalDynamicDescriptors, dynamicOffsetCount); + skip_call |= + log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, + (uint64_t)commandBuffer, __LINE__, DRAWSTATE_INVALID_DYNAMIC_OFFSET_COUNT, "DS", + "Attempting to bind %u descriptorSets with %u dynamic descriptors, but dynamicOffsetCount " + "is %u. It should exactly match the number of dynamic descriptors.", + setCount, totalDynamicDescriptors, dynamicOffsetCount); } } else { - skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdBindDescriptorSets()"); + skip_call |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdBindDescriptorSets()"); } } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); } VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); // TODO : Somewhere need to verify that IBs have correct usage state flagged std::unique_lock<std::mutex> lock(global_lock); VkDeviceMemory mem; - skipCall = getBufferMemory(dev_data, buffer, &mem); + skip_call = getBufferMemory(dev_data, buffer, &mem); auto cb_node = getCBNode(dev_data, commandBuffer); if (cb_node) { std::function<bool()> function = [=]() { return validate_memory_is_valid(dev_data, mem, "vkCmdBindIndexBuffer()"); }; cb_node->validate_functions.push_back(function); - skipCall |= addCmd(dev_data, cb_node, CMD_BINDINDEXBUFFER, "vkCmdBindIndexBuffer()"); + skip_call |= addCmd(dev_data, cb_node, CMD_BINDINDEXBUFFER, "vkCmdBindIndexBuffer()"); VkDeviceSize offset_align = 0; switch (indexType) { case VK_INDEX_TYPE_UINT16: @@ -6840,15 +6838,15 @@ CmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize break; } if (!offset_align || (offset % offset_align)) { - skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, - DRAWSTATE_VTX_INDEX_ALIGNMENT_ERROR, "DS", - "vkCmdBindIndexBuffer() offset (0x%" PRIxLEAST64 ") does not fall on alignment (%s) boundary.", - offset, string_VkIndexType(indexType)); + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, + DRAWSTATE_VTX_INDEX_ALIGNMENT_ERROR, "DS", + "vkCmdBindIndexBuffer() offset (0x%" PRIxLEAST64 ") does not fall on alignment (%s) boundary.", + offset, string_VkIndexType(indexType)); } cb_node->status |= CBSTATUS_INDEX_BUFFER_BOUND; } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType); } @@ -6867,7 +6865,7 @@ static inline void updateResourceTrackingOnDraw(GLOBAL_CB_NODE *pCB) { pCB->draw VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); // TODO : Somewhere need to verify that VBs have correct usage state flagged std::unique_lock<std::mutex> lock(global_lock); @@ -6875,7 +6873,7 @@ VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers(VkCommandBuffer commandBuffer, u if (cb_node) { for (uint32_t i = 0; i < bindingCount; ++i) { VkDeviceMemory mem; - skipCall |= getBufferMemory(dev_data, pBuffers[i], &mem); + skip_call |= getBufferMemory(dev_data, pBuffers[i], &mem); std::function<bool()> function = [=]() { return validate_memory_is_valid(dev_data, mem, "vkCmdBindVertexBuffers()"); }; cb_node->validate_functions.push_back(function); @@ -6883,10 +6881,10 @@ VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers(VkCommandBuffer commandBuffer, u addCmd(dev_data, cb_node, CMD_BINDVERTEXBUFFER, "vkCmdBindVertexBuffer()"); updateResourceTracking(cb_node, firstBinding, bindingCount, pBuffers); } else { - skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdBindVertexBuffer()"); + skip_call |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdBindVertexBuffer()"); } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->CmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets); } @@ -6921,27 +6919,27 @@ static bool markStoreImagesAndBuffersAsWritten(layer_data *dev_data, GLOBAL_CB_N VKAPI_ATTR void VKAPI_CALL CmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { - skipCall |= addCmd(dev_data, pCB, CMD_DRAW, "vkCmdDraw()"); + skip_call |= addCmd(dev_data, pCB, CMD_DRAW, "vkCmdDraw()"); pCB->drawCount[DRAW]++; - skipCall |= validate_and_update_draw_state(dev_data, pCB, false, VK_PIPELINE_BIND_POINT_GRAPHICS); - skipCall |= markStoreImagesAndBuffersAsWritten(dev_data, pCB); + skip_call |= validate_and_update_draw_state(dev_data, pCB, false, VK_PIPELINE_BIND_POINT_GRAPHICS); + skip_call |= markStoreImagesAndBuffersAsWritten(dev_data, pCB); // TODO : Need to pass commandBuffer as srcObj here - skipCall |= + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0, __LINE__, DRAWSTATE_NONE, "DS", "vkCmdDraw() call 0x%" PRIx64 ", reporting DS state:", g_drawCount[DRAW]++); - skipCall |= synchAndPrintDSConfig(dev_data, commandBuffer); - if (!skipCall) { + skip_call |= synchAndPrintDSConfig(dev_data, commandBuffer); + if (!skip_call) { updateResourceTrackingOnDraw(pCB); } - skipCall |= outsideRenderPass(dev_data, pCB, "vkCmdDraw"); + skip_call |= outsideRenderPass(dev_data, pCB, "vkCmdDraw"); } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance); } @@ -6949,26 +6947,26 @@ VKAPI_ATTR void VKAPI_CALL CmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_ uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) { layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); - bool skipCall = false; + bool skip_call = false; std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { - skipCall |= addCmd(dev_data, pCB, CMD_DRAWINDEXED, "vkCmdDrawIndexed()"); + skip_call |= addCmd(dev_data, pCB, CMD_DRAWINDEXED, "vkCmdDrawIndexed()"); pCB->drawCount[DRAW_INDEXED]++; - skipCall |= validate_and_update_draw_state(dev_data, pCB, true, VK_PIPELINE_BIND_POINT_GRAPHICS); - skipCall |= markStoreImagesAndBuffersAsWritten(dev_data, pCB); + skip_call |= validate_and_update_draw_state(dev_data, pCB, true, VK_PIPELINE_BIND_POINT_GRAPHICS); + skip_call |= markStoreImagesAndBuffersAsWritten(dev_data, pCB); // TODO : Need to pass commandBuffer as srcObj here - skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0, __LINE__, DRAWSTATE_NONE, "DS", - "vkCmdDrawIndexed() call 0x%" PRIx64 ", reporting DS state:", g_drawCount[DRAW_INDEXED]++); - skipCall |= synchAndPrintDSConfig(dev_data, commandBuffer); - if (!skipCall) { + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0, __LINE__, DRAWSTATE_NONE, "DS", + "vkCmdDrawIndexed() call 0x%" PRIx64 ", reporting DS state:", g_drawCount[DRAW_INDEXED]++); + skip_call |= synchAndPrintDSConfig(dev_data, commandBuffer); + if (!skip_call) { updateResourceTrackingOnDraw(pCB); } - skipCall |= outsideRenderPass(dev_data, pCB, "vkCmdDrawIndexed"); + skip_call |= outsideRenderPass(dev_data, pCB, "vkCmdDrawIndexed"); } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); } @@ -6976,116 +6974,116 @@ VKAPI_ATTR void VKAPI_CALL CmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_ VKAPI_ATTR void VKAPI_CALL CmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) { layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); - bool skipCall = false; + bool skip_call = false; std::unique_lock<std::mutex> lock(global_lock); VkDeviceMemory mem; // MTMTODO : merge with code below - skipCall = getBufferMemory(dev_data, buffer, &mem); - skipCall |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, mem, "vkCmdDrawIndirect"); + skip_call = getBufferMemory(dev_data, buffer, &mem); + skip_call |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, mem, "vkCmdDrawIndirect"); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { - skipCall |= addCmd(dev_data, pCB, CMD_DRAWINDIRECT, "vkCmdDrawIndirect()"); + skip_call |= addCmd(dev_data, pCB, CMD_DRAWINDIRECT, "vkCmdDrawIndirect()"); pCB->drawCount[DRAW_INDIRECT]++; - skipCall |= validate_and_update_draw_state(dev_data, pCB, false, VK_PIPELINE_BIND_POINT_GRAPHICS); - skipCall |= markStoreImagesAndBuffersAsWritten(dev_data, pCB); + skip_call |= validate_and_update_draw_state(dev_data, pCB, false, VK_PIPELINE_BIND_POINT_GRAPHICS); + skip_call |= markStoreImagesAndBuffersAsWritten(dev_data, pCB); // TODO : Need to pass commandBuffer as srcObj here - skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0, __LINE__, DRAWSTATE_NONE, "DS", - "vkCmdDrawIndirect() call 0x%" PRIx64 ", reporting DS state:", g_drawCount[DRAW_INDIRECT]++); - skipCall |= synchAndPrintDSConfig(dev_data, commandBuffer); - if (!skipCall) { + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0, __LINE__, DRAWSTATE_NONE, "DS", + "vkCmdDrawIndirect() call 0x%" PRIx64 ", reporting DS state:", g_drawCount[DRAW_INDIRECT]++); + skip_call |= synchAndPrintDSConfig(dev_data, commandBuffer); + if (!skip_call) { updateResourceTrackingOnDraw(pCB); } - skipCall |= outsideRenderPass(dev_data, pCB, "vkCmdDrawIndirect"); + skip_call |= outsideRenderPass(dev_data, pCB, "vkCmdDrawIndirect"); } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->CmdDrawIndirect(commandBuffer, buffer, offset, count, stride); } VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); VkDeviceMemory mem; // MTMTODO : merge with code below - skipCall = getBufferMemory(dev_data, buffer, &mem); - skipCall |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, mem, "vkCmdDrawIndexedIndirect"); + skip_call = getBufferMemory(dev_data, buffer, &mem); + skip_call |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, mem, "vkCmdDrawIndexedIndirect"); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { - skipCall |= addCmd(dev_data, pCB, CMD_DRAWINDEXEDINDIRECT, "vkCmdDrawIndexedIndirect()"); + skip_call |= addCmd(dev_data, pCB, CMD_DRAWINDEXEDINDIRECT, "vkCmdDrawIndexedIndirect()"); pCB->drawCount[DRAW_INDEXED_INDIRECT]++; - skipCall |= validate_and_update_draw_state(dev_data, pCB, true, VK_PIPELINE_BIND_POINT_GRAPHICS); - skipCall |= markStoreImagesAndBuffersAsWritten(dev_data, pCB); + skip_call |= validate_and_update_draw_state(dev_data, pCB, true, VK_PIPELINE_BIND_POINT_GRAPHICS); + skip_call |= markStoreImagesAndBuffersAsWritten(dev_data, pCB); // TODO : Need to pass commandBuffer as srcObj here - skipCall |= + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0, __LINE__, DRAWSTATE_NONE, "DS", "vkCmdDrawIndexedIndirect() call 0x%" PRIx64 ", reporting DS state:", g_drawCount[DRAW_INDEXED_INDIRECT]++); - skipCall |= synchAndPrintDSConfig(dev_data, commandBuffer); - if (!skipCall) { + skip_call |= synchAndPrintDSConfig(dev_data, commandBuffer); + if (!skip_call) { updateResourceTrackingOnDraw(pCB); } - skipCall |= outsideRenderPass(dev_data, pCB, "vkCmdDrawIndexedIndirect"); + skip_call |= outsideRenderPass(dev_data, pCB, "vkCmdDrawIndexedIndirect"); } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->CmdDrawIndexedIndirect(commandBuffer, buffer, offset, count, stride); } VKAPI_ATTR void VKAPI_CALL CmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { - skipCall |= validate_and_update_draw_state(dev_data, pCB, false, VK_PIPELINE_BIND_POINT_COMPUTE); - skipCall |= markStoreImagesAndBuffersAsWritten(dev_data, pCB); - skipCall |= addCmd(dev_data, pCB, CMD_DISPATCH, "vkCmdDispatch()"); - skipCall |= insideRenderPass(dev_data, pCB, "vkCmdDispatch"); + skip_call |= validate_and_update_draw_state(dev_data, pCB, false, VK_PIPELINE_BIND_POINT_COMPUTE); + skip_call |= markStoreImagesAndBuffersAsWritten(dev_data, pCB); + skip_call |= addCmd(dev_data, pCB, CMD_DISPATCH, "vkCmdDispatch()"); + skip_call |= insideRenderPass(dev_data, pCB, "vkCmdDispatch"); } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->CmdDispatch(commandBuffer, x, y, z); } VKAPI_ATTR void VKAPI_CALL CmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); VkDeviceMemory mem; - skipCall = getBufferMemory(dev_data, buffer, &mem); - skipCall |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, mem, "vkCmdDispatchIndirect"); + skip_call = getBufferMemory(dev_data, buffer, &mem); + skip_call |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, mem, "vkCmdDispatchIndirect"); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { - skipCall |= validate_and_update_draw_state(dev_data, pCB, false, VK_PIPELINE_BIND_POINT_COMPUTE); - skipCall |= markStoreImagesAndBuffersAsWritten(dev_data, pCB); - skipCall |= addCmd(dev_data, pCB, CMD_DISPATCHINDIRECT, "vkCmdDispatchIndirect()"); - skipCall |= insideRenderPass(dev_data, pCB, "vkCmdDispatchIndirect"); + skip_call |= validate_and_update_draw_state(dev_data, pCB, false, VK_PIPELINE_BIND_POINT_COMPUTE); + skip_call |= markStoreImagesAndBuffersAsWritten(dev_data, pCB); + skip_call |= addCmd(dev_data, pCB, CMD_DISPATCHINDIRECT, "vkCmdDispatchIndirect()"); + skip_call |= insideRenderPass(dev_data, pCB, "vkCmdDispatchIndirect"); } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->CmdDispatchIndirect(commandBuffer, buffer, offset); } VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy *pRegions) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); VkDeviceMemory src_mem, dst_mem; - skipCall = getBufferMemory(dev_data, srcBuffer, &src_mem); - skipCall |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, src_mem, "vkCmdCopyBuffer"); - skipCall |= getBufferMemory(dev_data, dstBuffer, &dst_mem); + skip_call = getBufferMemory(dev_data, srcBuffer, &src_mem); + skip_call |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, src_mem, "vkCmdCopyBuffer"); + skip_call |= getBufferMemory(dev_data, dstBuffer, &dst_mem); - skipCall |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, dst_mem, "vkCmdCopyBuffer"); + skip_call |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, dst_mem, "vkCmdCopyBuffer"); // Validate that SRC & DST buffers have correct usage flags set - skipCall |= validate_buffer_usage_flags(dev_data, srcBuffer, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, true, - "vkCmdCopyBuffer()", "VK_BUFFER_USAGE_TRANSFER_SRC_BIT"); - skipCall |= validate_buffer_usage_flags(dev_data, dstBuffer, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true, - "vkCmdCopyBuffer()", "VK_BUFFER_USAGE_TRANSFER_DST_BIT"); + skip_call |= validate_buffer_usage_flags(dev_data, srcBuffer, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, true, "vkCmdCopyBuffer()", + "VK_BUFFER_USAGE_TRANSFER_SRC_BIT"); + skip_call |= validate_buffer_usage_flags(dev_data, dstBuffer, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true, "vkCmdCopyBuffer()", + "VK_BUFFER_USAGE_TRANSFER_DST_BIT"); auto cb_node = getCBNode(dev_data, commandBuffer); if (cb_node) { std::function<bool()> function = [=]() { return validate_memory_is_valid(dev_data, src_mem, "vkCmdCopyBuffer()"); }; @@ -7096,11 +7094,11 @@ VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer }; cb_node->validate_functions.push_back(function); - skipCall |= addCmd(dev_data, cb_node, CMD_COPYBUFFER, "vkCmdCopyBuffer()"); - skipCall |= insideRenderPass(dev_data, cb_node, "vkCmdCopyBuffer"); + skip_call |= addCmd(dev_data, cb_node, CMD_COPYBUFFER, "vkCmdCopyBuffer()"); + skip_call |= insideRenderPass(dev_data, cb_node, "vkCmdCopyBuffer"); } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); } @@ -7184,20 +7182,20 @@ static bool VerifyDestImageLayout(VkCommandBuffer cmdBuffer, VkImage destImage, VKAPI_ATTR void VKAPI_CALL CmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy *pRegions) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); VkDeviceMemory src_mem, dst_mem; // Validate that src & dst images have correct usage flags set - skipCall = getImageMemory(dev_data, srcImage, &src_mem); - skipCall |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, src_mem, "vkCmdCopyImage"); - - skipCall |= getImageMemory(dev_data, dstImage, &dst_mem); - skipCall |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, dst_mem, "vkCmdCopyImage"); - skipCall |= validate_image_usage_flags(dev_data, srcImage, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, true, - "vkCmdCopyImage()", "VK_IMAGE_USAGE_TRANSFER_SRC_BIT"); - skipCall |= validate_image_usage_flags(dev_data, dstImage, VK_IMAGE_USAGE_TRANSFER_DST_BIT, true, - "vkCmdCopyImage()", "VK_IMAGE_USAGE_TRANSFER_DST_BIT"); + skip_call = getImageMemory(dev_data, srcImage, &src_mem); + skip_call |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, src_mem, "vkCmdCopyImage"); + + skip_call |= getImageMemory(dev_data, dstImage, &dst_mem); + skip_call |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, dst_mem, "vkCmdCopyImage"); + skip_call |= validate_image_usage_flags(dev_data, srcImage, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, true, "vkCmdCopyImage()", + "VK_IMAGE_USAGE_TRANSFER_SRC_BIT"); + skip_call |= validate_image_usage_flags(dev_data, dstImage, VK_IMAGE_USAGE_TRANSFER_DST_BIT, true, "vkCmdCopyImage()", + "VK_IMAGE_USAGE_TRANSFER_DST_BIT"); auto cb_node = getCBNode(dev_data, commandBuffer); if (cb_node) { std::function<bool()> function = [=]() { @@ -7210,15 +7208,15 @@ CmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcI }; cb_node->validate_functions.push_back(function); - skipCall |= addCmd(dev_data, cb_node, CMD_COPYIMAGE, "vkCmdCopyImage()"); - skipCall |= insideRenderPass(dev_data, cb_node, "vkCmdCopyImage"); + skip_call |= addCmd(dev_data, cb_node, CMD_COPYIMAGE, "vkCmdCopyImage()"); + skip_call |= insideRenderPass(dev_data, cb_node, "vkCmdCopyImage"); for (uint32_t i = 0; i < regionCount; ++i) { - skipCall |= VerifySourceImageLayout(commandBuffer, srcImage, pRegions[i].srcSubresource, srcImageLayout); - skipCall |= VerifyDestImageLayout(commandBuffer, dstImage, pRegions[i].dstSubresource, dstImageLayout); + skip_call |= VerifySourceImageLayout(commandBuffer, srcImage, pRegions[i].srcSubresource, srcImageLayout); + skip_call |= VerifyDestImageLayout(commandBuffer, dstImage, pRegions[i].dstSubresource, dstImageLayout); } } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); } @@ -7226,20 +7224,20 @@ CmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcI VKAPI_ATTR void VKAPI_CALL CmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit *pRegions, VkFilter filter) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); VkDeviceMemory src_mem, dst_mem; // Validate that src & dst images have correct usage flags set - skipCall = getImageMemory(dev_data, srcImage, &src_mem); - skipCall |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, src_mem, "vkCmdBlitImage"); + skip_call = getImageMemory(dev_data, srcImage, &src_mem); + skip_call |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, src_mem, "vkCmdBlitImage"); - skipCall |= getImageMemory(dev_data, dstImage, &dst_mem); - skipCall |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, dst_mem, "vkCmdBlitImage"); - skipCall |= validate_image_usage_flags(dev_data, srcImage, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, true, - "vkCmdBlitImage()", "VK_IMAGE_USAGE_TRANSFER_SRC_BIT"); - skipCall |= validate_image_usage_flags(dev_data, dstImage, VK_IMAGE_USAGE_TRANSFER_DST_BIT, true, - "vkCmdBlitImage()", "VK_IMAGE_USAGE_TRANSFER_DST_BIT"); + skip_call |= getImageMemory(dev_data, dstImage, &dst_mem); + skip_call |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, dst_mem, "vkCmdBlitImage"); + skip_call |= validate_image_usage_flags(dev_data, srcImage, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, true, "vkCmdBlitImage()", + "VK_IMAGE_USAGE_TRANSFER_SRC_BIT"); + skip_call |= validate_image_usage_flags(dev_data, dstImage, VK_IMAGE_USAGE_TRANSFER_DST_BIT, true, "vkCmdBlitImage()", + "VK_IMAGE_USAGE_TRANSFER_DST_BIT"); auto cb_node = getCBNode(dev_data, commandBuffer); if (cb_node) { @@ -7253,11 +7251,11 @@ CmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcI }; cb_node->validate_functions.push_back(function); - skipCall |= addCmd(dev_data, cb_node, CMD_BLITIMAGE, "vkCmdBlitImage()"); - skipCall |= insideRenderPass(dev_data, cb_node, "vkCmdBlitImage"); + skip_call |= addCmd(dev_data, cb_node, CMD_BLITIMAGE, "vkCmdBlitImage()"); + skip_call |= insideRenderPass(dev_data, cb_node, "vkCmdBlitImage"); } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter); } @@ -7265,20 +7263,20 @@ CmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcI VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy *pRegions) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); VkDeviceMemory dst_mem, src_mem; - skipCall = getImageMemory(dev_data, dstImage, &dst_mem); - skipCall |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, dst_mem, "vkCmdCopyBufferToImage"); + skip_call = getImageMemory(dev_data, dstImage, &dst_mem); + skip_call |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, dst_mem, "vkCmdCopyBufferToImage"); - skipCall |= getBufferMemory(dev_data, srcBuffer, &src_mem); - skipCall |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, src_mem, "vkCmdCopyBufferToImage"); + skip_call |= getBufferMemory(dev_data, srcBuffer, &src_mem); + skip_call |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, src_mem, "vkCmdCopyBufferToImage"); // Validate that src buff & dst image have correct usage flags set - skipCall |= validate_buffer_usage_flags(dev_data, srcBuffer, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, true, "vkCmdCopyBufferToImage()", - "VK_BUFFER_USAGE_TRANSFER_SRC_BIT"); - skipCall |= validate_image_usage_flags(dev_data, dstImage, VK_IMAGE_USAGE_TRANSFER_DST_BIT, true, "vkCmdCopyBufferToImage()", - "VK_IMAGE_USAGE_TRANSFER_DST_BIT"); + skip_call |= validate_buffer_usage_flags(dev_data, srcBuffer, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, true, + "vkCmdCopyBufferToImage()", "VK_BUFFER_USAGE_TRANSFER_SRC_BIT"); + skip_call |= validate_image_usage_flags(dev_data, dstImage, VK_IMAGE_USAGE_TRANSFER_DST_BIT, true, "vkCmdCopyBufferToImage()", + "VK_IMAGE_USAGE_TRANSFER_DST_BIT"); auto cb_node = getCBNode(dev_data, commandBuffer); if (cb_node) { std::function<bool()> function = [=]() { @@ -7289,14 +7287,14 @@ VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage(VkCommandBuffer commandBuffer, V function = [=]() { return validate_memory_is_valid(dev_data, src_mem, "vkCmdCopyBufferToImage()"); }; cb_node->validate_functions.push_back(function); - skipCall |= addCmd(dev_data, cb_node, CMD_COPYBUFFERTOIMAGE, "vkCmdCopyBufferToImage()"); - skipCall |= insideRenderPass(dev_data, cb_node, "vkCmdCopyBufferToImage"); + skip_call |= addCmd(dev_data, cb_node, CMD_COPYBUFFERTOIMAGE, "vkCmdCopyBufferToImage()"); + skip_call |= insideRenderPass(dev_data, cb_node, "vkCmdCopyBufferToImage"); for (uint32_t i = 0; i < regionCount; ++i) { - skipCall |= VerifyDestImageLayout(commandBuffer, dstImage, pRegions[i].imageSubresource, dstImageLayout); + skip_call |= VerifyDestImageLayout(commandBuffer, dstImage, pRegions[i].imageSubresource, dstImageLayout); } } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions); } @@ -7304,20 +7302,20 @@ VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage(VkCommandBuffer commandBuffer, V VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); VkDeviceMemory src_mem, dst_mem; - skipCall = getImageMemory(dev_data, srcImage, &src_mem); - skipCall |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, src_mem, "vkCmdCopyImageToBuffer"); + skip_call = getImageMemory(dev_data, srcImage, &src_mem); + skip_call |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, src_mem, "vkCmdCopyImageToBuffer"); - skipCall |= getBufferMemory(dev_data, dstBuffer, &dst_mem); - skipCall |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, dst_mem, "vkCmdCopyImageToBuffer"); + skip_call |= getBufferMemory(dev_data, dstBuffer, &dst_mem); + skip_call |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, dst_mem, "vkCmdCopyImageToBuffer"); // Validate that dst buff & src image have correct usage flags set - skipCall |= validate_image_usage_flags(dev_data, srcImage, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, true, "vkCmdCopyImageToBuffer()", - "VK_IMAGE_USAGE_TRANSFER_SRC_BIT"); - skipCall |= validate_buffer_usage_flags(dev_data, dstBuffer, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true, "vkCmdCopyImageToBuffer()", - "VK_BUFFER_USAGE_TRANSFER_DST_BIT"); + skip_call |= validate_image_usage_flags(dev_data, srcImage, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, true, "vkCmdCopyImageToBuffer()", + "VK_IMAGE_USAGE_TRANSFER_SRC_BIT"); + skip_call |= validate_buffer_usage_flags(dev_data, dstBuffer, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true, + "vkCmdCopyImageToBuffer()", "VK_BUFFER_USAGE_TRANSFER_DST_BIT"); auto cb_node = getCBNode(dev_data, commandBuffer); if (cb_node) { @@ -7331,29 +7329,29 @@ VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer(VkCommandBuffer commandBuffer, V }; cb_node->validate_functions.push_back(function); - skipCall |= addCmd(dev_data, cb_node, CMD_COPYIMAGETOBUFFER, "vkCmdCopyImageToBuffer()"); - skipCall |= insideRenderPass(dev_data, cb_node, "vkCmdCopyImageToBuffer"); + skip_call |= addCmd(dev_data, cb_node, CMD_COPYIMAGETOBUFFER, "vkCmdCopyImageToBuffer()"); + skip_call |= insideRenderPass(dev_data, cb_node, "vkCmdCopyImageToBuffer"); for (uint32_t i = 0; i < regionCount; ++i) { - skipCall |= VerifySourceImageLayout(commandBuffer, srcImage, pRegions[i].imageSubresource, srcImageLayout); + skip_call |= VerifySourceImageLayout(commandBuffer, srcImage, pRegions[i].imageSubresource, srcImageLayout); } } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions); } VKAPI_ATTR void VKAPI_CALL CmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t *pData) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); VkDeviceMemory mem; - skipCall = getBufferMemory(dev_data, dstBuffer, &mem); - skipCall |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, mem, "vkCmdUpdateBuffer"); + skip_call = getBufferMemory(dev_data, dstBuffer, &mem); + skip_call |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, mem, "vkCmdUpdateBuffer"); // Validate that dst buff has correct usage flags set - skipCall |= validate_buffer_usage_flags(dev_data, dstBuffer, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true, "vkCmdUpdateBuffer()", - "VK_BUFFER_USAGE_TRANSFER_DST_BIT"); + skip_call |= validate_buffer_usage_flags(dev_data, dstBuffer, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true, "vkCmdUpdateBuffer()", + "VK_BUFFER_USAGE_TRANSFER_DST_BIT"); auto cb_node = getCBNode(dev_data, commandBuffer); if (cb_node) { @@ -7363,25 +7361,25 @@ VKAPI_ATTR void VKAPI_CALL CmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuff }; cb_node->validate_functions.push_back(function); - skipCall |= addCmd(dev_data, cb_node, CMD_UPDATEBUFFER, "vkCmdUpdateBuffer()"); - skipCall |= insideRenderPass(dev_data, cb_node, "vkCmdCopyUpdateBuffer"); + skip_call |= addCmd(dev_data, cb_node, CMD_UPDATEBUFFER, "vkCmdUpdateBuffer()"); + skip_call |= insideRenderPass(dev_data, cb_node, "vkCmdCopyUpdateBuffer"); } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData); } VKAPI_ATTR void VKAPI_CALL CmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); VkDeviceMemory mem; - skipCall = getBufferMemory(dev_data, dstBuffer, &mem); - skipCall |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, mem, "vkCmdFillBuffer"); + skip_call = getBufferMemory(dev_data, dstBuffer, &mem); + skip_call |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, mem, "vkCmdFillBuffer"); // Validate that dst buff has correct usage flags set - skipCall |= validate_buffer_usage_flags(dev_data, dstBuffer, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true, "vkCmdFillBuffer()", - "VK_BUFFER_USAGE_TRANSFER_DST_BIT"); + skip_call |= validate_buffer_usage_flags(dev_data, dstBuffer, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true, "vkCmdFillBuffer()", + "VK_BUFFER_USAGE_TRANSFER_DST_BIT"); auto cb_node = getCBNode(dev_data, commandBuffer); if (cb_node) { @@ -7391,23 +7389,23 @@ CmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize ds }; cb_node->validate_functions.push_back(function); - skipCall |= addCmd(dev_data, cb_node, CMD_FILLBUFFER, "vkCmdFillBuffer()"); - skipCall |= insideRenderPass(dev_data, cb_node, "vkCmdCopyFillBuffer"); + skip_call |= addCmd(dev_data, cb_node, CMD_FILLBUFFER, "vkCmdFillBuffer()"); + skip_call |= insideRenderPass(dev_data, cb_node, "vkCmdCopyFillBuffer"); } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data); } VKAPI_ATTR void VKAPI_CALL CmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment *pAttachments, uint32_t rectCount, const VkClearRect *pRects) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { - skipCall |= addCmd(dev_data, pCB, CMD_CLEARATTACHMENTS, "vkCmdClearAttachments()"); + skip_call |= addCmd(dev_data, pCB, CMD_CLEARATTACHMENTS, "vkCmdClearAttachments()"); // Warn if this is issued prior to Draw Cmd and clearing the entire attachment if (!hasDrawCmd(pCB) && (pCB->activeRenderPassBeginInfo.renderArea.extent.width == pRects[0].rect.extent.width) && (pCB->activeRenderPassBeginInfo.renderArea.extent.height == pRects[0].rect.extent.height)) { @@ -7416,13 +7414,13 @@ VKAPI_ATTR void VKAPI_CALL CmdClearAttachments(VkCommandBuffer commandBuffer, ui // Can we make this warning more specific? I'd like to avoid triggering this test if we can tell it's a use that must // call CmdClearAttachments // Otherwise this seems more like a performance warning. - skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0, 0, DRAWSTATE_CLEAR_CMD_BEFORE_DRAW, "DS", - "vkCmdClearAttachments() issued on CB object 0x%" PRIxLEAST64 " prior to any Draw Cmds." - " It is recommended you use RenderPass LOAD_OP_CLEAR on Attachments prior to any Draw.", - (uint64_t)(commandBuffer)); + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0, 0, DRAWSTATE_CLEAR_CMD_BEFORE_DRAW, "DS", + "vkCmdClearAttachments() issued on CB object 0x%" PRIxLEAST64 " prior to any Draw Cmds." + " It is recommended you use RenderPass LOAD_OP_CLEAR on Attachments prior to any Draw.", + (uint64_t)(commandBuffer)); } - skipCall |= outsideRenderPass(dev_data, pCB, "vkCmdClearAttachments"); + skip_call |= outsideRenderPass(dev_data, pCB, "vkCmdClearAttachments"); } // Validate that attachment is in reference list of active subpass @@ -7441,7 +7439,7 @@ VKAPI_ATTR void VKAPI_CALL CmdClearAttachments(VkCommandBuffer commandBuffer, ui } } if (!found) { - skipCall |= log_msg( + skip_call |= log_msg( dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, (uint64_t)commandBuffer, __LINE__, DRAWSTATE_MISSING_ATTACHMENT_REFERENCE, "DS", "vkCmdClearAttachments() attachment index %d not found in attachment reference array of active subpass %d", @@ -7452,7 +7450,7 @@ VKAPI_ATTR void VKAPI_CALL CmdClearAttachments(VkCommandBuffer commandBuffer, ui (pSD->pDepthStencilAttachment->attachment == VK_ATTACHMENT_UNUSED)) { // Says no DS will be used in active subpass - skipCall |= log_msg( + skip_call |= log_msg( dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, (uint64_t)commandBuffer, __LINE__, DRAWSTATE_MISSING_ATTACHMENT_REFERENCE, "DS", "vkCmdClearAttachments() attachment index %d does not match depthStencilAttachment.attachment (%d) found " @@ -7465,20 +7463,20 @@ VKAPI_ATTR void VKAPI_CALL CmdClearAttachments(VkCommandBuffer commandBuffer, ui } } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects); } VKAPI_ATTR void VKAPI_CALL CmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue *pColor, uint32_t rangeCount, const VkImageSubresourceRange *pRanges) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); // TODO : Verify memory is in VK_IMAGE_STATE_CLEAR state VkDeviceMemory mem; - skipCall = getImageMemory(dev_data, image, &mem); - skipCall |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, mem, "vkCmdClearColorImage"); + skip_call = getImageMemory(dev_data, image, &mem); + skip_call |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, mem, "vkCmdClearColorImage"); auto cb_node = getCBNode(dev_data, commandBuffer); if (cb_node) { std::function<bool()> function = [=]() { @@ -7487,11 +7485,11 @@ VKAPI_ATTR void VKAPI_CALL CmdClearColorImage(VkCommandBuffer commandBuffer, VkI }; cb_node->validate_functions.push_back(function); - skipCall |= addCmd(dev_data, cb_node, CMD_CLEARCOLORIMAGE, "vkCmdClearColorImage()"); - skipCall |= insideRenderPass(dev_data, cb_node, "vkCmdClearColorImage"); + skip_call |= addCmd(dev_data, cb_node, CMD_CLEARCOLORIMAGE, "vkCmdClearColorImage()"); + skip_call |= insideRenderPass(dev_data, cb_node, "vkCmdClearColorImage"); } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges); } @@ -7499,13 +7497,13 @@ VKAPI_ATTR void VKAPI_CALL CmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange *pRanges) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); // TODO : Verify memory is in VK_IMAGE_STATE_CLEAR state VkDeviceMemory mem; - skipCall = getImageMemory(dev_data, image, &mem); - skipCall |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, mem, "vkCmdClearDepthStencilImage"); + skip_call = getImageMemory(dev_data, image, &mem); + skip_call |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, mem, "vkCmdClearDepthStencilImage"); auto cb_node = getCBNode(dev_data, commandBuffer); if (cb_node) { std::function<bool()> function = [=]() { @@ -7514,11 +7512,11 @@ CmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageL }; cb_node->validate_functions.push_back(function); - skipCall |= addCmd(dev_data, cb_node, CMD_CLEARDEPTHSTENCILIMAGE, "vkCmdClearDepthStencilImage()"); - skipCall |= insideRenderPass(dev_data, cb_node, "vkCmdClearDepthStencilImage"); + skip_call |= addCmd(dev_data, cb_node, CMD_CLEARDEPTHSTENCILIMAGE, "vkCmdClearDepthStencilImage()"); + skip_call |= insideRenderPass(dev_data, cb_node, "vkCmdClearDepthStencilImage"); } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges); } @@ -7526,15 +7524,15 @@ CmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageL VKAPI_ATTR void VKAPI_CALL CmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve *pRegions) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); VkDeviceMemory src_mem, dst_mem; - skipCall = getImageMemory(dev_data, srcImage, &src_mem); - skipCall |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, src_mem, "vkCmdResolveImage"); + skip_call = getImageMemory(dev_data, srcImage, &src_mem); + skip_call |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, src_mem, "vkCmdResolveImage"); - skipCall |= getImageMemory(dev_data, dstImage, &dst_mem); - skipCall |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, dst_mem, "vkCmdResolveImage"); + skip_call |= getImageMemory(dev_data, dstImage, &dst_mem); + skip_call |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, dst_mem, "vkCmdResolveImage"); auto cb_node = getCBNode(dev_data, commandBuffer); if (cb_node) { std::function<bool()> function = [=]() { @@ -7547,11 +7545,11 @@ CmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout s }; cb_node->validate_functions.push_back(function); - skipCall |= addCmd(dev_data, cb_node, CMD_RESOLVEIMAGE, "vkCmdResolveImage()"); - skipCall |= insideRenderPass(dev_data, cb_node, "vkCmdResolveImage"); + skip_call |= addCmd(dev_data, cb_node, CMD_RESOLVEIMAGE, "vkCmdResolveImage()"); + skip_call |= insideRenderPass(dev_data, cb_node, "vkCmdResolveImage"); } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); } @@ -7571,13 +7569,13 @@ bool setEventStageMask(VkQueue queue, VkCommandBuffer commandBuffer, VkEvent eve VKAPI_ATTR void VKAPI_CALL CmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { - skipCall |= addCmd(dev_data, pCB, CMD_SETEVENT, "vkCmdSetEvent()"); - skipCall |= insideRenderPass(dev_data, pCB, "vkCmdSetEvent"); + skip_call |= addCmd(dev_data, pCB, CMD_SETEVENT, "vkCmdSetEvent()"); + skip_call |= insideRenderPass(dev_data, pCB, "vkCmdSetEvent"); pCB->events.push_back(event); if (!pCB->waitedEvents.count(event)) { pCB->writeEventsBeforeWait.push_back(event); @@ -7587,19 +7585,19 @@ CmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags s pCB->eventUpdates.push_back(eventUpdate); } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->CmdSetEvent(commandBuffer, event, stageMask); } VKAPI_ATTR void VKAPI_CALL CmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { - skipCall |= addCmd(dev_data, pCB, CMD_RESETEVENT, "vkCmdResetEvent()"); - skipCall |= insideRenderPass(dev_data, pCB, "vkCmdResetEvent"); + skip_call |= addCmd(dev_data, pCB, CMD_RESETEVENT, "vkCmdResetEvent()"); + skip_call |= insideRenderPass(dev_data, pCB, "vkCmdResetEvent"); pCB->events.push_back(event); if (!pCB->waitedEvents.count(event)) { pCB->writeEventsBeforeWait.push_back(event); @@ -7609,7 +7607,7 @@ CmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags pCB->eventUpdates.push_back(eventUpdate); } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->CmdResetEvent(commandBuffer, event, stageMask); } @@ -7986,7 +7984,7 @@ CmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); @@ -8000,17 +7998,17 @@ CmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent std::bind(validateEventStageMask, std::placeholders::_1, pCB, eventCount, firstEventIndex, sourceStageMask); pCB->eventUpdates.push_back(eventUpdate); if (pCB->state == CB_RECORDING) { - skipCall |= addCmd(dev_data, pCB, CMD_WAITEVENTS, "vkCmdWaitEvents()"); + skip_call |= addCmd(dev_data, pCB, CMD_WAITEVENTS, "vkCmdWaitEvents()"); } else { - skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdWaitEvents()"); + skip_call |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdWaitEvents()"); } - skipCall |= TransitionImageLayouts(commandBuffer, imageMemoryBarrierCount, pImageMemoryBarriers); - skipCall |= + skip_call |= TransitionImageLayouts(commandBuffer, imageMemoryBarrierCount, pImageMemoryBarriers); + skip_call |= ValidateBarriers("vkCmdWaitEvents", commandBuffer, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->CmdWaitEvents(commandBuffer, eventCount, pEvents, sourceStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); @@ -8021,19 +8019,19 @@ CmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageM VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { - skipCall |= addCmd(dev_data, pCB, CMD_PIPELINEBARRIER, "vkCmdPipelineBarrier()"); - skipCall |= TransitionImageLayouts(commandBuffer, imageMemoryBarrierCount, pImageMemoryBarriers); - skipCall |= + skip_call |= addCmd(dev_data, pCB, CMD_PIPELINEBARRIER, "vkCmdPipelineBarrier()"); + skip_call |= TransitionImageLayouts(commandBuffer, imageMemoryBarrierCount, pImageMemoryBarriers); + skip_call |= ValidateBarriers("vkCmdPipelineBarrier", commandBuffer, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); @@ -8054,7 +8052,7 @@ bool setQueryState(VkQueue queue, VkCommandBuffer commandBuffer, QueryObject obj VKAPI_ATTR void VKAPI_CALL CmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); @@ -8064,22 +8062,22 @@ CmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slo if (!pCB->startedQueries.count(query)) { pCB->startedQueries.insert(query); } - skipCall |= addCmd(dev_data, pCB, CMD_BEGINQUERY, "vkCmdBeginQuery()"); + skip_call |= addCmd(dev_data, pCB, CMD_BEGINQUERY, "vkCmdBeginQuery()"); } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->CmdBeginQuery(commandBuffer, queryPool, slot, flags); } VKAPI_ATTR void VKAPI_CALL CmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { QueryObject query = {queryPool, slot}; if (!pCB->activeQueries.count(query)) { - skipCall |= + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, DRAWSTATE_INVALID_QUERY, "DS", "Ending a query before it was started: queryPool 0x%" PRIx64 ", index %d", (uint64_t)(queryPool), slot); @@ -8089,19 +8087,19 @@ VKAPI_ATTR void VKAPI_CALL CmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPoo std::function<bool(VkQueue)> queryUpdate = std::bind(setQueryState, std::placeholders::_1, commandBuffer, query, true); pCB->queryUpdates.push_back(queryUpdate); if (pCB->state == CB_RECORDING) { - skipCall |= addCmd(dev_data, pCB, CMD_ENDQUERY, "VkCmdEndQuery()"); + skip_call |= addCmd(dev_data, pCB, CMD_ENDQUERY, "VkCmdEndQuery()"); } else { - skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdEndQuery()"); + skip_call |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdEndQuery()"); } } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->CmdEndQuery(commandBuffer, queryPool, slot); } VKAPI_ATTR void VKAPI_CALL CmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); @@ -8113,14 +8111,14 @@ CmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t pCB->queryUpdates.push_back(queryUpdate); } if (pCB->state == CB_RECORDING) { - skipCall |= addCmd(dev_data, pCB, CMD_RESETQUERYPOOL, "VkCmdResetQueryPool()"); + skip_call |= addCmd(dev_data, pCB, CMD_RESETQUERYPOOL, "VkCmdResetQueryPool()"); } else { - skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdResetQueryPool()"); + skip_call |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdResetQueryPool()"); } - skipCall |= insideRenderPass(dev_data, pCB, "vkCmdQueryPool"); + skip_call |= insideRenderPass(dev_data, pCB, "vkCmdQueryPool"); } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->CmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount); } @@ -8161,14 +8159,14 @@ bool validateQuery(VkQueue queue, GLOBAL_CB_NODE *pCB, VkQueryPool queryPool, ui VKAPI_ATTR void VKAPI_CALL CmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); #if MTMERGESOURCE VkDeviceMemory mem; auto cb_node = getCBNode(dev_data, commandBuffer); - skipCall |= getBufferMemory(dev_data, dstBuffer, &mem); + skip_call |= getBufferMemory(dev_data, dstBuffer, &mem); if (cb_node) { std::function<bool()> function = [=]() { set_memory_valid(dev_data, mem, true); @@ -8176,24 +8174,24 @@ CmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, ui }; cb_node->validate_functions.push_back(function); } - skipCall |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, mem, "vkCmdCopyQueryPoolResults"); + skip_call |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, mem, "vkCmdCopyQueryPoolResults"); // Validate that DST buffer has correct usage flags set - skipCall |= validate_buffer_usage_flags(dev_data, dstBuffer, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true, - "vkCmdCopyQueryPoolResults()", "VK_BUFFER_USAGE_TRANSFER_DST_BIT"); + skip_call |= validate_buffer_usage_flags(dev_data, dstBuffer, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true, + "vkCmdCopyQueryPoolResults()", "VK_BUFFER_USAGE_TRANSFER_DST_BIT"); #endif if (pCB) { std::function<bool(VkQueue)> queryUpdate = std::bind(validateQuery, std::placeholders::_1, pCB, queryPool, queryCount, firstQuery); pCB->queryUpdates.push_back(queryUpdate); if (pCB->state == CB_RECORDING) { - skipCall |= addCmd(dev_data, pCB, CMD_COPYQUERYPOOLRESULTS, "vkCmdCopyQueryPoolResults()"); + skip_call |= addCmd(dev_data, pCB, CMD_COPYQUERYPOOLRESULTS, "vkCmdCopyQueryPoolResults()"); } else { - skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdCopyQueryPoolResults()"); + skip_call |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdCopyQueryPoolResults()"); } - skipCall |= insideRenderPass(dev_data, pCB, "vkCmdCopyQueryPoolResults"); + skip_call |= insideRenderPass(dev_data, pCB, "vkCmdCopyQueryPoolResults"); } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->CmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags); } @@ -8201,29 +8199,29 @@ CmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, ui VKAPI_ATTR void VKAPI_CALL CmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void *pValues) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { if (pCB->state == CB_RECORDING) { - skipCall |= addCmd(dev_data, pCB, CMD_PUSHCONSTANTS, "vkCmdPushConstants()"); + skip_call |= addCmd(dev_data, pCB, CMD_PUSHCONSTANTS, "vkCmdPushConstants()"); } else { - skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdPushConstants()"); + skip_call |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdPushConstants()"); } } - skipCall |= validatePushConstantRange(dev_data, offset, size, "vkCmdPushConstants()"); + skip_call |= validatePushConstantRange(dev_data, offset, size, "vkCmdPushConstants()"); if (0 == stageFlags) { - skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, - DRAWSTATE_PUSH_CONSTANTS_ERROR, "DS", "vkCmdPushConstants() call has no stageFlags set."); + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, + DRAWSTATE_PUSH_CONSTANTS_ERROR, "DS", "vkCmdPushConstants() call has no stageFlags set."); } // Check if push constant update is within any of the ranges with the same stage flags specified in pipeline layout. auto pipeline_layout = getPipelineLayout(dev_data, layout); if (!pipeline_layout) { - skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, - DRAWSTATE_PUSH_CONSTANTS_ERROR, "DS", "vkCmdPushConstants() Pipeline Layout 0x%" PRIx64 " not found.", - (uint64_t)layout); + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, + DRAWSTATE_PUSH_CONSTANTS_ERROR, "DS", "vkCmdPushConstants() Pipeline Layout 0x%" PRIx64 " not found.", + (uint64_t)layout); } else { // Coalesce adjacent/overlapping pipeline ranges before checking to see if incoming range is // contained in the pipeline ranges. @@ -8242,11 +8240,11 @@ VKAPI_ATTR void VKAPI_CALL CmdPushConstants(VkCommandBuffer commandBuffer, VkPip } if (spans.size() == 0) { // There were no ranges that matched the stageFlags. - skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, - DRAWSTATE_PUSH_CONSTANTS_ERROR, "DS", - "vkCmdPushConstants() stageFlags = 0x%" PRIx32 " do not match " - "the stageFlags in any of the ranges in pipeline layout 0x%" PRIx64 ".", - (uint32_t)stageFlags, (uint64_t)layout); + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, + DRAWSTATE_PUSH_CONSTANTS_ERROR, "DS", + "vkCmdPushConstants() stageFlags = 0x%" PRIx32 " do not match " + "the stageFlags in any of the ranges in pipeline layout 0x%" PRIx64 ".", + (uint32_t)stageFlags, (uint64_t)layout); } else { // Sort span list by start value. struct comparer { @@ -8281,23 +8279,23 @@ VKAPI_ATTR void VKAPI_CALL CmdPushConstants(VkCommandBuffer commandBuffer, VkPip } } if (!contained_in_a_range) { - skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, - __LINE__, DRAWSTATE_PUSH_CONSTANTS_ERROR, "DS", - "vkCmdPushConstants() Push constant range [%d, %d) " - "with stageFlags = 0x%" PRIx32 " " - "not within flag-matching ranges in pipeline layout 0x%" PRIx64 ".", - offset, offset + size, (uint32_t)stageFlags, (uint64_t)layout); + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, + __LINE__, DRAWSTATE_PUSH_CONSTANTS_ERROR, "DS", + "vkCmdPushConstants() Push constant range [%d, %d) " + "with stageFlags = 0x%" PRIx32 " " + "not within flag-matching ranges in pipeline layout 0x%" PRIx64 ".", + offset, offset + size, (uint32_t)stageFlags, (uint64_t)layout); } } } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues); } VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); @@ -8306,13 +8304,13 @@ CmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelin std::function<bool(VkQueue)> queryUpdate = std::bind(setQueryState, std::placeholders::_1, commandBuffer, query, true); pCB->queryUpdates.push_back(queryUpdate); if (pCB->state == CB_RECORDING) { - skipCall |= addCmd(dev_data, pCB, CMD_WRITETIMESTAMP, "vkCmdWriteTimestamp()"); + skip_call |= addCmd(dev_data, pCB, CMD_WRITETIMESTAMP, "vkCmdWriteTimestamp()"); } else { - skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdWriteTimestamp()"); + skip_call |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdWriteTimestamp()"); } } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, slot); } @@ -9301,7 +9299,7 @@ template <typename T> static bool FormatSpecificLoadAndStoreOpSettings(VkFormat VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, VkSubpassContents contents) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); @@ -9347,7 +9345,7 @@ CmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *p } } if (clear_op_count > pRenderPassBegin->clearValueCount) { - skipCall |= log_msg( + skip_call |= log_msg( dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, reinterpret_cast<uint64_t &>(renderPass), __LINE__, DRAWSTATE_RENDERPASS_INCOMPATIBLE, "DS", "In vkCmdBeginRenderPass() the VkRenderPassBeginInfo struct has a clearValueCount of %u but the actual number " @@ -9355,12 +9353,12 @@ CmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *p "must therefore be greater than or equal to %u.", pRenderPassBegin->clearValueCount, reinterpret_cast<uint64_t &>(renderPass), clear_op_count, clear_op_count); } - skipCall |= VerifyRenderAreaBounds(dev_data, pRenderPassBegin); - skipCall |= VerifyFramebufferAndRenderPassLayouts(dev_data, pCB, pRenderPassBegin); - skipCall |= insideRenderPass(dev_data, pCB, "vkCmdBeginRenderPass"); - skipCall |= ValidateDependencies(dev_data, framebuffer, renderPass); - skipCall |= validatePrimaryCommandBuffer(dev_data, pCB, "vkCmdBeginRenderPass"); - skipCall |= addCmd(dev_data, pCB, CMD_BEGINRENDERPASS, "vkCmdBeginRenderPass()"); + skip_call |= VerifyRenderAreaBounds(dev_data, pRenderPassBegin); + skip_call |= VerifyFramebufferAndRenderPassLayouts(dev_data, pCB, pRenderPassBegin); + skip_call |= insideRenderPass(dev_data, pCB, "vkCmdBeginRenderPass"); + skip_call |= ValidateDependencies(dev_data, framebuffer, renderPass); + skip_call |= validatePrimaryCommandBuffer(dev_data, pCB, "vkCmdBeginRenderPass"); + skip_call |= addCmd(dev_data, pCB, CMD_BEGINRENDERPASS, "vkCmdBeginRenderPass()"); pCB->activeRenderPass = renderPass; // This is a shallow copy as that is all that is needed for now pCB->activeRenderPassBeginInfo = *pRenderPassBegin; @@ -9373,37 +9371,37 @@ CmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *p // transition attachments to the correct layouts for the first subpass TransitionSubpassLayouts(dev_data, pCB, &pCB->activeRenderPassBeginInfo, pCB->activeSubpass); } else { - skipCall |= - log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, - DRAWSTATE_INVALID_RENDERPASS, "DS", "You cannot use a NULL RenderPass object in vkCmdBeginRenderPass()"); + skip_call |= + log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, + DRAWSTATE_INVALID_RENDERPASS, "DS", "You cannot use a NULL RenderPass object in vkCmdBeginRenderPass()"); } } lock.unlock(); - if (!skipCall) { + if (!skip_call) { dev_data->device_dispatch_table->CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents); } } VKAPI_ATTR void VKAPI_CALL CmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); if (pCB) { - skipCall |= validatePrimaryCommandBuffer(dev_data, pCB, "vkCmdNextSubpass"); - skipCall |= addCmd(dev_data, pCB, CMD_NEXTSUBPASS, "vkCmdNextSubpass()"); + skip_call |= validatePrimaryCommandBuffer(dev_data, pCB, "vkCmdNextSubpass"); + skip_call |= addCmd(dev_data, pCB, CMD_NEXTSUBPASS, "vkCmdNextSubpass()"); pCB->activeSubpass++; pCB->activeSubpassContents = contents; TransitionSubpassLayouts(dev_data, pCB, &pCB->activeRenderPassBeginInfo, pCB->activeSubpass); - skipCall |= outsideRenderPass(dev_data, pCB, "vkCmdNextSubpass"); + skip_call |= outsideRenderPass(dev_data, pCB, "vkCmdNextSubpass"); } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->CmdNextSubpass(commandBuffer, contents); } VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass(VkCommandBuffer commandBuffer) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); auto pCB = getCBNode(dev_data, commandBuffer); @@ -9432,16 +9430,16 @@ VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass(VkCommandBuffer commandBuffer) { } } } - skipCall |= outsideRenderPass(dev_data, pCB, "vkCmdEndRenderpass"); - skipCall |= validatePrimaryCommandBuffer(dev_data, pCB, "vkCmdEndRenderPass"); - skipCall |= addCmd(dev_data, pCB, CMD_ENDRENDERPASS, "vkCmdEndRenderPass()"); + skip_call |= outsideRenderPass(dev_data, pCB, "vkCmdEndRenderpass"); + skip_call |= validatePrimaryCommandBuffer(dev_data, pCB, "vkCmdEndRenderPass"); + skip_call |= addCmd(dev_data, pCB, CMD_ENDRENDERPASS, "vkCmdEndRenderPass()"); TransitionFinalSubpassLayouts(dev_data, pCB, &pCB->activeRenderPassBeginInfo); pCB->activeRenderPass = nullptr; pCB->activeSubpass = 0; pCB->activeFramebuffer = VK_NULL_HANDLE; } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->CmdEndRenderPass(commandBuffer); } @@ -9605,7 +9603,7 @@ static bool validateFramebuffer(layer_data *dev_data, VkCommandBuffer primaryBuf } static bool validateSecondaryCommandBufferState(layer_data *dev_data, GLOBAL_CB_NODE *pCB, GLOBAL_CB_NODE *pSubCB) { - bool skipCall = false; + bool skip_call = false; unordered_set<int> activeTypes; for (auto queryObject : pCB->activeQueries) { auto queryPoolData = dev_data->queryPoolMap.find(queryObject.pool); @@ -9614,7 +9612,7 @@ static bool validateSecondaryCommandBufferState(layer_data *dev_data, GLOBAL_CB_ pSubCB->beginInfo.pInheritanceInfo) { VkQueryPipelineStatisticFlags cmdBufStatistics = pSubCB->beginInfo.pInheritanceInfo->pipelineStatistics; if ((cmdBufStatistics & queryPoolData->second.createInfo.pipelineStatistics) != cmdBufStatistics) { - skipCall |= log_msg( + skip_call |= log_msg( dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, DRAWSTATE_INVALID_SECONDARY_COMMAND_BUFFER, "DS", "vkCmdExecuteCommands() called w/ invalid Cmd Buffer 0x%p " @@ -9629,7 +9627,7 @@ static bool validateSecondaryCommandBufferState(layer_data *dev_data, GLOBAL_CB_ for (auto queryObject : pSubCB->startedQueries) { auto queryPoolData = dev_data->queryPoolMap.find(queryObject.pool); if (queryPoolData != dev_data->queryPoolMap.end() && activeTypes.count(queryPoolData->second.createInfo.queryType)) { - skipCall |= + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, DRAWSTATE_INVALID_SECONDARY_COMMAND_BUFFER, "DS", "vkCmdExecuteCommands() called w/ invalid Cmd Buffer 0x%p " @@ -9639,12 +9637,12 @@ static bool validateSecondaryCommandBufferState(layer_data *dev_data, GLOBAL_CB_ queryPoolData->second.createInfo.queryType, reinterpret_cast<void *>(pSubCB->commandBuffer)); } } - return skipCall; + return skip_call; } VKAPI_ATTR void VKAPI_CALL CmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount, const VkCommandBuffer *pCommandBuffers) { - bool skipCall = false; + bool skip_call = false; layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer); @@ -9653,21 +9651,21 @@ CmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount, for (uint32_t i = 0; i < commandBuffersCount; i++) { pSubCB = getCBNode(dev_data, pCommandBuffers[i]); if (!pSubCB) { - skipCall |= + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, DRAWSTATE_INVALID_SECONDARY_COMMAND_BUFFER, "DS", "vkCmdExecuteCommands() called w/ invalid Cmd Buffer 0x%p in element %u of pCommandBuffers array.", (void *)pCommandBuffers[i], i); } else if (VK_COMMAND_BUFFER_LEVEL_PRIMARY == pSubCB->createInfo.level) { - skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, - __LINE__, DRAWSTATE_INVALID_SECONDARY_COMMAND_BUFFER, "DS", - "vkCmdExecuteCommands() called w/ Primary Cmd Buffer 0x%p in element %u of pCommandBuffers " - "array. All cmd buffers in pCommandBuffers array must be secondary.", - (void *)pCommandBuffers[i], i); + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, + __LINE__, DRAWSTATE_INVALID_SECONDARY_COMMAND_BUFFER, "DS", + "vkCmdExecuteCommands() called w/ Primary Cmd Buffer 0x%p in element %u of pCommandBuffers " + "array. All cmd buffers in pCommandBuffers array must be secondary.", + (void *)pCommandBuffers[i], i); } else if (pCB->activeRenderPass) { // Secondary CB w/i RenderPass must have *CONTINUE_BIT set auto secondary_rp_node = getRenderPass(dev_data, pSubCB->beginInfo.pInheritanceInfo->renderPass); if (!(pSubCB->beginInfo.flags & VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT)) { - skipCall |= log_msg( + skip_call |= log_msg( dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, (uint64_t)pCommandBuffers[i], __LINE__, DRAWSTATE_BEGIN_CB_INVALID_STATE, "DS", "vkCmdExecuteCommands(): Secondary Command Buffer (0x%p) executed within render pass (0x%" PRIxLEAST64 @@ -9676,16 +9674,16 @@ CmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount, } else { // Make sure render pass is compatible with parent command buffer pass if has continue if (pCB->activeRenderPass->renderPass != secondary_rp_node->renderPass) { - skipCall |= validateRenderPassCompatibility(dev_data, commandBuffer, pCB->activeRenderPass->pCreateInfo, + skip_call |= validateRenderPassCompatibility(dev_data, commandBuffer, pCB->activeRenderPass->pCreateInfo, pCommandBuffers[i], secondary_rp_node->pCreateInfo); } - skipCall |= validateFramebuffer(dev_data, commandBuffer, pCB, pCommandBuffers[i], pSubCB); + skip_call |= validateFramebuffer(dev_data, commandBuffer, pCB, pCommandBuffers[i], pSubCB); } string errorString = ""; if ((pCB->activeRenderPass->renderPass != secondary_rp_node->renderPass) && !verify_renderpass_compatibility(dev_data, pCB->activeRenderPass->pCreateInfo, secondary_rp_node->pCreateInfo, errorString)) { - skipCall |= log_msg( + skip_call |= log_msg( dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, (uint64_t)pCommandBuffers[i], __LINE__, DRAWSTATE_RENDERPASS_INCOMPATIBLE, "DS", "vkCmdExecuteCommands(): Secondary Command Buffer (0x%p) w/ render pass (0x%" PRIxLEAST64 @@ -9697,7 +9695,7 @@ CmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount, // that this CB will be executed in AND framebuffer must have been created w/ RP compatible w/ renderpass if (pSubCB->beginInfo.pInheritanceInfo->framebuffer) { if (pSubCB->beginInfo.pInheritanceInfo->framebuffer != pCB->activeRenderPassBeginInfo.framebuffer) { - skipCall |= log_msg( + skip_call |= log_msg( dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, (uint64_t)pCommandBuffers[i], __LINE__, DRAWSTATE_FRAMEBUFFER_INCOMPATIBLE, "DS", "vkCmdExecuteCommands(): Secondary Command Buffer (0x%p) references framebuffer (0x%" PRIxLEAST64 @@ -9708,13 +9706,13 @@ CmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount, } } // TODO(mlentine): Move more logic into this method - skipCall |= validateSecondaryCommandBufferState(dev_data, pCB, pSubCB); - skipCall |= validateCommandBufferState(dev_data, pSubCB); + skip_call |= validateSecondaryCommandBufferState(dev_data, pCB, pSubCB); + skip_call |= validateCommandBufferState(dev_data, pSubCB); // Secondary cmdBuffers are considered pending execution starting w/ // being recorded if (!(pSubCB->beginInfo.flags & VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT)) { if (dev_data->globalInFlightCmdBuffers.find(pSubCB->commandBuffer) != dev_data->globalInFlightCmdBuffers.end()) { - skipCall |= log_msg( + skip_call |= log_msg( dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, (uint64_t)(pCB->commandBuffer), __LINE__, DRAWSTATE_INVALID_CB_SIMULTANEOUS_USE, "DS", "Attempt to simultaneously execute CB 0x%" PRIxLEAST64 " w/o VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT " @@ -9723,19 +9721,19 @@ CmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount, } if (pCB->beginInfo.flags & VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT) { // Warn that non-simultaneous secondary cmd buffer renders primary non-simultaneous - skipCall |= log_msg( + skip_call |= log_msg( dev_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, (uint64_t)(pCommandBuffers[i]), __LINE__, DRAWSTATE_INVALID_CB_SIMULTANEOUS_USE, "DS", "vkCmdExecuteCommands(): Secondary Command Buffer (0x%" PRIxLEAST64 ") does not have VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT set and will cause primary command buffer " "(0x%" PRIxLEAST64 ") to be treated as if it does not have VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT " - "set, even though it does.", + "set, even though it does.", (uint64_t)(pCommandBuffers[i]), (uint64_t)(pCB->commandBuffer)); pCB->beginInfo.flags &= ~VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT; } } if (!pCB->activeQueries.empty() && !dev_data->phys_dev_properties.features.inheritedQueries) { - skipCall |= + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, reinterpret_cast<uint64_t>(pCommandBuffers[i]), __LINE__, DRAWSTATE_INVALID_COMMAND_BUFFER, "DS", "vkCmdExecuteCommands(): Secondary Command Buffer " @@ -9748,11 +9746,11 @@ CmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount, pCB->secondaryCommandBuffers.insert(pSubCB->commandBuffer); dev_data->globalInFlightCmdBuffers.insert(pSubCB->commandBuffer); } - skipCall |= validatePrimaryCommandBuffer(dev_data, pCB, "vkCmdExecuteComands"); - skipCall |= addCmd(dev_data, pCB, CMD_EXECUTECOMMANDS, "vkCmdExecuteComands()"); + skip_call |= validatePrimaryCommandBuffer(dev_data, pCB, "vkCmdExecuteComands"); + skip_call |= addCmd(dev_data, pCB, CMD_EXECUTECOMMANDS, "vkCmdExecuteComands()"); } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->CmdExecuteCommands(commandBuffer, commandBuffersCount, pCommandBuffers); } @@ -9816,24 +9814,24 @@ MapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize VKAPI_ATTR void VKAPI_CALL UnmapMemory(VkDevice device, VkDeviceMemory mem) { layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); - bool skipCall = false; + bool skip_call = false; std::unique_lock<std::mutex> lock(global_lock); - skipCall |= deleteMemRanges(my_data, mem); + skip_call |= deleteMemRanges(my_data, mem); lock.unlock(); - if (!skipCall) { + if (!skip_call) { my_data->device_dispatch_table->UnmapMemory(device, mem); } } static bool validateMemoryIsMapped(layer_data *my_data, const char *funcName, uint32_t memRangeCount, const VkMappedMemoryRange *pMemRanges) { - bool skipCall = false; + bool skip_call = false; for (uint32_t i = 0; i < memRangeCount; ++i) { auto mem_info = getMemObjInfo(my_data, pMemRanges[i].memory); if (mem_info) { if (mem_info->memRange.offset > pMemRanges[i].offset) { - skipCall |= + skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, (uint64_t)pMemRanges[i].memory, __LINE__, MEMTRACK_INVALID_MAP, "MEM", "%s: Flush/Invalidate offset (" PRINTF_SIZE_T_SPECIFIER ") is less than Memory Object's offset " @@ -9845,22 +9843,21 @@ static bool validateMemoryIsMapped(layer_data *my_data, const char *funcName, ui (mem_info->memRange.size == VK_WHOLE_SIZE) ? mem_info->allocInfo.allocationSize : (mem_info->memRange.offset + mem_info->memRange.size); if (pMemRanges[i].size != VK_WHOLE_SIZE && (my_dataTerminus < (pMemRanges[i].offset + pMemRanges[i].size))) { - skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, (uint64_t)pMemRanges[i].memory, __LINE__, - MEMTRACK_INVALID_MAP, "MEM", "%s: Flush/Invalidate upper-bound (" PRINTF_SIZE_T_SPECIFIER - ") exceeds the Memory Object's upper-bound " - "(" PRINTF_SIZE_T_SPECIFIER ").", - funcName, static_cast<size_t>(pMemRanges[i].offset + pMemRanges[i].size), - static_cast<size_t>(my_dataTerminus)); + skip_call |= log_msg( + my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, + (uint64_t)pMemRanges[i].memory, __LINE__, MEMTRACK_INVALID_MAP, "MEM", + "%s: Flush/Invalidate upper-bound (" PRINTF_SIZE_T_SPECIFIER ") exceeds the Memory Object's upper-bound " + "(" PRINTF_SIZE_T_SPECIFIER ").", + funcName, static_cast<size_t>(pMemRanges[i].offset + pMemRanges[i].size), static_cast<size_t>(my_dataTerminus)); } } } - return skipCall; + return skip_call; } static bool validateAndCopyNoncoherentMemoryToDriver(layer_data *my_data, uint32_t memRangeCount, const VkMappedMemoryRange *pMemRanges) { - bool skipCall = false; + bool skip_call = false; for (uint32_t i = 0; i < memRangeCount; ++i) { auto mem_info = getMemObjInfo(my_data, pMemRanges[i].memory); if (mem_info) { @@ -9870,38 +9867,38 @@ static bool validateAndCopyNoncoherentMemoryToDriver(layer_data *my_data, uint32 char *data = static_cast<char *>(mem_info->pData); for (auto j = 0; j < half_size; ++j) { if (data[j] != NoncoherentMemoryFillValue) { - skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, (uint64_t)pMemRanges[i].memory, __LINE__, - MEMTRACK_INVALID_MAP, "MEM", "Memory overflow was detected on mem obj 0x%" PRIxLEAST64, - (uint64_t)pMemRanges[i].memory); + skip_call |= log_msg( + my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, + (uint64_t)pMemRanges[i].memory, __LINE__, MEMTRACK_INVALID_MAP, "MEM", + "Memory overflow was detected on mem obj 0x%" PRIxLEAST64, (uint64_t)pMemRanges[i].memory); } } for (auto j = size + half_size; j < 2 * size; ++j) { if (data[j] != NoncoherentMemoryFillValue) { - skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, (uint64_t)pMemRanges[i].memory, __LINE__, - MEMTRACK_INVALID_MAP, "MEM", "Memory overflow was detected on mem obj 0x%" PRIxLEAST64, - (uint64_t)pMemRanges[i].memory); + skip_call |= log_msg( + my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, + (uint64_t)pMemRanges[i].memory, __LINE__, MEMTRACK_INVALID_MAP, "MEM", + "Memory overflow was detected on mem obj 0x%" PRIxLEAST64, (uint64_t)pMemRanges[i].memory); } } memcpy(mem_info->pDriverData, static_cast<void *>(data + (size_t)(half_size)), (size_t)(size)); } } } - return skipCall; + return skip_call; } VkResult VKAPI_CALL FlushMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange *pMemRanges) { VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - bool skipCall = false; + bool skip_call = false; layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); - skipCall |= validateAndCopyNoncoherentMemoryToDriver(my_data, memRangeCount, pMemRanges); - skipCall |= validateMemoryIsMapped(my_data, "vkFlushMappedMemoryRanges", memRangeCount, pMemRanges); + skip_call |= validateAndCopyNoncoherentMemoryToDriver(my_data, memRangeCount, pMemRanges); + skip_call |= validateMemoryIsMapped(my_data, "vkFlushMappedMemoryRanges", memRangeCount, pMemRanges); lock.unlock(); - if (!skipCall) { + if (!skip_call) { result = my_data->device_dispatch_table->FlushMappedMemoryRanges(device, memRangeCount, pMemRanges); } return result; @@ -9910,13 +9907,13 @@ FlushMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedM VkResult VKAPI_CALL InvalidateMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange *pMemRanges) { VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - bool skipCall = false; + bool skip_call = false; layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); std::unique_lock<std::mutex> lock(global_lock); - skipCall |= validateMemoryIsMapped(my_data, "vkInvalidateMappedMemoryRanges", memRangeCount, pMemRanges); + skip_call |= validateMemoryIsMapped(my_data, "vkInvalidateMappedMemoryRanges", memRangeCount, pMemRanges); lock.unlock(); - if (!skipCall) { + if (!skip_call) { result = my_data->device_dispatch_table->InvalidateMappedMemoryRanges(device, memRangeCount, pMemRanges); } return result; @@ -9925,13 +9922,13 @@ InvalidateMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMa VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memoryOffset) { layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - bool skipCall = false; + bool skip_call = false; std::unique_lock<std::mutex> lock(global_lock); auto image_node = getImageNode(dev_data, image); if (image_node) { // Track objects tied to memory uint64_t image_handle = reinterpret_cast<uint64_t &>(image); - skipCall = set_mem_binding(dev_data, mem, image_handle, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, "vkBindImageMemory"); + skip_call = set_mem_binding(dev_data, mem, image_handle, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, "vkBindImageMemory"); VkMemoryRequirements memRequirements; lock.unlock(); dev_data->device_dispatch_table->GetImageMemoryRequirements(device, image, &memRequirements); @@ -9942,13 +9939,13 @@ VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory(VkDevice device, VkImage image, V if (mem_info) { const MEMORY_RANGE range = insert_memory_ranges(image_handle, mem, memoryOffset, memRequirements, mem_info->imageRanges); - skipCall |= validate_memory_range(dev_data, mem_info->bufferRanges, range, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT); - skipCall |= ValidateMemoryTypes(dev_data, mem_info, memRequirements.memoryTypeBits, "vkBindImageMemory"); + skip_call |= validate_memory_range(dev_data, mem_info->bufferRanges, range, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT); + skip_call |= ValidateMemoryTypes(dev_data, mem_info, memRequirements.memoryTypeBits, "vkBindImageMemory"); } print_mem_list(dev_data); lock.unlock(); - if (!skipCall) { + if (!skip_call) { result = dev_data->device_dispatch_table->BindImageMemory(device, image, mem, memoryOffset); lock.lock(); dev_data->memObjMap[mem].get()->image = image; @@ -10126,7 +10123,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateSwapchainKHR(VkDevice device, const VkSwapc VKAPI_ATTR void VKAPI_CALL DestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator) { layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); - bool skipCall = false; + bool skip_call = false; std::unique_lock<std::mutex> lock(global_lock); auto swapchain_data = getSwapchainNode(dev_data, swapchain); @@ -10143,15 +10140,15 @@ DestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocatio } dev_data->imageSubresourceMap.erase(image_sub); } - skipCall = clear_object_binding(dev_data, (uint64_t)swapchain_image, - VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT); + skip_call = + clear_object_binding(dev_data, (uint64_t)swapchain_image, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT); dev_data->imageMap.erase(swapchain_image); } } dev_data->device_extensions.swapchainMap.erase(swapchain); } lock.unlock(); - if (!skipCall) + if (!skip_call) dev_data->device_dispatch_table->DestroySwapchainKHR(device, swapchain, pAllocator); } @@ -10271,23 +10268,23 @@ VKAPI_ATTR VkResult VKAPI_CALL QueuePresentKHR(VkQueue queue, const VkPresentInf VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex) { layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); - bool skipCall = false; + bool skip_call = false; std::unique_lock<std::mutex> lock(global_lock); auto pSemaphore = getSemaphoreNode(dev_data, semaphore); if (pSemaphore && pSemaphore->signaled) { - skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, - reinterpret_cast<const uint64_t &>(semaphore), __LINE__, DRAWSTATE_QUEUE_FORWARD_PROGRESS, "DS", - "vkAcquireNextImageKHR: Semaphore must not be currently signaled or in a wait state"); + skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, + reinterpret_cast<const uint64_t &>(semaphore), __LINE__, DRAWSTATE_QUEUE_FORWARD_PROGRESS, "DS", + "vkAcquireNextImageKHR: Semaphore must not be currently signaled or in a wait state"); } auto pFence = getFenceNode(dev_data, fence); if (pFence) { - skipCall |= ValidateFenceForSubmit(dev_data, pFence); + skip_call |= ValidateFenceForSubmit(dev_data, pFence); } lock.unlock(); - if (skipCall) + if (skip_call) return VK_ERROR_VALIDATION_FAILED_EXT; VkResult result = @@ -10311,7 +10308,7 @@ VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImageKHR(VkDevice device, VkSwapchainK VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, VkPhysicalDevice *pPhysicalDevices) { - bool skipCall = false; + bool skip_call = false; layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map); if (my_data->instance_state) { // For this instance, flag when vkEnumeratePhysicalDevices goes to QUERY_COUNT and then QUERY_DETAILS @@ -10321,14 +10318,14 @@ VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDevices(VkInstance instance, uin if (UNCALLED == my_data->instance_state->vkEnumeratePhysicalDevicesState) { // Flag warning here. You can call this without having queried the count, but it may not be // robust on platforms with multiple physical devices. - skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, + skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, 0, __LINE__, DEVLIMITS_MISSING_QUERY_COUNT, "DL", "Call sequence has vkEnumeratePhysicalDevices() w/ non-NULL pPhysicalDevices. You should first " "call vkEnumeratePhysicalDevices() w/ NULL pPhysicalDevices to query pPhysicalDeviceCount."); } // TODO : Could also flag a warning if re-calling this function in QUERY_DETAILS state else if (my_data->instance_state->physical_devices_count != *pPhysicalDeviceCount) { // Having actual count match count from app is not a requirement, so this can be a warning - skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, + skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, 0, __LINE__, DEVLIMITS_COUNT_MISMATCH, "DL", "Call to vkEnumeratePhysicalDevices() w/ pPhysicalDeviceCount value %u, but actual count " "supported by this instance is %u.", @@ -10336,7 +10333,7 @@ VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDevices(VkInstance instance, uin } my_data->instance_state->vkEnumeratePhysicalDevicesState = QUERY_DETAILS; } - if (skipCall) { + if (skip_call) { return VK_ERROR_VALIDATION_FAILED_EXT; } VkResult result = |