layers: Clang-format changes for files in layers dir of repo

1 files changed, 983 insertions, 643 deletions

diff --git a/layers/image.cpp b/layers/image.cpp
index a40b2f23..56d1bb5c 100644
--- a/layers/image.cpp
+++ b/layers/image.cpp
@@ -58,37 +58,33 @@ using namespace std;
 using namespace std;
 
 struct layer_data {
-    debug_report_data            *report_data;
-    vector<VkDebugReportCallbackEXT>      logging_callback;
-    VkLayerDispatchTable*         device_dispatch_table;
+    debug_report_data *report_data;
+    vector<VkDebugReportCallbackEXT> logging_callback;
+    VkLayerDispatchTable *device_dispatch_table;
     VkLayerInstanceDispatchTable *instance_dispatch_table;
-    VkPhysicalDevice              physicalDevice;
-    VkPhysicalDeviceProperties    physicalDeviceProperties;
+    VkPhysicalDevice physicalDevice;
+    VkPhysicalDeviceProperties physicalDeviceProperties;
 
     unordered_map<VkImage, IMAGE_STATE> imageMap;
 
-    layer_data() :
-        report_data(nullptr),
-        device_dispatch_table(nullptr),
-        instance_dispatch_table(nullptr),
-        physicalDevice(0),
-        physicalDeviceProperties()
-    {};
+    layer_data()
+        : report_data(nullptr), device_dispatch_table(nullptr),
+          instance_dispatch_table(nullptr), physicalDevice(0),
+          physicalDeviceProperties(){};
 };
 
-static unordered_map<void*, layer_data*> layer_data_map;
+static unordered_map<void *, layer_data *> layer_data_map;
 
-static void InitImage(layer_data *data, const VkAllocationCallbacks *pAllocator)
-{
+static void InitImage(layer_data *data,
+                      const VkAllocationCallbacks *pAllocator) {
     VkDebugReportCallbackEXT callback;
     uint32_t report_flags = getLayerOptionFlags("ImageReportFlags", 0);
 
     uint32_t debug_action = 0;
-    getLayerOptionEnum("ImageDebugAction", (uint32_t *) &debug_action);
-    if(debug_action & VK_DBG_LAYER_ACTION_LOG_MSG)
-    {
+    getLayerOptionEnum("ImageDebugAction", (uint32_t *)&debug_action);
+    if (debug_action & VK_DBG_LAYER_ACTION_LOG_MSG) {
         FILE *log_output = NULL;
-        const char* option_str = getLayerOption("ImageLogFilename");
+        const char *option_str = getLayerOption("ImageLogFilename");
         log_output = getLayerLogOutput(option_str, "Image");
         VkDebugReportCallbackCreateInfoEXT dbgInfo;
         memset(&dbgInfo, 0, sizeof(dbgInfo));
@@ -96,7 +92,8 @@ static void InitImage(layer_data *data, const VkAllocationCallbacks *pAllocator)
         dbgInfo.pfnCallback = log_callback;
         dbgInfo.pUserData = log_output;
         dbgInfo.flags = report_flags;
-        layer_create_msg_callback(data->report_data, &dbgInfo, pAllocator, &callback);
+        layer_create_msg_callback(data->report_data, &dbgInfo, pAllocator,
+                                  &callback);
         data->logging_callback.push_back(callback);
     }
 
@@ -106,56 +103,63 @@ static void InitImage(layer_data *data, const VkAllocationCallbacks *pAllocator)
         dbgInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT;
         dbgInfo.pfnCallback = win32_debug_output_msg;
         dbgInfo.flags = report_flags;
-        layer_create_msg_callback(data->report_data, &dbgInfo, pAllocator, &callback);
+        layer_create_msg_callback(data->report_data, &dbgInfo, pAllocator,
+                                  &callback);
         data->logging_callback.push_back(callback);
     }
 }
 
 VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT(
-        VkInstance                                  instance,
-        const VkDebugReportCallbackCreateInfoEXT*   pCreateInfo,
-        const VkAllocationCallbacks*                pAllocator,
-        VkDebugReportCallbackEXT*                   pMsgCallback)
-{
-    layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
-    VkResult res = my_data->instance_dispatch_table->CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pMsgCallback);
+    VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
+    const VkAllocationCallbacks *pAllocator,
+    VkDebugReportCallbackEXT *pMsgCallback) {
+    layer_data *my_data =
+        get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
+    VkResult res =
+        my_data->instance_dispatch_table->CreateDebugReportCallbackEXT(
+            instance, pCreateInfo, pAllocator, pMsgCallback);
     if (res == VK_SUCCESS) {
-        res = layer_create_msg_callback(my_data->report_data, pCreateInfo, pAllocator, pMsgCallback);
+        res = layer_create_msg_callback(my_data->report_data, pCreateInfo,
+                                        pAllocator, pMsgCallback);
     }
     return res;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT(
-        VkInstance                                  instance,
-        VkDebugReportCallbackEXT                    msgCallback,
-        const VkAllocationCallbacks*                pAllocator)
-{
-    layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
-    my_data->instance_dispatch_table->DestroyDebugReportCallbackEXT(instance, msgCallback, pAllocator);
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkDestroyDebugReportCallbackEXT(VkInstance instance,
+                                    VkDebugReportCallbackEXT msgCallback,
+                                    const VkAllocationCallbacks *pAllocator) {
+    layer_data *my_data =
+        get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
+    my_data->instance_dispatch_table->DestroyDebugReportCallbackEXT(
+        instance, msgCallback, pAllocator);
     layer_destroy_msg_callback(my_data->report_data, msgCallback, pAllocator);
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT(
-        VkInstance                                  instance,
-        VkDebugReportFlagsEXT                       flags,
-        VkDebugReportObjectTypeEXT                  objType,
-        uint64_t                                    object,
-        size_t                                      location,
-        int32_t                                     msgCode,
-        const char*                                 pLayerPrefix,
-        const char*                                 pMsg)
-{
-    layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
-    my_data->instance_dispatch_table->DebugReportMessageEXT(instance, flags, objType, object, location, msgCode, pLayerPrefix, pMsg);
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags,
+                            VkDebugReportObjectTypeEXT objType, uint64_t object,
+                            size_t location, int32_t msgCode,
+                            const char *pLayerPrefix, const char *pMsg) {
+    layer_data *my_data =
+        get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
+    my_data->instance_dispatch_table->DebugReportMessageEXT(
+        instance, flags, objType, object, location, msgCode, pLayerPrefix,
+        pMsg);
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance)
-{
-    VkLayerInstanceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO);
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo,
+                     const VkAllocationCallbacks *pAllocator,
+                     VkInstance *pInstance) {
+    VkLayerInstanceCreateInfo *chain_info =
+        get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO);
 
     assert(chain_info->u.pLayerInfo);
-    PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr;
-    PFN_vkCreateInstance fpCreateInstance = (PFN_vkCreateInstance) fpGetInstanceProcAddr(NULL, "vkCreateInstance");
+    PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr =
+        chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr;
+    PFN_vkCreateInstance fpCreateInstance =
+        (PFN_vkCreateInstance)fpGetInstanceProcAddr(NULL, "vkCreateInstance");
     if (fpCreateInstance == NULL) {
         return VK_ERROR_INITIALIZATION_FAILED;
     }
@@ -167,23 +171,25 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(const VkInstance
     if (result != VK_SUCCESS)
         return result;
 
-    layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
+    layer_data *my_data =
+        get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
     my_data->instance_dispatch_table = new VkLayerInstanceDispatchTable;
-    layer_init_instance_dispatch_table(*pInstance, my_data->instance_dispatch_table, fpGetInstanceProcAddr);
+    layer_init_instance_dispatch_table(
+        *pInstance, my_data->instance_dispatch_table, fpGetInstanceProcAddr);
 
     my_data->report_data = debug_report_create_instance(
-                               my_data->instance_dispatch_table,
-                               *pInstance,
-                               pCreateInfo->enabledExtensionCount,
-                               pCreateInfo->ppEnabledExtensionNames);
+        my_data->instance_dispatch_table, *pInstance,
+        pCreateInfo->enabledExtensionCount,
+        pCreateInfo->ppEnabledExtensionNames);
 
     InitImage(my_data, pAllocator);
 
     return result;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator)
-{
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkDestroyInstance(VkInstance instance,
+                      const VkAllocationCallbacks *pAllocator) {
     // Grab the key before the instance is destroyed.
     dispatch_key key = get_dispatch_key(instance);
     layer_data *my_data = get_my_data_ptr(key, layer_data_map);
@@ -200,17 +206,22 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(VkInstance instance
     layer_debug_report_destroy_instance(my_data->report_data);
     delete my_data->instance_dispatch_table;
     layer_data_map.erase(key);
-
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
-{
-    VkLayerDeviceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO);
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkCreateDevice(VkPhysicalDevice physicalDevice,
+                   const VkDeviceCreateInfo *pCreateInfo,
+                   const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) {
+    VkLayerDeviceCreateInfo *chain_info =
+        get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO);
 
     assert(chain_info->u.pLayerInfo);
-    PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr;
-    PFN_vkGetDeviceProcAddr fpGetDeviceProcAddr = chain_info->u.pLayerInfo->pfnNextGetDeviceProcAddr;
-    PFN_vkCreateDevice fpCreateDevice = (PFN_vkCreateDevice) fpGetInstanceProcAddr(NULL, "vkCreateDevice");
+    PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr =
+        chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr;
+    PFN_vkGetDeviceProcAddr fpGetDeviceProcAddr =
+        chain_info->u.pLayerInfo->pfnNextGetDeviceProcAddr;
+    PFN_vkCreateDevice fpCreateDevice =
+        (PFN_vkCreateDevice)fpGetInstanceProcAddr(NULL, "vkCreateDevice");
     if (fpCreateDevice == NULL) {
         return VK_ERROR_INITIALIZATION_FAILED;
     }
@@ -218,28 +229,34 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(VkPhysicalDevice p
     // Advance the link info for the next element on the chain
     chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext;
 
-    VkResult result = fpCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
+    VkResult result =
+        fpCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
     if (result != VK_SUCCESS) {
         return result;
     }
 
-    layer_data *my_instance_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
-    layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map);
+    layer_data *my_instance_data =
+        get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
+    layer_data *my_device_data =
+        get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map);
 
     // Setup device dispatch table
     my_device_data->device_dispatch_table = new VkLayerDispatchTable;
-    layer_init_device_dispatch_table(*pDevice, my_device_data->device_dispatch_table, fpGetDeviceProcAddr);
+    layer_init_device_dispatch_table(
+        *pDevice, my_device_data->device_dispatch_table, fpGetDeviceProcAddr);
 
-    my_device_data->report_data = layer_debug_report_create_device(my_instance_data->report_data, *pDevice);
+    my_device_data->report_data = layer_debug_report_create_device(
+        my_instance_data->report_data, *pDevice);
     my_device_data->physicalDevice = physicalDevice;
 
-    my_instance_data->instance_dispatch_table->GetPhysicalDeviceProperties(physicalDevice, &(my_device_data->physicalDeviceProperties));
+    my_instance_data->instance_dispatch_table->GetPhysicalDeviceProperties(
+        physicalDevice, &(my_device_data->physicalDeviceProperties));
 
     return result;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator)
-{
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) {
     dispatch_key key = get_dispatch_key(device);
     layer_data *my_data = get_my_data_ptr(key, layer_data_map);
     my_data->device_dispatch_table->DestroyDevice(device, pAllocator);
@@ -248,181 +265,196 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(VkDevice device, cons
 }
 
 static const VkExtensionProperties instance_extensions[] = {
-    {
-        VK_EXT_DEBUG_REPORT_EXTENSION_NAME,
-        VK_EXT_DEBUG_REPORT_SPEC_VERSION
-    }
-};
-
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(
-        const char *pLayerName,
-        uint32_t *pCount,
-        VkExtensionProperties* pProperties)
-{
-    return util_GetExtensionProperties(1, instance_extensions, pCount, pProperties);
+    {VK_EXT_DEBUG_REPORT_EXTENSION_NAME, VK_EXT_DEBUG_REPORT_SPEC_VERSION}};
+
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkEnumerateInstanceExtensionProperties(const char *pLayerName,
+                                           uint32_t *pCount,
+                                           VkExtensionProperties *pProperties) {
+    return util_GetExtensionProperties(1, instance_extensions, pCount,
+                                       pProperties);
 }
 
-static const VkLayerProperties pc_global_layers[] = {
-    {
-        "VK_LAYER_LUNARG_image",
-        VK_API_VERSION,
-        VK_MAKE_VERSION(0, 1, 0),
-        "Validation layer: image",
-    }
-};
+static const VkLayerProperties pc_global_layers[] = {{
+    "VK_LAYER_LUNARG_image", VK_API_VERSION, VK_MAKE_VERSION(0, 1, 0),
+    "Validation layer: image",
+}};
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(
-        uint32_t *pCount,
-        VkLayerProperties*    pProperties)
-{
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkEnumerateInstanceLayerProperties(uint32_t *pCount,
+                                       VkLayerProperties *pProperties) {
     return util_GetLayerProperties(ARRAY_SIZE(pc_global_layers),
-                                   pc_global_layers,
-                                   pCount, pProperties);
+                                   pc_global_layers, pCount, pProperties);
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(
-        VkPhysicalDevice                            physicalDevice,
-        const char*                                 pLayerName,
-        uint32_t*                                   pCount,
-        VkExtensionProperties*                      pProperties)
-{
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,
+                                         const char *pLayerName,
+                                         uint32_t *pCount,
+                                         VkExtensionProperties *pProperties) {
     // Image does not have any physical device extensions
     if (pLayerName == NULL) {
         dispatch_key key = get_dispatch_key(physicalDevice);
         layer_data *my_data = get_my_data_ptr(key, layer_data_map);
         VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
-        return pTable->EnumerateDeviceExtensionProperties(
-                                                    physicalDevice,
-                                                    NULL,
-                                                    pCount,
-                                                    pProperties);
+        return pTable->EnumerateDeviceExtensionProperties(physicalDevice, NULL,
+                                                          pCount, pProperties);
     } else {
         return util_GetExtensionProperties(0, NULL, pCount, pProperties);
     }
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(
-        VkPhysicalDevice                            physicalDevice,
-        uint32_t*                                   pCount,
-        VkLayerProperties*                          pProperties)
-{
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,
+                                     uint32_t *pCount,
+                                     VkLayerProperties *pProperties) {
     // ParamChecker's physical device layers are the same as global
-    return util_GetLayerProperties(ARRAY_SIZE(pc_global_layers), pc_global_layers,
-                                   pCount, pProperties);
+    return util_GetLayerProperties(ARRAY_SIZE(pc_global_layers),
+                                   pc_global_layers, pCount, pProperties);
 }
 
 // Start of the Image layer proper
 
 // Returns TRUE if a format is a depth-compatible format
-bool is_depth_format(VkFormat format)
-{
+bool is_depth_format(VkFormat format) {
     bool result = VK_FALSE;
     switch (format) {
-        case VK_FORMAT_D16_UNORM:
-        case VK_FORMAT_X8_D24_UNORM_PACK32:
-        case VK_FORMAT_D32_SFLOAT:
-        case VK_FORMAT_S8_UINT:
-        case VK_FORMAT_D16_UNORM_S8_UINT:
-        case VK_FORMAT_D24_UNORM_S8_UINT:
-        case VK_FORMAT_D32_SFLOAT_S8_UINT:
-            result = VK_TRUE;
-            break;
-        default:
-            break;
+    case VK_FORMAT_D16_UNORM:
+    case VK_FORMAT_X8_D24_UNORM_PACK32:
+    case VK_FORMAT_D32_SFLOAT:
+    case VK_FORMAT_S8_UINT:
+    case VK_FORMAT_D16_UNORM_S8_UINT:
+    case VK_FORMAT_D24_UNORM_S8_UINT:
+    case VK_FORMAT_D32_SFLOAT_S8_UINT:
+        result = VK_TRUE;
+        break;
+    default:
+        break;
     }
     return result;
 }
 
-static inline uint32_t validate_VkImageLayoutKHR(VkImageLayout input_value)
-{
+static inline uint32_t validate_VkImageLayoutKHR(VkImageLayout input_value) {
     return ((validate_VkImageLayout(input_value) == 1) ||
             (input_value == VK_IMAGE_LAYOUT_PRESENT_SRC_KHR));
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
-{
-    VkBool32                skipCall              = VK_FALSE;
-    VkResult                result                = VK_ERROR_VALIDATION_FAILED_EXT;
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo,
+                  const VkAllocationCallbacks *pAllocator, VkImage *pImage) {
+    VkBool32 skipCall = VK_FALSE;
+    VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
     VkImageFormatProperties ImageFormatProperties = {0};
 
-    layer_data       *device_data    = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
-    VkPhysicalDevice  physicalDevice = device_data->physicalDevice;
-    layer_data       *phy_dev_data   = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
+    layer_data *device_data =
+        get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+    VkPhysicalDevice physicalDevice = device_data->physicalDevice;
+    layer_data *phy_dev_data =
+        get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
 
-    if (pCreateInfo->format != VK_FORMAT_UNDEFINED)
-    {
+    if (pCreateInfo->format != VK_FORMAT_UNDEFINED) {
         VkFormatProperties properties;
-        phy_dev_data->instance_dispatch_table->GetPhysicalDeviceFormatProperties(
+        phy_dev_data->instance_dispatch_table
+            ->GetPhysicalDeviceFormatProperties(
                 device_data->physicalDevice, pCreateInfo->format, &properties);
 
-        if ((properties.linearTilingFeatures) == 0 && (properties.optimalTilingFeatures == 0))
-        {
-            char const str[] = "vkCreateImage parameter, VkFormat pCreateInfo->format, contains unsupported format";
-            // TODO: Verify against Valid Use section of spec. Generally if something yield an undefined result, it's invalid
-            skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, IMAGE_FORMAT_UNSUPPORTED, "IMAGE", str);
+        if ((properties.linearTilingFeatures) == 0 &&
+            (properties.optimalTilingFeatures == 0)) {
+            char const str[] = "vkCreateImage parameter, VkFormat "
+                               "pCreateInfo->format, contains unsupported "
+                               "format";
+            // TODO: Verify against Valid Use section of spec. Generally if
+            // something yield an undefined result, it's invalid
+            skipCall |=
+                log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT,
+                        (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
+                        IMAGE_FORMAT_UNSUPPORTED, "IMAGE", str);
         }
     }
 
-    // Internal call to get format info.  Still goes through layers, could potentially go directly to ICD.
-    phy_dev_data->instance_dispatch_table->GetPhysicalDeviceImageFormatProperties(
-                       physicalDevice, pCreateInfo->format, pCreateInfo->imageType, pCreateInfo->tiling,
-                       pCreateInfo->usage, pCreateInfo->flags, &ImageFormatProperties);
+    // Internal call to get format info.  Still goes through layers, could
+    // potentially go directly to ICD.
+    phy_dev_data->instance_dispatch_table
+        ->GetPhysicalDeviceImageFormatProperties(
+            physicalDevice, pCreateInfo->format, pCreateInfo->imageType,
+            pCreateInfo->tiling, pCreateInfo->usage, pCreateInfo->flags,
+            &ImageFormatProperties);
 
-    VkDeviceSize imageGranularity = device_data->physicalDeviceProperties.limits.bufferImageGranularity;
+    VkDeviceSize imageGranularity =
+        device_data->physicalDeviceProperties.limits.bufferImageGranularity;
     imageGranularity = imageGranularity == 1 ? 0 : imageGranularity;
 
-    if ((pCreateInfo->extent.depth  > ImageFormatProperties.maxExtent.depth)  ||
-        (pCreateInfo->extent.width  > ImageFormatProperties.maxExtent.width)  ||
+    if ((pCreateInfo->extent.depth > ImageFormatProperties.maxExtent.depth) ||
+        (pCreateInfo->extent.width > ImageFormatProperties.maxExtent.width) ||
         (pCreateInfo->extent.height > ImageFormatProperties.maxExtent.height)) {
-        skipCall |= log_msg(phy_dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, (uint64_t)pImage, __LINE__,
-                        IMAGE_INVALID_FORMAT_LIMITS_VIOLATION, "Image",
-                        "CreateImage extents exceed allowable limits for format: "
-                        "Width = %d Height = %d Depth = %d:  Limits for Width = %d Height = %d Depth = %d for format %s.",
-                        pCreateInfo->extent.width, pCreateInfo->extent.height, pCreateInfo->extent.depth,
-                        ImageFormatProperties.maxExtent.width, ImageFormatProperties.maxExtent.height, ImageFormatProperties.maxExtent.depth,
-                        string_VkFormat(pCreateInfo->format));
-
+        skipCall |= log_msg(
+            phy_dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+            VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, (uint64_t)pImage, __LINE__,
+            IMAGE_INVALID_FORMAT_LIMITS_VIOLATION, "Image",
+            "CreateImage extents exceed allowable limits for format: "
+            "Width = %d Height = %d Depth = %d:  Limits for Width = %d Height "
+            "= %d Depth = %d for format %s.",
+            pCreateInfo->extent.width, pCreateInfo->extent.height,
+            pCreateInfo->extent.depth, ImageFormatProperties.maxExtent.width,
+            ImageFormatProperties.maxExtent.height,
+            ImageFormatProperties.maxExtent.depth,
+            string_VkFormat(pCreateInfo->format));
     }
 
-    uint64_t totalSize = ((uint64_t)pCreateInfo->extent.width               *
-                          (uint64_t)pCreateInfo->extent.height              *
-                          (uint64_t)pCreateInfo->extent.depth               *
-                          (uint64_t)pCreateInfo->arrayLayers                *
-                          (uint64_t)pCreateInfo->samples                    *
-                          (uint64_t)vk_format_get_size(pCreateInfo->format) +
-                          (uint64_t)imageGranularity ) & ~(uint64_t)imageGranularity;
+    uint64_t totalSize =
+        ((uint64_t)pCreateInfo->extent.width *
+             (uint64_t)pCreateInfo->extent.height *
+             (uint64_t)pCreateInfo->extent.depth *
+             (uint64_t)pCreateInfo->arrayLayers *
+             (uint64_t)pCreateInfo->samples *
+             (uint64_t)vk_format_get_size(pCreateInfo->format) +
+         (uint64_t)imageGranularity) &
+        ~(uint64_t)imageGranularity;
 
     if (totalSize > ImageFormatProperties.maxResourceSize) {
-        skipCall |= log_msg(phy_dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, (uint64_t)pImage, __LINE__,
-                        IMAGE_INVALID_FORMAT_LIMITS_VIOLATION, "Image",
-                        "CreateImage resource size exceeds allowable maximum "
-                        "Image resource size = %#" PRIxLEAST64 ", maximum resource size = %#" PRIxLEAST64 " ",
-                        totalSize, ImageFormatProperties.maxResourceSize);
+        skipCall |=
+            log_msg(phy_dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, (uint64_t)pImage,
+                    __LINE__, IMAGE_INVALID_FORMAT_LIMITS_VIOLATION, "Image",
+                    "CreateImage resource size exceeds allowable maximum "
+                    "Image resource size = %#" PRIxLEAST64
+                    ", maximum resource size = %#" PRIxLEAST64 " ",
+                    totalSize, ImageFormatProperties.maxResourceSize);
     }
 
     if (pCreateInfo->mipLevels > ImageFormatProperties.maxMipLevels) {
-        skipCall |= log_msg(phy_dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, (uint64_t)pImage, __LINE__,
-                        IMAGE_INVALID_FORMAT_LIMITS_VIOLATION, "Image",
-                        "CreateImage mipLevels=%d exceeds allowable maximum supported by format of %d",
-                        pCreateInfo->mipLevels, ImageFormatProperties.maxMipLevels);
+        skipCall |=
+            log_msg(phy_dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, (uint64_t)pImage,
+                    __LINE__, IMAGE_INVALID_FORMAT_LIMITS_VIOLATION, "Image",
+                    "CreateImage mipLevels=%d exceeds allowable maximum "
+                    "supported by format of %d",
+                    pCreateInfo->mipLevels, ImageFormatProperties.maxMipLevels);
     }
 
     if (pCreateInfo->arrayLayers > ImageFormatProperties.maxArrayLayers) {
-        skipCall |= log_msg(phy_dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, (uint64_t)pImage, __LINE__,
-                        IMAGE_INVALID_FORMAT_LIMITS_VIOLATION, "Image",
-                        "CreateImage arrayLayers=%d exceeds allowable maximum supported by format of %d",
-                        pCreateInfo->arrayLayers, ImageFormatProperties.maxArrayLayers);
+        skipCall |= log_msg(
+            phy_dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+            VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, (uint64_t)pImage, __LINE__,
+            IMAGE_INVALID_FORMAT_LIMITS_VIOLATION, "Image",
+            "CreateImage arrayLayers=%d exceeds allowable maximum supported by "
+            "format of %d",
+            pCreateInfo->arrayLayers, ImageFormatProperties.maxArrayLayers);
     }
 
     if ((pCreateInfo->samples & ImageFormatProperties.sampleCounts) == 0) {
-        skipCall |= log_msg(phy_dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, (uint64_t)pImage, __LINE__,
-                        IMAGE_INVALID_FORMAT_LIMITS_VIOLATION, "Image",
-                        "CreateImage samples %s is not supported by format 0x%.8X",
-                        string_VkSampleCountFlagBits(pCreateInfo->samples), ImageFormatProperties.sampleCounts);
+        skipCall |=
+            log_msg(phy_dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, (uint64_t)pImage,
+                    __LINE__, IMAGE_INVALID_FORMAT_LIMITS_VIOLATION, "Image",
+                    "CreateImage samples %s is not supported by format 0x%.8X",
+                    string_VkSampleCountFlagBits(pCreateInfo->samples),
+                    ImageFormatProperties.sampleCounts);
     }
 
     if (VK_FALSE == skipCall) {
-        result = device_data->device_dispatch_table->CreateImage(device, pCreateInfo, pAllocator, pImage);
+        result = device_data->device_dispatch_table->CreateImage(
+            device, pCreateInfo, pAllocator, pImage);
     }
     if (result == VK_SUCCESS) {
         device_data->imageMap[*pImage] = IMAGE_STATE(pCreateInfo);
@@ -430,213 +462,350 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(VkDevice device, co
     return result;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
-{
-    layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkDestroyImage(VkDevice device, VkImage image,
+                   const VkAllocationCallbacks *pAllocator) {
+    layer_data *device_data =
+        get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     device_data->imageMap.erase(image);
     device_data->device_dispatch_table->DestroyImage(device, image, pAllocator);
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
-{
-    layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkCreateRenderPass(VkDevice device,
+                       const VkRenderPassCreateInfo *pCreateInfo,
+                       const VkAllocationCallbacks *pAllocator,
+                       VkRenderPass *pRenderPass) {
+    layer_data *my_data =
+        get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     VkBool32 skipCall = VK_FALSE;
-    for(uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i)
-    {
-        if(pCreateInfo->pAttachments[i].format != VK_FORMAT_UNDEFINED)
-        {
+    for (uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i) {
+        if (pCreateInfo->pAttachments[i].format != VK_FORMAT_UNDEFINED) {
             VkFormatProperties properties;
-            get_my_data_ptr(get_dispatch_key(my_data->physicalDevice), layer_data_map)->instance_dispatch_table->GetPhysicalDeviceFormatProperties(
-                    my_data->physicalDevice, pCreateInfo->pAttachments[i].format, &properties);
-
-            if((properties.linearTilingFeatures) == 0 && (properties.optimalTilingFeatures == 0))
-            {
+            get_my_data_ptr(get_dispatch_key(my_data->physicalDevice),
+                            layer_data_map)
+                ->instance_dispatch_table->GetPhysicalDeviceFormatProperties(
+                    my_data->physicalDevice,
+                    pCreateInfo->pAttachments[i].format, &properties);
+
+            if ((properties.linearTilingFeatures) == 0 &&
+                (properties.optimalTilingFeatures == 0)) {
                 std::stringstream ss;
-                ss << "vkCreateRenderPass parameter, VkFormat in pCreateInfo->pAttachments[" << i << "], contains unsupported format";
-                // TODO: Verify against Valid Use section of spec. Generally if something yield an undefined result, it's invalid
-                skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, IMAGE_FORMAT_UNSUPPORTED, "IMAGE", "%s", ss.str().c_str());
+                ss << "vkCreateRenderPass parameter, VkFormat in "
+                      "pCreateInfo->pAttachments[" << i
+                   << "], contains unsupported format";
+                // TODO: Verify against Valid Use section of spec. Generally if
+                // something yield an undefined result, it's invalid
+                skipCall |= log_msg(
+                    my_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
+                    IMAGE_FORMAT_UNSUPPORTED, "IMAGE", "%s", ss.str().c_str());
             }
         }
     }
 
-    for(uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i)
-    {
-        if(!validate_VkImageLayoutKHR(pCreateInfo->pAttachments[i].initialLayout) ||
-           !validate_VkImageLayoutKHR(pCreateInfo->pAttachments[i].finalLayout))
-        {
+    for (uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i) {
+        if (!validate_VkImageLayoutKHR(
+                pCreateInfo->pAttachments[i].initialLayout) ||
+            !validate_VkImageLayoutKHR(
+                pCreateInfo->pAttachments[i].finalLayout)) {
             std::stringstream ss;
-            ss << "vkCreateRenderPass parameter, VkImageLayout in pCreateInfo->pAttachments[" << i << "], is unrecognized";
-            // TODO: Verify against Valid Use section of spec. Generally if something yield an undefined result, it's invalid
-            skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, IMAGE_RENDERPASS_INVALID_ATTACHMENT, "IMAGE", "%s", ss.str().c_str());
+            ss << "vkCreateRenderPass parameter, VkImageLayout in "
+                  "pCreateInfo->pAttachments[" << i << "], is unrecognized";
+            // TODO: Verify against Valid Use section of spec. Generally if
+            // something yield an undefined result, it's invalid
+            skipCall |=
+                log_msg(my_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT,
+                        (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
+                        IMAGE_RENDERPASS_INVALID_ATTACHMENT, "IMAGE", "%s",
+                        ss.str().c_str());
         }
     }
 
-    for(uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i)
-    {
-        if(!validate_VkAttachmentLoadOp(pCreateInfo->pAttachments[i].loadOp))
-        {
+    for (uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i) {
+        if (!validate_VkAttachmentLoadOp(pCreateInfo->pAttachments[i].loadOp)) {
             std::stringstream ss;
-            ss << "vkCreateRenderPass parameter, VkAttachmentLoadOp in pCreateInfo->pAttachments[" << i << "], is unrecognized";
-            // TODO: Verify against Valid Use section of spec. Generally if something yield an undefined result, it's invalid
-            skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, IMAGE_RENDERPASS_INVALID_ATTACHMENT, "IMAGE", "%s", ss.str().c_str());
+            ss << "vkCreateRenderPass parameter, VkAttachmentLoadOp in "
+                  "pCreateInfo->pAttachments[" << i << "], is unrecognized";
+            // TODO: Verify against Valid Use section of spec. Generally if
+            // something yield an undefined result, it's invalid
+            skipCall |=
+                log_msg(my_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT,
+                        (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
+                        IMAGE_RENDERPASS_INVALID_ATTACHMENT, "IMAGE", "%s",
+                        ss.str().c_str());
         }
     }
 
-    for(uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i)
-    {
-        if(!validate_VkAttachmentStoreOp(pCreateInfo->pAttachments[i].storeOp))
-        {
+    for (uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i) {
+        if (!validate_VkAttachmentStoreOp(
+                pCreateInfo->pAttachments[i].storeOp)) {
             std::stringstream ss;
-            ss << "vkCreateRenderPass parameter, VkAttachmentStoreOp in pCreateInfo->pAttachments[" << i << "], is unrecognized";
-            // TODO: Verify against Valid Use section of spec. Generally if something yield an undefined result, it's invalid
-            skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, IMAGE_RENDERPASS_INVALID_ATTACHMENT, "IMAGE", "%s", ss.str().c_str());
+            ss << "vkCreateRenderPass parameter, VkAttachmentStoreOp in "
+                  "pCreateInfo->pAttachments[" << i << "], is unrecognized";
+            // TODO: Verify against Valid Use section of spec. Generally if
+            // something yield an undefined result, it's invalid
+            skipCall |=
+                log_msg(my_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT,
+                        (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
+                        IMAGE_RENDERPASS_INVALID_ATTACHMENT, "IMAGE", "%s",
+                        ss.str().c_str());
         }
     }
 
     // Any depth buffers specified as attachments?
     bool depthFormatPresent = VK_FALSE;
-    for (uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i)
-    {
-        depthFormatPresent |= is_depth_format(pCreateInfo->pAttachments[i].format);
+    for (uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i) {
+        depthFormatPresent |=
+            is_depth_format(pCreateInfo->pAttachments[i].format);
     }
 
     if (depthFormatPresent == VK_FALSE) {
-        // No depth attachment is present, validate that subpasses set depthStencilAttachment to VK_ATTACHMENT_UNUSED;
+        // No depth attachment is present, validate that subpasses set
+        // depthStencilAttachment to VK_ATTACHMENT_UNUSED;
         for (uint32_t i = 0; i < pCreateInfo->subpassCount; i++) {
             if (pCreateInfo->pSubpasses[i].pDepthStencilAttachment &&
-                pCreateInfo->pSubpasses[i].pDepthStencilAttachment->attachment != VK_ATTACHMENT_UNUSED) {
+                pCreateInfo->pSubpasses[i]
+                        .pDepthStencilAttachment->attachment !=
+                    VK_ATTACHMENT_UNUSED) {
                 std::stringstream ss;
-                ss << "vkCreateRenderPass has no depth/stencil attachment, yet subpass[" << i << "] has VkSubpassDescription::depthStencilAttachment value that is not VK_ATTACHMENT_UNUSED";
-                skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, IMAGE_RENDERPASS_INVALID_DS_ATTACHMENT, "IMAGE", "%s", ss.str().c_str());
+                ss << "vkCreateRenderPass has no depth/stencil attachment, yet "
+                      "subpass[" << i
+                   << "] has VkSubpassDescription::depthStencilAttachment "
+                      "value that is not VK_ATTACHMENT_UNUSED";
+                skipCall |=
+                    log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                            (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
+                            IMAGE_RENDERPASS_INVALID_DS_ATTACHMENT, "IMAGE",
+                            "%s", ss.str().c_str());
             }
         }
     }
     if (skipCall)
         return VK_ERROR_VALIDATION_FAILED_EXT;
 
-    VkResult result = my_data->device_dispatch_table->CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
+    VkResult result = my_data->device_dispatch_table->CreateRenderPass(
+        device, pCreateInfo, pAllocator, pRenderPass);
 
     return result;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView)
-{
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
+    vkCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo,
+                      const VkAllocationCallbacks *pAllocator,
+                      VkImageView *pView) {
     VkBool32 skipCall = VK_FALSE;
-    layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+    layer_data *device_data =
+        get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     auto imageEntry = device_data->imageMap.find(pCreateInfo->image);
     if (imageEntry != device_data->imageMap.end()) {
-        if (pCreateInfo->subresourceRange.baseMipLevel >= imageEntry->second.mipLevels) {
+        if (pCreateInfo->subresourceRange.baseMipLevel >=
+            imageEntry->second.mipLevels) {
             std::stringstream ss;
-            ss << "vkCreateImageView called with baseMipLevel " << pCreateInfo->subresourceRange.baseMipLevel
-               << " for image " << pCreateInfo->image << " that only has " << imageEntry->second.mipLevels << " mip levels.";
-            skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, IMAGE_VIEW_CREATE_ERROR, "IMAGE", "%s", ss.str().c_str());
+            ss << "vkCreateImageView called with baseMipLevel "
+               << pCreateInfo->subresourceRange.baseMipLevel << " for image "
+               << pCreateInfo->image << " that only has "
+               << imageEntry->second.mipLevels << " mip levels.";
+            skipCall |= log_msg(
+                device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
+                IMAGE_VIEW_CREATE_ERROR, "IMAGE", "%s", ss.str().c_str());
         }
-        if (pCreateInfo->subresourceRange.baseArrayLayer >= imageEntry->second.arraySize) {
+        if (pCreateInfo->subresourceRange.baseArrayLayer >=
+            imageEntry->second.arraySize) {
             std::stringstream ss;
-            ss << "vkCreateImageView called with baseArrayLayer " << pCreateInfo->subresourceRange.baseArrayLayer << " for image "
-               << pCreateInfo->image << " that only has " << imageEntry->second.arraySize << " mip levels.";
-            skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, IMAGE_VIEW_CREATE_ERROR, "IMAGE", "%s", ss.str().c_str());
+            ss << "vkCreateImageView called with baseArrayLayer "
+               << pCreateInfo->subresourceRange.baseArrayLayer << " for image "
+               << pCreateInfo->image << " that only has "
+               << imageEntry->second.arraySize << " mip levels.";
+            skipCall |= log_msg(
+                device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
+                IMAGE_VIEW_CREATE_ERROR, "IMAGE", "%s", ss.str().c_str());
         }
         if (!pCreateInfo->subresourceRange.levelCount) {
             std::stringstream ss;
-            ss << "vkCreateImageView called with 0 in pCreateInfo->subresourceRange.levelCount.";
-            skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, IMAGE_VIEW_CREATE_ERROR, "IMAGE", "%s", ss.str().c_str());
+            ss << "vkCreateImageView called with 0 in "
+                  "pCreateInfo->subresourceRange.levelCount.";
+            skipCall |= log_msg(
+                device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
+                IMAGE_VIEW_CREATE_ERROR, "IMAGE", "%s", ss.str().c_str());
         }
         if (!pCreateInfo->subresourceRange.layerCount) {
             std::stringstream ss;
-            ss << "vkCreateImageView called with 0 in pCreateInfo->subresourceRange.layerCount.";
-            skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, IMAGE_VIEW_CREATE_ERROR, "IMAGE", "%s", ss.str().c_str());
+            ss << "vkCreateImageView called with 0 in "
+                  "pCreateInfo->subresourceRange.layerCount.";
+            skipCall |= log_msg(
+                device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
+                IMAGE_VIEW_CREATE_ERROR, "IMAGE", "%s", ss.str().c_str());
         }
 
-        VkImageCreateFlags imageFlags  = imageEntry->second.flags;
-        VkFormat           imageFormat = imageEntry->second.format;
-        VkFormat           ivciFormat  = pCreateInfo->format;
-        VkImageAspectFlags aspectMask  = pCreateInfo->subresourceRange.aspectMask;
+        VkImageCreateFlags imageFlags = imageEntry->second.flags;
+        VkFormat imageFormat = imageEntry->second.format;
+        VkFormat ivciFormat = pCreateInfo->format;
+        VkImageAspectFlags aspectMask =
+            pCreateInfo->subresourceRange.aspectMask;
 
         // Validate VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT state
         if (imageFlags & VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT) {
-            // Format MUST be compatible (in the same format compatibility class) as the format the image was created with
-            if (vk_format_get_compatibility_class(imageFormat) != vk_format_get_compatibility_class(ivciFormat)) {
+            // Format MUST be compatible (in the same format compatibility
+            // class) as the format the image was created with
+            if (vk_format_get_compatibility_class(imageFormat) !=
+                vk_format_get_compatibility_class(ivciFormat)) {
                 std::stringstream ss;
-                ss << "vkCreateImageView(): ImageView format " << string_VkFormat(ivciFormat) << " is not in the same format compatibility class as image ("    <<
-                    (uint64_t)pCreateInfo->image << ")  format " << string_VkFormat(imageFormat) << ".  Images created with the VK_IMAGE_CREATE_MUTABLE_FORMAT BIT " <<
-                    "can support ImageViews with differing formats but they must be in the same compatibility class.";
-                skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
+                ss << "vkCreateImageView(): ImageView format "
+                   << string_VkFormat(ivciFormat)
+                   << " is not in the same format compatibility class as image "
+                      "(" << (uint64_t)pCreateInfo->image << ")  format "
+                   << string_VkFormat(imageFormat)
+                   << ".  Images created with the "
+                      "VK_IMAGE_CREATE_MUTABLE_FORMAT BIT "
+                   << "can support ImageViews with differing formats but they "
+                      "must be in the same compatibility class.";
+                skipCall |= log_msg(
+                    device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
                     IMAGE_VIEW_CREATE_ERROR, "IMAGE", "%s", ss.str().c_str());
             }
         } else {
             // Format MUST be IDENTICAL to the format the image was created with
             if (imageFormat != ivciFormat) {
                 std::stringstream ss;
-                ss << "vkCreateImageView() format " << string_VkFormat(ivciFormat) << " differs from image " << (uint64_t)pCreateInfo->image << " format " <<
-                    string_VkFormat(imageFormat) << ".  Formats MUST be IDENTICAL unless VK_IMAGE_CREATE_MUTABLE_FORMAT BIT was set on image creation.";
-                skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
+                ss << "vkCreateImageView() format "
+                   << string_VkFormat(ivciFormat) << " differs from image "
+                   << (uint64_t)pCreateInfo->image << " format "
+                   << string_VkFormat(imageFormat)
+                   << ".  Formats MUST be IDENTICAL unless "
+                      "VK_IMAGE_CREATE_MUTABLE_FORMAT BIT was set on image "
+                      "creation.";
+                skipCall |= log_msg(
+                    device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
                     IMAGE_VIEW_CREATE_ERROR, "IMAGE", "%s", ss.str().c_str());
             }
         }
 
-        // Validate correct image aspect bits for desired formats and format consistency
+        // Validate correct image aspect bits for desired formats and format
+        // consistency
         if (vk_format_is_color(imageFormat)) {
-            if ((aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) != VK_IMAGE_ASPECT_COLOR_BIT) {
+            if ((aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) !=
+                VK_IMAGE_ASPECT_COLOR_BIT) {
                 std::stringstream ss;
-                ss << "vkCreateImageView: Color image formats must have the VK_IMAGE_ASPECT_COLOR_BIT set";
-                skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
-                                   (uint64_t)pCreateInfo->image, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", ss.str().c_str());
+                ss << "vkCreateImageView: Color image formats must have the "
+                      "VK_IMAGE_ASPECT_COLOR_BIT set";
+                skipCall |= log_msg(device_data->report_data,
+                                    VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                                    VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
+                                    (uint64_t)pCreateInfo->image, __LINE__,
+                                    IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s",
+                                    ss.str().c_str());
             }
             if ((aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) != aspectMask) {
                 std::stringstream ss;
-                ss << "vkCreateImageView: Color image formats must have ONLY the VK_IMAGE_ASPECT_COLOR_BIT set";
-                skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
-                                   (uint64_t)pCreateInfo->image, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", ss.str().c_str());
+                ss << "vkCreateImageView: Color image formats must have ONLY "
+                      "the VK_IMAGE_ASPECT_COLOR_BIT set";
+                skipCall |= log_msg(device_data->report_data,
+                                    VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                                    VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
+                                    (uint64_t)pCreateInfo->image, __LINE__,
+                                    IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s",
+                                    ss.str().c_str());
             }
             if (VK_FALSE == vk_format_is_color(ivciFormat)) {
                 std::stringstream ss;
-                ss << "vkCreateImageView: The image view's format can differ from the parent image's format, but both must be "
-                   << "color formats.  ImageFormat is " << string_VkFormat(imageFormat) << " ImageViewFormat is " << string_VkFormat(ivciFormat);
-                skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
-                                   (uint64_t)pCreateInfo->image, __LINE__, IMAGE_INVALID_FORMAT, "IMAGE", "%s", ss.str().c_str());
+                ss << "vkCreateImageView: The image view's format can differ "
+                      "from the parent image's format, but both must be "
+                   << "color formats.  ImageFormat is "
+                   << string_VkFormat(imageFormat) << " ImageViewFormat is "
+                   << string_VkFormat(ivciFormat);
+                skipCall |= log_msg(
+                    device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
+                    (uint64_t)pCreateInfo->image, __LINE__,
+                    IMAGE_INVALID_FORMAT, "IMAGE", "%s", ss.str().c_str());
             }
-            // TODO:  Uncompressed formats are compatible if they occupy they same number of bits per pixel.
-            //        Compressed formats are compatible if the only difference between them is the numerical type of
-            //        the uncompressed pixels (e.g. signed vs. unsigned, or sRGB vs. UNORM encoding).
-        } else  if (vk_format_is_depth_and_stencil(imageFormat)) {
-            if ((aspectMask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) == 0) {
+            // TODO:  Uncompressed formats are compatible if they occupy they
+            // same number of bits per pixel.
+            //        Compressed formats are compatible if the only difference
+            //        between them is the numerical type of
+            //        the uncompressed pixels (e.g. signed vs. unsigned, or sRGB
+            //        vs. UNORM encoding).
+        } else if (vk_format_is_depth_and_stencil(imageFormat)) {
+            if ((aspectMask & (VK_IMAGE_ASPECT_DEPTH_BIT |
+                               VK_IMAGE_ASPECT_STENCIL_BIT)) == 0) {
                 std::stringstream ss;
-                ss << "vkCreateImageView: Depth/stencil image formats must have at least one of VK_IMAGE_ASPECT_DEPTH_BIT and VK_IMAGE_ASPECT_STENCIL_BIT set";
-                skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
-                                   (uint64_t)pCreateInfo->image, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", ss.str().c_str());
+                ss << "vkCreateImageView: Depth/stencil image formats must "
+                      "have at least one of VK_IMAGE_ASPECT_DEPTH_BIT and "
+                      "VK_IMAGE_ASPECT_STENCIL_BIT set";
+                skipCall |= log_msg(device_data->report_data,
+                                    VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                                    VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
+                                    (uint64_t)pCreateInfo->image, __LINE__,
+                                    IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s",
+                                    ss.str().c_str());
             }
-            if ((aspectMask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) != aspectMask) {
+            if ((aspectMask & (VK_IMAGE_ASPECT_DEPTH_BIT |
+                               VK_IMAGE_ASPECT_STENCIL_BIT)) != aspectMask) {
                 std::stringstream ss;
-                ss << "vkCreateImageView: Combination depth/stencil image formats can have only the VK_IMAGE_ASPECT_DEPTH_BIT and VK_IMAGE_ASPECT_STENCIL_BIT set";
-                skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
-                                   (uint64_t)pCreateInfo->image, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", ss.str().c_str());
+                ss << "vkCreateImageView: Combination depth/stencil image "
+                      "formats can have only the VK_IMAGE_ASPECT_DEPTH_BIT and "
+                      "VK_IMAGE_ASPECT_STENCIL_BIT set";
+                skipCall |= log_msg(device_data->report_data,
+                                    VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                                    VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
+                                    (uint64_t)pCreateInfo->image, __LINE__,
+                                    IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s",
+                                    ss.str().c_str());
             }
-        } else  if (vk_format_is_depth_only(imageFormat)) {
-            if ((aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) != VK_IMAGE_ASPECT_DEPTH_BIT) {
+        } else if (vk_format_is_depth_only(imageFormat)) {
+            if ((aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) !=
+                VK_IMAGE_ASPECT_DEPTH_BIT) {
                 std::stringstream ss;
-                ss << "vkCreateImageView: Depth-only image formats must have the VK_IMAGE_ASPECT_DEPTH_BIT set";
-                skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
-                                   (uint64_t)pCreateInfo->image, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", ss.str().c_str());
+                ss << "vkCreateImageView: Depth-only image formats must have "
+                      "the VK_IMAGE_ASPECT_DEPTH_BIT set";
+                skipCall |= log_msg(device_data->report_data,
+                                    VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                                    VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
+                                    (uint64_t)pCreateInfo->image, __LINE__,
+                                    IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s",
+                                    ss.str().c_str());
             }
             if ((aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) != aspectMask) {
                 std::stringstream ss;
-                ss << "vkCreateImageView: Depth-only image formats can have only the VK_IMAGE_ASPECT_DEPTH_BIT set";
-                skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
-                                   (uint64_t)pCreateInfo->image, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", ss.str().c_str());
+                ss << "vkCreateImageView: Depth-only image formats can have "
+                      "only the VK_IMAGE_ASPECT_DEPTH_BIT set";
+                skipCall |= log_msg(device_data->report_data,
+                                    VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                                    VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
+                                    (uint64_t)pCreateInfo->image, __LINE__,
+                                    IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s",
+                                    ss.str().c_str());
             }
-        } else  if (vk_format_is_stencil_only(imageFormat)) {
-            if ((aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) != VK_IMAGE_ASPECT_STENCIL_BIT) {
+        } else if (vk_format_is_stencil_only(imageFormat)) {
+            if ((aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) !=
+                VK_IMAGE_ASPECT_STENCIL_BIT) {
                 std::stringstream ss;
-                ss << "vkCreateImageView: Stencil-only image formats must have the VK_IMAGE_ASPECT_STENCIL_BIT set";
-                skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
-                                   (uint64_t)pCreateInfo->image, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", ss.str().c_str());
+                ss << "vkCreateImageView: Stencil-only image formats must have "
+                      "the VK_IMAGE_ASPECT_STENCIL_BIT set";
+                skipCall |= log_msg(device_data->report_data,
+                                    VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                                    VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
+                                    (uint64_t)pCreateInfo->image, __LINE__,
+                                    IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s",
+                                    ss.str().c_str());
             }
             if ((aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) != aspectMask) {
                 std::stringstream ss;
-                ss << "vkCreateImageView: Stencil-only image formats can have only the VK_IMAGE_ASPECT_STENCIL_BIT set";
-                skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
-                                   (uint64_t)pCreateInfo->image, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", ss.str().c_str());
+                ss << "vkCreateImageView: Stencil-only image formats can have "
+                      "only the VK_IMAGE_ASPECT_STENCIL_BIT set";
+                skipCall |= log_msg(device_data->report_data,
+                                    VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                                    VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
+                                    (uint64_t)pCreateInfo->image, __LINE__,
+                                    IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s",
+                                    ss.str().c_str());
             }
         }
     }
@@ -645,74 +814,81 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView(VkDevice device
         return VK_ERROR_VALIDATION_FAILED_EXT;
     }
 
-    VkResult result = device_data->device_dispatch_table->CreateImageView(device, pCreateInfo, pAllocator, pView);
+    VkResult result = device_data->device_dispatch_table->CreateImageView(
+        device, pCreateInfo, pAllocator, pView);
     return result;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage(
-    VkCommandBuffer                commandBuffer,
-    VkImage                        image,
-    VkImageLayout                  imageLayout,
-    const VkClearColorValue       *pColor,
-    uint32_t                       rangeCount,
-    const VkImageSubresourceRange *pRanges)
-{
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image,
+                         VkImageLayout imageLayout,
+                         const VkClearColorValue *pColor, uint32_t rangeCount,
+                         const VkImageSubresourceRange *pRanges) {
     VkBool32 skipCall = VK_FALSE;
-    layer_data *device_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    layer_data *device_data =
+        get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     // For each range, image aspect must be color only
     for (uint32_t i = 0; i < rangeCount; i++) {
         if (pRanges[i].aspectMask != VK_IMAGE_ASPECT_COLOR_BIT) {
-            char const str[] = "vkCmdClearColorImage aspectMasks for all subresource ranges must be set to VK_IMAGE_ASPECT_COLOR_BIT";
-            skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
-                                (uint64_t)commandBuffer, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str);
+            char const str[] = "vkCmdClearColorImage aspectMasks for all "
+                               "subresource ranges must be set to "
+                               "VK_IMAGE_ASPECT_COLOR_BIT";
+            skipCall |=
+                log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+                        (uint64_t)commandBuffer, __LINE__,
+                        IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str);
         }
     }
 
     if (VK_FALSE == skipCall) {
-        device_data->device_dispatch_table->CmdClearColorImage(commandBuffer, image, imageLayout,
-                                                               pColor, rangeCount, pRanges);
+        device_data->device_dispatch_table->CmdClearColorImage(
+            commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
     }
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage(
-    VkCommandBuffer                 commandBuffer,
-    VkImage                         image,
-    VkImageLayout                   imageLayout,
-    const VkClearDepthStencilValue *pDepthStencil,
-    uint32_t                        rangeCount,
-    const VkImageSubresourceRange  *pRanges)
-{
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image,
+                                VkImageLayout imageLayout,
+                                const VkClearDepthStencilValue *pDepthStencil,
+                                uint32_t rangeCount,
+                                const VkImageSubresourceRange *pRanges) {
     VkBool32 skipCall = VK_FALSE;
-    layer_data *device_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    layer_data *device_data =
+        get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     // For each range, Image aspect must be depth or stencil or both
     for (uint32_t i = 0; i < rangeCount; i++) {
-        if (((pRanges[i].aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT)   != VK_IMAGE_ASPECT_DEPTH_BIT) &&
-            ((pRanges[i].aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) != VK_IMAGE_ASPECT_STENCIL_BIT))
-        {
-            char const str[] = "vkCmdClearDepthStencilImage aspectMasks for all subresource ranges must be "
-                               "set to VK_IMAGE_ASPECT_DEPTH_BIT and/or VK_IMAGE_ASPECT_STENCIL_BIT";
-            skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
-                                (uint64_t)commandBuffer, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str);
+        if (((pRanges[i].aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) !=
+             VK_IMAGE_ASPECT_DEPTH_BIT) &&
+            ((pRanges[i].aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) !=
+             VK_IMAGE_ASPECT_STENCIL_BIT)) {
+            char const str[] = "vkCmdClearDepthStencilImage aspectMasks for "
+                               "all subresource ranges must be "
+                               "set to VK_IMAGE_ASPECT_DEPTH_BIT and/or "
+                               "VK_IMAGE_ASPECT_STENCIL_BIT";
+            skipCall |=
+                log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+                        (uint64_t)commandBuffer, __LINE__,
+                        IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str);
         }
     }
 
     if (VK_FALSE == skipCall) {
-        device_data->device_dispatch_table->CmdClearDepthStencilImage(commandBuffer,
-            image, imageLayout, pDepthStencil, rangeCount, pRanges);
+        device_data->device_dispatch_table->CmdClearDepthStencilImage(
+            commandBuffer, image, imageLayout, pDepthStencil, rangeCount,
+            pRanges);
     }
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage(
-    VkCommandBuffer    commandBuffer,
-    VkImage            srcImage,
-    VkImageLayout      srcImageLayout,
-    VkImage            dstImage,
-    VkImageLayout      dstImageLayout,
-    uint32_t           regionCount,
-    const VkImageCopy *pRegions)
-{
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage,
+                   VkImageLayout srcImageLayout, VkImage dstImage,
+                   VkImageLayout dstImageLayout, uint32_t regionCount,
+                   const VkImageCopy *pRegions) {
     VkBool32 skipCall = VK_FALSE;
-    layer_data *device_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    layer_data *device_data =
+        get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     auto srcImageEntry = device_data->imageMap.find(srcImage);
     auto dstImageEntry = device_data->imageMap.find(dstImage);
 
@@ -721,201 +897,262 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage(
     // For each region, src aspect mask must match dest aspect mask
     // For each region, color aspects cannot be mixed with depth/stencil aspects
     for (uint32_t i = 0; i < regionCount; i++) {
-        if(pRegions[i].srcSubresource.layerCount == 0)
-        {
-            char const str[] = "vkCmdCopyImage: number of layers in source subresource is zero";
+        if (pRegions[i].srcSubresource.layerCount == 0) {
+            char const str[] = "vkCmdCopyImage: number of layers in source "
+                               "subresource is zero";
             // TODO: Verify against Valid Use section of spec
-            skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
-                                (uint64_t)commandBuffer, __LINE__, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
+            skipCall |=
+                log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT,
+                        VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+                        (uint64_t)commandBuffer, __LINE__,
+                        IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
         }
 
-        if(pRegions[i].dstSubresource.layerCount == 0)
-        {
-            char const str[] = "vkCmdCopyImage: number of layers in destination subresource is zero";
+        if (pRegions[i].dstSubresource.layerCount == 0) {
+            char const str[] = "vkCmdCopyImage: number of layers in "
+                               "destination subresource is zero";
             // TODO: Verify against Valid Use section of spec
-            skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
-                                (uint64_t)commandBuffer, __LINE__, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
+            skipCall |=
+                log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT,
+                        VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+                        (uint64_t)commandBuffer, __LINE__,
+                        IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
         }
 
-        if(pRegions[i].srcSubresource.layerCount != pRegions[i].dstSubresource.layerCount)
-        {
-            char const str[] = "vkCmdCopyImage: number of layers in source and destination subresources must match";
-            skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
-                                (uint64_t)commandBuffer, __LINE__, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
+        if (pRegions[i].srcSubresource.layerCount !=
+            pRegions[i].dstSubresource.layerCount) {
+            char const str[] = "vkCmdCopyImage: number of layers in source and "
+                               "destination subresources must match";
+            skipCall |=
+                log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+                        (uint64_t)commandBuffer, __LINE__,
+                        IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
         }
 
-        if (pRegions[i].srcSubresource.aspectMask != pRegions[i].dstSubresource.aspectMask) {
-            char const str[] = "vkCmdCopyImage: Src and dest aspectMasks for each region must match";
-            skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
-                                (uint64_t)commandBuffer, __LINE__, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
+        if (pRegions[i].srcSubresource.aspectMask !=
+            pRegions[i].dstSubresource.aspectMask) {
+            char const str[] = "vkCmdCopyImage: Src and dest aspectMasks for "
+                               "each region must match";
+            skipCall |=
+                log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+                        (uint64_t)commandBuffer, __LINE__,
+                        IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
         }
-        if ((pRegions[i].srcSubresource.aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) &&
-            (pRegions[i].srcSubresource.aspectMask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT))) {
-            char const str[] = "vkCmdCopyImage aspectMask cannot specify both COLOR and DEPTH/STENCIL aspects";
-            skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
-                                (uint64_t)commandBuffer, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str);
+        if ((pRegions[i].srcSubresource.aspectMask &
+             VK_IMAGE_ASPECT_COLOR_BIT) &&
+            (pRegions[i].srcSubresource.aspectMask &
+             (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT))) {
+            char const str[] = "vkCmdCopyImage aspectMask cannot specify both "
+                               "COLOR and DEPTH/STENCIL aspects";
+            skipCall |=
+                log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+                        (uint64_t)commandBuffer, __LINE__,
+                        IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str);
         }
     }
 
-    if ((srcImageEntry != device_data->imageMap.end())
-    && (dstImageEntry != device_data->imageMap.end())) {
-        if (srcImageEntry->second.imageType != dstImageEntry->second.imageType) {
-            char const str[] = "vkCmdCopyImage called with unmatched source and dest image types.";
-            skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
-                                (uint64_t)commandBuffer, __LINE__, IMAGE_MISMATCHED_IMAGE_TYPE, "IMAGE", str);
+    if ((srcImageEntry != device_data->imageMap.end()) &&
+        (dstImageEntry != device_data->imageMap.end())) {
+        if (srcImageEntry->second.imageType !=
+            dstImageEntry->second.imageType) {
+            char const str[] = "vkCmdCopyImage called with unmatched source "
+                               "and dest image types.";
+            skipCall |=
+                log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+                        (uint64_t)commandBuffer, __LINE__,
+                        IMAGE_MISMATCHED_IMAGE_TYPE, "IMAGE", str);
         }
         // Check that format is same size or exact stencil/depth
         if (is_depth_format(srcImageEntry->second.format)) {
             if (srcImageEntry->second.format != dstImageEntry->second.format) {
-                char const str[] = "vkCmdCopyImage called with unmatched source and dest image depth/stencil formats.";
-                skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
-                                    (uint64_t)commandBuffer, __LINE__, IMAGE_MISMATCHED_IMAGE_FORMAT, "IMAGE", str);
+                char const str[] = "vkCmdCopyImage called with unmatched "
+                                   "source and dest image depth/stencil "
+                                   "formats.";
+                skipCall |= log_msg(
+                    device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+                    (uint64_t)commandBuffer, __LINE__,
+                    IMAGE_MISMATCHED_IMAGE_FORMAT, "IMAGE", str);
             }
         } else {
             size_t srcSize = vk_format_get_size(srcImageEntry->second.format);
             size_t destSize = vk_format_get_size(dstImageEntry->second.format);
             if (srcSize != destSize) {
-                char const str[] = "vkCmdCopyImage called with unmatched source and dest image format sizes.";
-                skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
-                                    (uint64_t)commandBuffer, __LINE__, IMAGE_MISMATCHED_IMAGE_FORMAT, "IMAGE", str);
+                char const str[] = "vkCmdCopyImage called with unmatched "
+                                   "source and dest image format sizes.";
+                skipCall |= log_msg(
+                    device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+                    (uint64_t)commandBuffer, __LINE__,
+                    IMAGE_MISMATCHED_IMAGE_FORMAT, "IMAGE", str);
             }
         }
     }
 
     if (VK_FALSE == skipCall) {
-        device_data->device_dispatch_table->CmdCopyImage(commandBuffer, srcImage,
-            srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
+        device_data->device_dispatch_table->CmdCopyImage(
+            commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout,
+            regionCount, pRegions);
     }
 }
 
-VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments(
-    VkCommandBuffer                             commandBuffer,
-    uint32_t                                    attachmentCount,
-    const VkClearAttachment*                    pAttachments,
-    uint32_t                                    rectCount,
-    const VkClearRect*                          pRects)
-{
+VKAPI_ATTR void VKAPI_CALL
+    vkCmdClearAttachments(VkCommandBuffer commandBuffer,
+                          uint32_t attachmentCount,
+                          const VkClearAttachment *pAttachments,
+                          uint32_t rectCount, const VkClearRect *pRects) {
     VkBool32 skipCall = VK_FALSE;
     VkImageAspectFlags aspectMask;
-    layer_data *device_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    layer_data *device_data =
+        get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     for (uint32_t i = 0; i < attachmentCount; i++) {
         aspectMask = pAttachments[i].aspectMask;
         if (aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) {
             if (aspectMask != VK_IMAGE_ASPECT_COLOR_BIT) {
-                // VK_IMAGE_ASPECT_COLOR_BIT is not the only bit set for this attachment
-                char const str[] = "vkCmdClearAttachments aspectMask [%d] must set only VK_IMAGE_ASPECT_COLOR_BIT of a color attachment.";
-                skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
-                                (uint64_t)commandBuffer, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str, i);
+                // VK_IMAGE_ASPECT_COLOR_BIT is not the only bit set for this
+                // attachment
+                char const str[] = "vkCmdClearAttachments aspectMask [%d] must "
+                                   "set only VK_IMAGE_ASPECT_COLOR_BIT of a "
+                                   "color attachment.";
+                skipCall |= log_msg(
+                    device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+                    (uint64_t)commandBuffer, __LINE__,
+                    IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str, i);
             }
         } else {
             // Image aspect must be depth or stencil or both
-            if (((aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT)   != VK_IMAGE_ASPECT_DEPTH_BIT) &&
-                ((aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) != VK_IMAGE_ASPECT_STENCIL_BIT))
-            {
-                char const str[] = "vkCmdClearAttachments aspectMask [%d] must be set to VK_IMAGE_ASPECT_DEPTH_BIT and/or VK_IMAGE_ASPECT_STENCIL_BIT";
-                skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
-                                    (uint64_t)commandBuffer, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str, i);
+            if (((aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) !=
+                 VK_IMAGE_ASPECT_DEPTH_BIT) &&
+                ((aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) !=
+                 VK_IMAGE_ASPECT_STENCIL_BIT)) {
+                char const str[] = "vkCmdClearAttachments aspectMask [%d] must "
+                                   "be set to VK_IMAGE_ASPECT_DEPTH_BIT and/or "
+                                   "VK_IMAGE_ASPECT_STENCIL_BIT";
+                skipCall |= log_msg(
+                    device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+                    (uint64_t)commandBuffer, __LINE__,
+                    IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str, i);
             }
         }
     }
 
     if (VK_FALSE == skipCall) {
-        device_data->device_dispatch_table->CmdClearAttachments(commandBuffer,
-            attachmentCount, pAttachments, rectCount, pRects);
+        device_data->device_dispatch_table->CmdClearAttachments(
+            commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
     }
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer(
-    VkCommandBuffer          commandBuffer,
-    VkImage                  srcImage,
-    VkImageLayout            srcImageLayout,
-    VkBuffer                 dstBuffer,
-    uint32_t                 regionCount,
-    const VkBufferImageCopy *pRegions)
-{
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage,
+                           VkImageLayout srcImageLayout, VkBuffer dstBuffer,
+                           uint32_t regionCount,
+                           const VkBufferImageCopy *pRegions) {
     VkBool32 skipCall = VK_FALSE;
-    layer_data *device_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
-    // For each region, the number of layers in the image subresource should not be zero
+    layer_data *device_data =
+        get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    // For each region, the number of layers in the image subresource should not
+    // be zero
     // Image aspect must be ONE OF color, depth, stencil
     for (uint32_t i = 0; i < regionCount; i++) {
-        if(pRegions[i].imageSubresource.layerCount == 0)
-        {
-            char const str[] = "vkCmdCopyImageToBuffer: number of layers in image subresource is zero";
-            // TODO: Verify against Valid Use section of spec, if this case yields undefined results, then it's an error
-            skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
-                                (uint64_t)commandBuffer, __LINE__, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
+        if (pRegions[i].imageSubresource.layerCount == 0) {
+            char const str[] = "vkCmdCopyImageToBuffer: number of layers in "
+                               "image subresource is zero";
+            // TODO: Verify against Valid Use section of spec, if this case
+            // yields undefined results, then it's an error
+            skipCall |=
+                log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT,
+                        VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+                        (uint64_t)commandBuffer, __LINE__,
+                        IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
         }
 
         VkImageAspectFlags aspectMask = pRegions[i].imageSubresource.aspectMask;
         if ((aspectMask != VK_IMAGE_ASPECT_COLOR_BIT) &&
             (aspectMask != VK_IMAGE_ASPECT_DEPTH_BIT) &&
             (aspectMask != VK_IMAGE_ASPECT_STENCIL_BIT)) {
-            char const str[] = "vkCmdCopyImageToBuffer: aspectMasks for each region must specify only COLOR or DEPTH or STENCIL";
-            skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
-                                (uint64_t)commandBuffer, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str);
+            char const str[] = "vkCmdCopyImageToBuffer: aspectMasks for each "
+                               "region must specify only COLOR or DEPTH or "
+                               "STENCIL";
+            skipCall |=
+                log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+                        (uint64_t)commandBuffer, __LINE__,
+                        IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str);
         }
     }
 
     if (VK_FALSE == skipCall) {
-        device_data->device_dispatch_table->CmdCopyImageToBuffer(commandBuffer,
-            srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
+        device_data->device_dispatch_table->CmdCopyImageToBuffer(
+            commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount,
+            pRegions);
     }
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage(
-    VkCommandBuffer          commandBuffer,
-    VkBuffer                 srcBuffer,
-    VkImage                  dstImage,
-    VkImageLayout            dstImageLayout,
-    uint32_t                 regionCount,
-    const VkBufferImageCopy *pRegions)
-{
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer,
+                           VkImage dstImage, VkImageLayout dstImageLayout,
+                           uint32_t regionCount,
+                           const VkBufferImageCopy *pRegions) {
     VkBool32 skipCall = VK_FALSE;
-    layer_data *device_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
-    // For each region, the number of layers in the image subresource should not be zero
+    layer_data *device_data =
+        get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    // For each region, the number of layers in the image subresource should not
+    // be zero
     // Image aspect must be ONE OF color, depth, stencil
     for (uint32_t i = 0; i < regionCount; i++) {
-        if(pRegions[i].imageSubresource.layerCount == 0)
-        {
-            char const str[] = "vkCmdCopyBufferToImage: number of layers in image subresource is zero";
-            // TODO: Verify against Valid Use section of spec, if this case yields undefined results, then it's an error
-            skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
-                                (uint64_t)commandBuffer, __LINE__, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
+        if (pRegions[i].imageSubresource.layerCount == 0) {
+            char const str[] = "vkCmdCopyBufferToImage: number of layers in "
+                               "image subresource is zero";
+            // TODO: Verify against Valid Use section of spec, if this case
+            // yields undefined results, then it's an error
+            skipCall |=
+                log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT,
+                        VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+                        (uint64_t)commandBuffer, __LINE__,
+                        IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
         }
 
         VkImageAspectFlags aspectMask = pRegions[i].imageSubresource.aspectMask;
         if ((aspectMask != VK_IMAGE_ASPECT_COLOR_BIT) &&
             (aspectMask != VK_IMAGE_ASPECT_DEPTH_BIT) &&
             (aspectMask != VK_IMAGE_ASPECT_STENCIL_BIT)) {
-            char const str[] = "vkCmdCopyBufferToImage: aspectMasks for each region must specify only COLOR or DEPTH or STENCIL";
-            skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
-                                (uint64_t)commandBuffer, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str);
+            char const str[] = "vkCmdCopyBufferToImage: aspectMasks for each "
+                               "region must specify only COLOR or DEPTH or "
+                               "STENCIL";
+            skipCall |=
+                log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+                        (uint64_t)commandBuffer, __LINE__,
+                        IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str);
         }
     }
 
     if (VK_FALSE == skipCall) {
-        device_data->device_dispatch_table->CmdCopyBufferToImage(commandBuffer,
-            srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
+        device_data->device_dispatch_table->CmdCopyBufferToImage(
+            commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount,
+            pRegions);
     }
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage(
-    VkCommandBuffer    commandBuffer,
-    VkImage            srcImage,
-    VkImageLayout      srcImageLayout,
-    VkImage            dstImage,
-    VkImageLayout      dstImageLayout,
-    uint32_t           regionCount,
-    const VkImageBlit *pRegions,
-    VkFilter        filter)
-{
-    VkBool32    skipCall    = VK_FALSE;
-    layer_data *device_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
-
-    auto srcImageEntry  = device_data->imageMap.find(srcImage);
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage,
+                   VkImageLayout srcImageLayout, VkImage dstImage,
+                   VkImageLayout dstImageLayout, uint32_t regionCount,
+                   const VkImageBlit *pRegions, VkFilter filter) {
+    VkBool32 skipCall = VK_FALSE;
+    layer_data *device_data =
+        get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+
+    auto srcImageEntry = device_data->imageMap.find(srcImage);
     auto dstImageEntry = device_data->imageMap.find(dstImage);
 
-    if ((srcImageEntry  != device_data->imageMap.end()) &&
+    if ((srcImageEntry != device_data->imageMap.end()) &&
         (dstImageEntry != device_data->imageMap.end())) {
 
         VkFormat srcFormat = srcImageEntry->second.format;
@@ -925,11 +1162,17 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage(
         if ((vk_format_is_sint(srcFormat) && !vk_format_is_sint(dstFormat)) ||
             (vk_format_is_uint(srcFormat) && !vk_format_is_uint(dstFormat))) {
             std::stringstream ss;
-            ss << "vkCmdBlitImage: If one of srcImage and dstImage images has signed/unsigned integer format, "
-               << "the other one must also have signed/unsigned integer format.  "
-               << "Source format is " << string_VkFormat(srcFormat) << " Destination format is " << string_VkFormat(dstFormat);
-            skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
-                               (uint64_t)commandBuffer, __LINE__, IMAGE_INVALID_FORMAT, "IMAGE", "%s", ss.str().c_str());
+            ss << "vkCmdBlitImage: If one of srcImage and dstImage images has "
+                  "signed/unsigned integer format, "
+               << "the other one must also have signed/unsigned integer "
+                  "format.  "
+               << "Source format is " << string_VkFormat(srcFormat)
+               << " Destination format is " << string_VkFormat(dstFormat);
+            skipCall |=
+                log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+                        (uint64_t)commandBuffer, __LINE__, IMAGE_INVALID_FORMAT,
+                        "IMAGE", "%s", ss.str().c_str());
         }
 
         // Validate aspect bits and formats for depth/stencil images
@@ -937,70 +1180,118 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage(
             vk_format_is_depth_or_stencil(dstFormat)) {
             if (srcFormat != dstFormat) {
                 std::stringstream ss;
-                ss << "vkCmdBlitImage: If one of srcImage and dstImage images has a format of depth, stencil or depth "
-                   << "stencil, the other one must have exactly the same format.  "
-                   << "Source format is " << string_VkFormat(srcFormat) << " Destination format is " << string_VkFormat(dstFormat);
-                skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
-                                   (uint64_t)commandBuffer, __LINE__, IMAGE_INVALID_FORMAT, "IMAGE", "%s", ss.str().c_str());
+                ss << "vkCmdBlitImage: If one of srcImage and dstImage images "
+                      "has a format of depth, stencil or depth "
+                   << "stencil, the other one must have exactly the same "
+                      "format.  "
+                   << "Source format is " << string_VkFormat(srcFormat)
+                   << " Destination format is " << string_VkFormat(dstFormat);
+                skipCall |= log_msg(
+                    device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+                    (uint64_t)commandBuffer, __LINE__, IMAGE_INVALID_FORMAT,
+                    "IMAGE", "%s", ss.str().c_str());
             }
 
             for (uint32_t i = 0; i < regionCount; i++) {
-                if(pRegions[i].srcSubresource.layerCount == 0)
-                {
-                    char const str[] = "vkCmdBlitImage: number of layers in source subresource is zero";
-                    // TODO: Verify against Valid Use section of spec, if this case yields undefined results, then it's an error
-                    skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
-                                        (uint64_t)commandBuffer, __LINE__, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
+                if (pRegions[i].srcSubresource.layerCount == 0) {
+                    char const str[] = "vkCmdBlitImage: number of layers in "
+                                       "source subresource is zero";
+                    // TODO: Verify against Valid Use section of spec, if this
+                    // case yields undefined results, then it's an error
+                    skipCall |= log_msg(
+                        device_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT,
+                        VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+                        (uint64_t)commandBuffer, __LINE__,
+                        IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
                 }
 
-                if(pRegions[i].dstSubresource.layerCount == 0)
-                {
-                    char const str[] = "vkCmdBlitImage: number of layers in destination subresource is zero";
-                    // TODO: Verify against Valid Use section of spec, if this case yields undefined results, then it's an error
-                    skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
-                                        (uint64_t)commandBuffer, __LINE__, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
+                if (pRegions[i].dstSubresource.layerCount == 0) {
+                    char const str[] = "vkCmdBlitImage: number of layers in "
+                                       "destination subresource is zero";
+                    // TODO: Verify against Valid Use section of spec, if this
+                    // case yields undefined results, then it's an error
+                    skipCall |= log_msg(
+                        device_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT,
+                        VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+                        (uint64_t)commandBuffer, __LINE__,
+                        IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
                 }
 
-                if(pRegions[i].srcSubresource.layerCount != pRegions[i].dstSubresource.layerCount)
-                {
-                    char const str[] = "vkCmdBlitImage: number of layers in source and destination subresources must match";
-                    skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
-                                        (uint64_t)commandBuffer, __LINE__, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
+                if (pRegions[i].srcSubresource.layerCount !=
+                    pRegions[i].dstSubresource.layerCount) {
+                    char const str[] = "vkCmdBlitImage: number of layers in "
+                                       "source and destination subresources "
+                                       "must match";
+                    skipCall |= log_msg(
+                        device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+                        (uint64_t)commandBuffer, __LINE__,
+                        IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
                 }
 
-                VkImageAspectFlags srcAspect = pRegions[i].srcSubresource.aspectMask;
-                VkImageAspectFlags dstAspect = pRegions[i].dstSubresource.aspectMask;
+                VkImageAspectFlags srcAspect =
+                    pRegions[i].srcSubresource.aspectMask;
+                VkImageAspectFlags dstAspect =
+                    pRegions[i].dstSubresource.aspectMask;
 
                 if (srcAspect != dstAspect) {
                     std::stringstream ss;
-                    ss << "vkCmdBlitImage: Image aspects of depth/stencil images should match";
-                    // TODO: Verify against Valid Use section of spec, if this case yields undefined results, then it's an error
-                    skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
-                                       (uint64_t)commandBuffer, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", ss.str().c_str());
+                    ss << "vkCmdBlitImage: Image aspects of depth/stencil "
+                          "images should match";
+                    // TODO: Verify against Valid Use section of spec, if this
+                    // case yields undefined results, then it's an error
+                    skipCall |= log_msg(
+                        device_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT,
+                        VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+                        (uint64_t)commandBuffer, __LINE__,
+                        IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s",
+                        ss.str().c_str());
                 }
                 if (vk_format_is_depth_and_stencil(srcFormat)) {
-                    if ((srcAspect != VK_IMAGE_ASPECT_DEPTH_BIT) && (srcAspect != VK_IMAGE_ASPECT_STENCIL_BIT)) {
+                    if ((srcAspect != VK_IMAGE_ASPECT_DEPTH_BIT) &&
+                        (srcAspect != VK_IMAGE_ASPECT_STENCIL_BIT)) {
                         std::stringstream ss;
-                        ss << "vkCmdBlitImage: Combination depth/stencil image formats must have only one of VK_IMAGE_ASPECT_DEPTH_BIT "
-                           << "and VK_IMAGE_ASPECT_STENCIL_BIT set in srcImage and dstImage";
-                        skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
-                                           (uint64_t)commandBuffer, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", ss.str().c_str());
+                        ss << "vkCmdBlitImage: Combination depth/stencil image "
+                              "formats must have only one of "
+                              "VK_IMAGE_ASPECT_DEPTH_BIT "
+                           << "and VK_IMAGE_ASPECT_STENCIL_BIT set in srcImage "
+                              "and dstImage";
+                        skipCall |= log_msg(
+                            device_data->report_data,
+                            VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                            VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+                            (uint64_t)commandBuffer, __LINE__,
+                            IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s",
+                            ss.str().c_str());
                     }
                 } else if (vk_format_is_stencil_only(srcFormat)) {
                     if (srcAspect != VK_IMAGE_ASPECT_STENCIL_BIT) {
                         std::stringstream ss;
-                        ss << "vkCmdBlitImage: Stencil-only image formats must have only the VK_IMAGE_ASPECT_STENCIL_BIT "
+                        ss << "vkCmdBlitImage: Stencil-only image formats must "
+                              "have only the VK_IMAGE_ASPECT_STENCIL_BIT "
                            << "set in both the srcImage and dstImage";
-                        skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
-                                           (uint64_t)commandBuffer, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", ss.str().c_str());
+                        skipCall |= log_msg(
+                            device_data->report_data,
+                            VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                            VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+                            (uint64_t)commandBuffer, __LINE__,
+                            IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s",
+                            ss.str().c_str());
                     }
                 } else if (vk_format_is_depth_only(srcFormat)) {
                     if (srcAspect != VK_IMAGE_ASPECT_DEPTH_BIT) {
                         std::stringstream ss;
-                        ss << "vkCmdBlitImage: Depth-only image formats must have only the VK_IMAGE_ASPECT_DEPTH "
+                        ss << "vkCmdBlitImage: Depth-only image formats must "
+                              "have only the VK_IMAGE_ASPECT_DEPTH "
                            << "set in both the srcImage and dstImage";
-                        skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
-                                           (uint64_t)commandBuffer, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", ss.str().c_str());
+                        skipCall |= log_msg(
+                            device_data->report_data,
+                            VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                            VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+                            (uint64_t)commandBuffer, __LINE__,
+                            IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s",
+                            ss.str().c_str());
                     }
                 }
             }
@@ -1011,140 +1302,173 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage(
             vk_format_is_int(srcFormat)) {
             if (filter != VK_FILTER_NEAREST) {
                 std::stringstream ss;
-                ss << "vkCmdBlitImage: If the format of srcImage is a depth, stencil, depth stencil or integer-based format "
+                ss << "vkCmdBlitImage: If the format of srcImage is a depth, "
+                      "stencil, depth stencil or integer-based format "
                    << "then filter must be VK_FILTER_NEAREST.";
-                skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
-                                   (uint64_t)commandBuffer, __LINE__, IMAGE_INVALID_FILTER, "IMAGE", "%s", ss.str().c_str());
+                skipCall |= log_msg(
+                    device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+                    (uint64_t)commandBuffer, __LINE__, IMAGE_INVALID_FILTER,
+                    "IMAGE", "%s", ss.str().c_str());
             }
         }
     }
 
-    device_data->device_dispatch_table->CmdBlitImage(commandBuffer, srcImage,
-        srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
+    device_data->device_dispatch_table->CmdBlitImage(
+        commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout,
+        regionCount, pRegions, filter);
 }
 
 VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier(
-    VkCommandBuffer                             commandBuffer,
-    VkPipelineStageFlags                        srcStageMask,
-    VkPipelineStageFlags                        dstStageMask,
-    VkDependencyFlags                           dependencyFlags,
-    uint32_t                                    memoryBarrierCount,
-    const VkMemoryBarrier                      *pMemoryBarriers,
-    uint32_t                                    bufferMemoryBarrierCount,
-    const VkBufferMemoryBarrier                *pBufferMemoryBarriers,
-    uint32_t                                    imageMemoryBarrierCount,
-    const VkImageMemoryBarrier                 *pImageMemoryBarriers)
-{
+    VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask,
+    VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags,
+    uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers,
+    uint32_t bufferMemoryBarrierCount,
+    const VkBufferMemoryBarrier *pBufferMemoryBarriers,
+    uint32_t imageMemoryBarrierCount,
+    const VkImageMemoryBarrier *pImageMemoryBarriers) {
     VkBool32 skipCall = VK_FALSE;
-    layer_data *device_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
-
-    for (uint32_t i = 0; i < imageMemoryBarrierCount; ++i)
-    {
-        VkImageMemoryBarrier const*const barrier = (VkImageMemoryBarrier const*const) &pImageMemoryBarriers[i];
-        if (barrier->sType == VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER)
-        {
-            if (barrier->subresourceRange.layerCount == 0)
-            {
+    layer_data *device_data =
+        get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+
+    for (uint32_t i = 0; i < imageMemoryBarrierCount; ++i) {
+        VkImageMemoryBarrier const *const barrier =
+            (VkImageMemoryBarrier const *const) & pImageMemoryBarriers[i];
+        if (barrier->sType == VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER) {
+            if (barrier->subresourceRange.layerCount == 0) {
                 std::stringstream ss;
-                ss << "vkCmdPipelineBarrier called with 0 in ppMemoryBarriers[" << i << "]->subresourceRange.layerCount.";
-                skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0,
-                                    0, __LINE__, IMAGE_INVALID_IMAGE_RESOURCE, "IMAGE", "%s", ss.str().c_str());
+                ss << "vkCmdPipelineBarrier called with 0 in ppMemoryBarriers["
+                   << i << "]->subresourceRange.layerCount.";
+                skipCall |= log_msg(device_data->report_data,
+                                    VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                                    (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
+                                    IMAGE_INVALID_IMAGE_RESOURCE, "IMAGE", "%s",
+                                    ss.str().c_str());
             }
         }
     }
 
-    if (skipCall)
-    {
+    if (skipCall) {
         return;
     }
 
-    device_data->device_dispatch_table->CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags,
-                                            memoryBarrierCount, pMemoryBarriers,
-                                            bufferMemoryBarrierCount, pBufferMemoryBarriers,
-                                            imageMemoryBarrierCount, pImageMemoryBarriers);
+    device_data->device_dispatch_table->CmdPipelineBarrier(
+        commandBuffer, srcStageMask, dstStageMask, dependencyFlags,
+        memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount,
+        pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage(
-    VkCommandBuffer       commandBuffer,
-    VkImage               srcImage,
-    VkImageLayout         srcImageLayout,
-    VkImage               dstImage,
-    VkImageLayout         dstImageLayout,
-    uint32_t              regionCount,
-    const VkImageResolve *pRegions)
-{
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage,
+                      VkImageLayout srcImageLayout, VkImage dstImage,
+                      VkImageLayout dstImageLayout, uint32_t regionCount,
+                      const VkImageResolve *pRegions) {
     VkBool32 skipCall = VK_FALSE;
-    layer_data *device_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+    layer_data *device_data =
+        get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     auto srcImageEntry = device_data->imageMap.find(srcImage);
     auto dstImageEntry = device_data->imageMap.find(dstImage);
 
-    // For each region, the number of layers in the image subresource should not be zero
+    // For each region, the number of layers in the image subresource should not
+    // be zero
     // For each region, src and dest image aspect must be color only
     for (uint32_t i = 0; i < regionCount; i++) {
-        if(pRegions[i].srcSubresource.layerCount == 0)
-        {
-            char const str[] = "vkCmdResolveImage: number of layers in source subresource is zero";
-            // TODO: Verify against Valid Use section of spec. Generally if something yield an undefined result, it's invalid/error
-            skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
-                                (uint64_t)commandBuffer, __LINE__, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
+        if (pRegions[i].srcSubresource.layerCount == 0) {
+            char const str[] = "vkCmdResolveImage: number of layers in source "
+                               "subresource is zero";
+            // TODO: Verify against Valid Use section of spec. Generally if
+            // something yield an undefined result, it's invalid/error
+            skipCall |=
+                log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT,
+                        VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+                        (uint64_t)commandBuffer, __LINE__,
+                        IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
         }
 
-        if(pRegions[i].dstSubresource.layerCount == 0)
-        {
-            char const str[] = "vkCmdResolveImage: number of layers in destination subresource is zero";
-
-            // TODO: Verify against Valid Use section of spec. Generally if something yield an undefined result, it's invalid/error
-            skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
-                                (uint64_t)commandBuffer, __LINE__, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
+        if (pRegions[i].dstSubresource.layerCount == 0) {
+            char const str[] = "vkCmdResolveImage: number of layers in "
+                               "destination subresource is zero";
+
+            // TODO: Verify against Valid Use section of spec. Generally if
+            // something yield an undefined result, it's invalid/error
+            skipCall |=
+                log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT,
+                        VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+                        (uint64_t)commandBuffer, __LINE__,
+                        IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str);
         }
 
-        if ((pRegions[i].srcSubresource.aspectMask  != VK_IMAGE_ASPECT_COLOR_BIT) ||
-            (pRegions[i].dstSubresource.aspectMask != VK_IMAGE_ASPECT_COLOR_BIT)) {
-            char const str[] = "vkCmdResolveImage: src and dest aspectMasks for each region must specify only VK_IMAGE_ASPECT_COLOR_BIT";
-            skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
-                                (uint64_t)commandBuffer, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str);
+        if ((pRegions[i].srcSubresource.aspectMask !=
+             VK_IMAGE_ASPECT_COLOR_BIT) ||
+            (pRegions[i].dstSubresource.aspectMask !=
+             VK_IMAGE_ASPECT_COLOR_BIT)) {
+            char const str[] = "vkCmdResolveImage: src and dest aspectMasks "
+                               "for each region must specify only "
+                               "VK_IMAGE_ASPECT_COLOR_BIT";
+            skipCall |=
+                log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+                        (uint64_t)commandBuffer, __LINE__,
+                        IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str);
         }
     }
 
-    if ((srcImageEntry  != device_data->imageMap.end()) &&
+    if ((srcImageEntry != device_data->imageMap.end()) &&
         (dstImageEntry != device_data->imageMap.end())) {
         if (srcImageEntry->second.format != dstImageEntry->second.format) {
-            char const str[] =  "vkCmdResolveImage called with unmatched source and dest formats.";
-            skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
-                                (uint64_t)commandBuffer, __LINE__, IMAGE_MISMATCHED_IMAGE_FORMAT, "IMAGE", str);
+            char const str[] = "vkCmdResolveImage called with unmatched source "
+                               "and dest formats.";
+            skipCall |=
+                log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+                        (uint64_t)commandBuffer, __LINE__,
+                        IMAGE_MISMATCHED_IMAGE_FORMAT, "IMAGE", str);
         }
-        if (srcImageEntry->second.imageType != dstImageEntry->second.imageType) {
-            char const str[] =  "vkCmdResolveImage called with unmatched source and dest image types.";
-            skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
-                                (uint64_t)commandBuffer, __LINE__, IMAGE_MISMATCHED_IMAGE_TYPE, "IMAGE", str);
+        if (srcImageEntry->second.imageType !=
+            dstImageEntry->second.imageType) {
+            char const str[] = "vkCmdResolveImage called with unmatched source "
+                               "and dest image types.";
+            skipCall |=
+                log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+                        (uint64_t)commandBuffer, __LINE__,
+                        IMAGE_MISMATCHED_IMAGE_TYPE, "IMAGE", str);
         }
         if (srcImageEntry->second.samples == VK_SAMPLE_COUNT_1_BIT) {
-            char const str[] =  "vkCmdResolveImage called with source sample count less than 2.";
-            skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
-                                (uint64_t)commandBuffer, __LINE__, IMAGE_INVALID_RESOLVE_SAMPLES,  "IMAGE", str);
+            char const str[] = "vkCmdResolveImage called with source sample "
+                               "count less than 2.";
+            skipCall |=
+                log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+                        (uint64_t)commandBuffer, __LINE__,
+                        IMAGE_INVALID_RESOLVE_SAMPLES, "IMAGE", str);
         }
         if (dstImageEntry->second.samples != VK_SAMPLE_COUNT_1_BIT) {
-            char const str[] =  "vkCmdResolveImage called with dest sample count greater than 1.";
-            skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
-                                (uint64_t)commandBuffer, __LINE__, IMAGE_INVALID_RESOLVE_SAMPLES, "IMAGE", str);
+            char const str[] = "vkCmdResolveImage called with dest sample "
+                               "count greater than 1.";
+            skipCall |=
+                log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                        VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+                        (uint64_t)commandBuffer, __LINE__,
+                        IMAGE_INVALID_RESOLVE_SAMPLES, "IMAGE", str);
         }
     }
 
     if (VK_FALSE == skipCall) {
-        device_data->device_dispatch_table->CmdResolveImage(commandBuffer, srcImage,
-            srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
+        device_data->device_dispatch_table->CmdResolveImage(
+            commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout,
+            regionCount, pRegions);
     }
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout(
-    VkDevice                  device,
-    VkImage                   image,
-    const VkImageSubresource *pSubresource,
-    VkSubresourceLayout      *pLayout)
-{
-    VkBool32    skipCall    = VK_FALSE;
-    layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
-    VkFormat    format;
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkGetImageSubresourceLayout(VkDevice device, VkImage image,
+                                const VkImageSubresource *pSubresource,
+                                VkSubresourceLayout *pLayout) {
+    VkBool32 skipCall = VK_FALSE;
+    layer_data *device_data =
+        get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+    VkFormat format;
 
     auto imageEntry = device_data->imageMap.find(image);
 
@@ -1154,75 +1478,89 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout(
         if (vk_format_is_color(format)) {
             if (pSubresource->aspectMask != VK_IMAGE_ASPECT_COLOR_BIT) {
                 std::stringstream ss;
-                ss << "vkGetImageSubresourceLayout: For color formats, the aspectMask field of VkImageSubresource must be VK_IMAGE_ASPECT_COLOR.";
-                skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
-                                   (uint64_t)image, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", ss.str().c_str());
+                ss << "vkGetImageSubresourceLayout: For color formats, the "
+                      "aspectMask field of VkImageSubresource must be "
+                      "VK_IMAGE_ASPECT_COLOR.";
+                skipCall |= log_msg(
+                    device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, (uint64_t)image,
+                    __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s",
+                    ss.str().c_str());
             }
         } else if (vk_format_is_depth_or_stencil(format)) {
             if ((pSubresource->aspectMask != VK_IMAGE_ASPECT_DEPTH_BIT) &&
                 (pSubresource->aspectMask != VK_IMAGE_ASPECT_STENCIL_BIT)) {
                 std::stringstream ss;
-                ss << "vkGetImageSubresourceLayout: For depth/stencil formats, the aspectMask selects either the depth or stencil image aspectMask.";
-                skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
-                                   (uint64_t)image, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", ss.str().c_str());
+                ss << "vkGetImageSubresourceLayout: For depth/stencil formats, "
+                      "the aspectMask selects either the depth or stencil "
+                      "image aspectMask.";
+                skipCall |= log_msg(
+                    device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                    VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, (uint64_t)image,
+                    __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s",
+                    ss.str().c_str());
             }
         }
     }
 
     if (VK_FALSE == skipCall) {
-        device_data->device_dispatch_table->GetImageSubresourceLayout(device,
-                           image, pSubresource, pLayout);
+        device_data->device_dispatch_table->GetImageSubresourceLayout(
+            device, image, pSubresource, pLayout);
     }
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties)
-{
-    layer_data *phy_dev_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
-    phy_dev_data->instance_dispatch_table->GetPhysicalDeviceProperties(physicalDevice, pProperties);
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL
+    vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,
+                                  VkPhysicalDeviceProperties *pProperties) {
+    layer_data *phy_dev_data =
+        get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
+    phy_dev_data->instance_dispatch_table->GetPhysicalDeviceProperties(
+        physicalDevice, pProperties);
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice device, const char* funcName)
-{
+VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL
+    vkGetDeviceProcAddr(VkDevice device, const char *funcName) {
     if (!strcmp(funcName, "vkGetDeviceProcAddr"))
-        return (PFN_vkVoidFunction) vkGetDeviceProcAddr;
+        return (PFN_vkVoidFunction)vkGetDeviceProcAddr;
     if (!strcmp(funcName, "vkDestroyDevice"))
-        return (PFN_vkVoidFunction) vkDestroyDevice;
+        return (PFN_vkVoidFunction)vkDestroyDevice;
     if (!strcmp(funcName, "vkCreateImage"))
-        return (PFN_vkVoidFunction) vkCreateImage;
+        return (PFN_vkVoidFunction)vkCreateImage;
     if (!strcmp(funcName, "vkDestroyImage"))
-        return (PFN_vkVoidFunction) vkDestroyImage;
+        return (PFN_vkVoidFunction)vkDestroyImage;
     if (!strcmp(funcName, "vkCreateImageView"))
-        return (PFN_vkVoidFunction) vkCreateImageView;
+        return (PFN_vkVoidFunction)vkCreateImageView;
     if (!strcmp(funcName, "vkCreateRenderPass"))
-        return (PFN_vkVoidFunction) vkCreateRenderPass;
+        return (PFN_vkVoidFunction)vkCreateRenderPass;
     if (!strcmp(funcName, "vkCmdClearColorImage"))
-        return (PFN_vkVoidFunction) vkCmdClearColorImage;
+        return (PFN_vkVoidFunction)vkCmdClearColorImage;
     if (!strcmp(funcName, "vkCmdClearDepthStencilImage"))
-        return (PFN_vkVoidFunction) vkCmdClearDepthStencilImage;
+        return (PFN_vkVoidFunction)vkCmdClearDepthStencilImage;
     if (!strcmp(funcName, "vkCmdClearAttachments"))
-        return (PFN_vkVoidFunction) vkCmdClearAttachments;
+        return (PFN_vkVoidFunction)vkCmdClearAttachments;
     if (!strcmp(funcName, "vkCmdCopyImage"))
-        return (PFN_vkVoidFunction) vkCmdCopyImage;
+        return (PFN_vkVoidFunction)vkCmdCopyImage;
     if (!strcmp(funcName, "vkCmdCopyImageToBuffer"))
-        return (PFN_vkVoidFunction) vkCmdCopyImageToBuffer;
+        return (PFN_vkVoidFunction)vkCmdCopyImageToBuffer;
     if (!strcmp(funcName, "vkCmdCopyBufferToImage"))
-        return (PFN_vkVoidFunction) vkCmdCopyBufferToImage;
+        return (PFN_vkVoidFunction)vkCmdCopyBufferToImage;
     if (!strcmp(funcName, "vkCmdBlitImage"))
-        return (PFN_vkVoidFunction) vkCmdBlitImage;
+        return (PFN_vkVoidFunction)vkCmdBlitImage;
     if (!strcmp(funcName, "vkCmdPipelineBarrier"))
-        return (PFN_vkVoidFunction) vkCmdPipelineBarrier;
+        return (PFN_vkVoidFunction)vkCmdPipelineBarrier;
     if (!strcmp(funcName, "vkCmdResolveImage"))
-        return (PFN_vkVoidFunction) vkCmdResolveImage;
+        return (PFN_vkVoidFunction)vkCmdResolveImage;
     if (!strcmp(funcName, "vkGetImageSubresourceLayout"))
-        return (PFN_vkVoidFunction) vkGetImageSubresourceLayout;
+        return (PFN_vkVoidFunction)vkGetImageSubresourceLayout;
 
     if (device == NULL) {
         return NULL;
     }
 
-    layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+    layer_data *my_data =
+        get_my_data_ptr(get_dispatch_key(device), layer_data_map);
 
-    VkLayerDispatchTable* pTable = my_data->device_dispatch_table;
+    VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
     {
         if (pTable->GetDeviceProcAddr == NULL)
             return NULL;
@@ -1230,38 +1568,40 @@ VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkD
     }
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance, const char* funcName)
-{
+VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL
+    vkGetInstanceProcAddr(VkInstance instance, const char *funcName) {
     if (!strcmp(funcName, "vkGetInstanceProcAddr"))
-        return (PFN_vkVoidFunction) vkGetInstanceProcAddr;
+        return (PFN_vkVoidFunction)vkGetInstanceProcAddr;
     if (!strcmp(funcName, "vkCreateInstance"))
-        return (PFN_vkVoidFunction) vkCreateInstance;
+        return (PFN_vkVoidFunction)vkCreateInstance;
     if (!strcmp(funcName, "vkDestroyInstance"))
-        return (PFN_vkVoidFunction) vkDestroyInstance;
+        return (PFN_vkVoidFunction)vkDestroyInstance;
     if (!strcmp(funcName, "vkCreateDevice"))
-        return (PFN_vkVoidFunction) vkCreateDevice;
+        return (PFN_vkVoidFunction)vkCreateDevice;
     if (!strcmp(funcName, "vkEnumerateInstanceLayerProperties"))
-        return (PFN_vkVoidFunction) vkEnumerateInstanceLayerProperties;
+        return (PFN_vkVoidFunction)vkEnumerateInstanceLayerProperties;
     if (!strcmp(funcName, "vkEnumerateInstanceExtensionProperties"))
-        return (PFN_vkVoidFunction) vkEnumerateInstanceExtensionProperties;
+        return (PFN_vkVoidFunction)vkEnumerateInstanceExtensionProperties;
     if (!strcmp(funcName, "vkEnumerateDeviceLayerProperties"))
-        return (PFN_vkVoidFunction) vkEnumerateDeviceLayerProperties;
+        return (PFN_vkVoidFunction)vkEnumerateDeviceLayerProperties;
     if (!strcmp(funcName, "vkEnumerateDeviceExtensionProperties"))
-        return (PFN_vkVoidFunction) vkEnumerateDeviceExtensionProperties;
+        return (PFN_vkVoidFunction)vkEnumerateDeviceExtensionProperties;
     if (!strcmp(funcName, "vkGetPhysicalDeviceProperties"))
-        return (PFN_vkVoidFunction) vkGetPhysicalDeviceProperties;
+        return (PFN_vkVoidFunction)vkGetPhysicalDeviceProperties;
 
     if (instance == NULL) {
         return NULL;
     }
 
-    layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
+    layer_data *my_data =
+        get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
 
-    PFN_vkVoidFunction fptr = debug_report_get_instance_proc_addr(my_data->report_data, funcName);
-    if(fptr)
+    PFN_vkVoidFunction fptr =
+        debug_report_get_instance_proc_addr(my_data->report_data, funcName);
+    if (fptr)
         return fptr;
 
-    VkLayerInstanceDispatchTable* pTable = my_data->instance_dispatch_table;
+    VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
     if (pTable->GetInstanceProcAddr == NULL)
         return NULL;
     return pTable->GetInstanceProcAddr(instance, funcName);