layers: Update PDFmt/Img/Mem/Dev props helpers

Change-Id: Id39da6041790f7644244814718b74aa771241cbd

4 files changed, 31 insertions, 37 deletions

diff --git a/layers/buffer_validation.cpp b/layers/buffer_validation.cpp
index d9bad017a..f9ef69d0a 100644
--- a/layers/buffer_validation.cpp
+++ b/layers/buffer_validation.cpp
@@ -1386,7 +1386,7 @@ bool CoreChecks::PreCallValidateCreateImage(VkDevice device, const VkImageCreate
             "vkCreateImage(): Image type must be VK_IMAGE_TYPE_2D when VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT flag bit is set");
     }
 
-    const VkPhysicalDeviceLimits *device_limits = &(GetPDProperties(device_data)->limits);
+    const VkPhysicalDeviceLimits *device_limits = &(GetPDProperties()->limits);
     VkImageUsageFlags attach_flags = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT |
                                      VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
     if ((pCreateInfo->usage & attach_flags) && (pCreateInfo->extent.width > device_limits->maxFramebufferWidth)) {
@@ -1404,7 +1404,7 @@ bool CoreChecks::PreCallValidateCreateImage(VkDevice device, const VkImageCreate
     }
 
     VkImageFormatProperties format_limits = {};
-    VkResult res = GetPDImageFormatProperties(device_data, pCreateInfo, &format_limits);
+    VkResult res = GetPDImageFormatProperties(pCreateInfo, &format_limits);
     if (res == VK_ERROR_FORMAT_NOT_SUPPORTED) {
         skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, kVUIDUndefined,
                         "vkCreateImage(): Format %s is not supported for this combination of parameters.",
@@ -1424,7 +1424,7 @@ bool CoreChecks::PreCallValidateCreateImage(VkDevice device, const VkImageCreate
         uint64_t total_size = (uint64_t)std::ceil(FormatTexelSize(pCreateInfo->format) * texel_count);
 
         // Round up to imageGranularity boundary
-        VkDeviceSize imageGranularity = GetPDProperties(device_data)->limits.bufferImageGranularity;
+        VkDeviceSize imageGranularity = GetPDProperties()->limits.bufferImageGranularity;
         uint64_t ig_mask = imageGranularity - 1;
         total_size = (total_size + ig_mask) & ~ig_mask;
 
@@ -3737,7 +3737,7 @@ bool CoreChecks::ValidateImageUsageFlags(layer_data *device_data, IMAGE_STATE co
 
 bool CoreChecks::ValidateImageFormatFeatureFlags(layer_data *dev_data, IMAGE_STATE const *image_state, VkFormatFeatureFlags desired,
                                                  char const *func_name, const char *linear_vuid, const char *optimal_vuid) {
-    VkFormatProperties format_properties = GetPDFormatProperties(dev_data, image_state->createInfo.format);
+    VkFormatProperties format_properties = GetPDFormatProperties(image_state->createInfo.format);
     bool skip = false;
     if (image_state->createInfo.tiling == VK_IMAGE_TILING_LINEAR) {
         if ((format_properties.linearTilingFeatures & desired) != desired) {
@@ -3845,7 +3845,7 @@ bool CoreChecks::ValidateBufferViewRange(const layer_data *device_data, const BU
 bool CoreChecks::ValidateBufferViewBuffer(const layer_data *device_data, const BUFFER_STATE *buffer_state,
                                           const VkBufferViewCreateInfo *pCreateInfo) {
     bool skip = false;
-    const VkFormatProperties format_properties = GetPDFormatProperties(device_data, pCreateInfo->format);
+    const VkFormatProperties format_properties = GetPDFormatProperties(pCreateInfo->format);
     if ((buffer_state->createInfo.usage & VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT) &&
         !(format_properties.bufferFeatures & VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT)) {
         skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT,
@@ -3965,7 +3965,7 @@ bool CoreChecks::PreCallValidateCreateBufferView(VkDevice device, const VkBuffer
                             pCreateInfo->offset, buffer_state->createInfo.size);
         }
 
-        const VkPhysicalDeviceLimits *device_limits = &(GetPDProperties(device_data)->limits);
+        const VkPhysicalDeviceLimits *device_limits = &(GetPDProperties()->limits);
         // Buffer view offset must be a multiple of VkPhysicalDeviceLimits::minTexelBufferOffsetAlignment
         if ((pCreateInfo->offset % device_limits->minTexelBufferOffsetAlignment) != 0) {
             skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT,
@@ -4359,7 +4359,7 @@ bool CoreChecks::PreCallValidateCreateImageView(VkDevice device, const VkImageVi
             skip |= ValidateCreateImageViewANDROID(device_data, pCreateInfo);
         }
 
-        VkFormatProperties format_properties = GetPDFormatProperties(device_data, view_format);
+        VkFormatProperties format_properties = GetPDFormatProperties(view_format);
         VkFormatFeatureFlags tiling_features = (image_tiling & VK_IMAGE_TILING_LINEAR) ? format_properties.linearTilingFeatures
                                                                                        : format_properties.optimalTilingFeatures;
 
diff --git a/layers/core_validation.cpp b/layers/core_validation.cpp
index 6e318d88d..1923cc02b 100644
--- a/layers/core_validation.cpp
+++ b/layers/core_validation.cpp
@@ -3427,7 +3427,7 @@ bool CoreChecks::ValidateAllocateMemoryANDROID(layer_data *dev_data, const VkMem
         ifp2.sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2;
         ifp2.pNext = &ext_img_fmt_props;
 
-        VkResult fmt_lookup_result = GetPDImageFormatProperties2(dev_data, &pdifi2, &ifp2);
+        VkResult fmt_lookup_result = GetPDImageFormatProperties2(&pdifi2, &ifp2);
 
         //  If buffer is not NULL, Android hardware buffers must be supported for import, as reported by
         //  VkExternalImageFormatProperties or VkExternalBufferProperties.
@@ -4990,26 +4990,24 @@ void CoreChecks::PreCallRecordDestroyRenderPass(VkDevice device, VkRenderPass re
 }
 
 // Access helper functions for external modules
-VkFormatProperties CoreChecks::GetPDFormatProperties(const layer_data *device_data, const VkFormat format) {
+VkFormatProperties CoreChecks::GetPDFormatProperties(const VkFormat format) {
     VkFormatProperties format_properties;
-    device_data->instance_dispatch_table.GetPhysicalDeviceFormatProperties(device_data->physical_device, format,
-                                                                           &format_properties);
+    instance_dispatch_table.GetPhysicalDeviceFormatProperties(physical_device, format, &format_properties);
     return format_properties;
 }
 
-VkResult CoreChecks::GetPDImageFormatProperties(layer_data *device_data, const VkImageCreateInfo *image_ci,
+VkResult CoreChecks::GetPDImageFormatProperties(const VkImageCreateInfo *image_ci,
                                                 VkImageFormatProperties *pImageFormatProperties) {
-    return device_data->instance_dispatch_table.GetPhysicalDeviceImageFormatProperties(
-        device_data->physical_device, image_ci->format, image_ci->imageType, image_ci->tiling, image_ci->usage, image_ci->flags,
-        pImageFormatProperties);
+    return instance_dispatch_table.GetPhysicalDeviceImageFormatProperties(physical_device, image_ci->format, image_ci->imageType,
+                                                                          image_ci->tiling, image_ci->usage, image_ci->flags,
+                                                                          pImageFormatProperties);
 }
 
-VkResult CoreChecks::GetPDImageFormatProperties2(layer_data *device_data,
-                                                 const VkPhysicalDeviceImageFormatInfo2 *phys_dev_image_fmt_info,
+VkResult CoreChecks::GetPDImageFormatProperties2(const VkPhysicalDeviceImageFormatInfo2 *phys_dev_image_fmt_info,
                                                  VkImageFormatProperties2 *pImageFormatProperties) {
-    if (!device_data->instance_extensions.vk_khr_get_physical_device_properties_2) return VK_ERROR_EXTENSION_NOT_PRESENT;
-    return device_data->instance_dispatch_table.GetPhysicalDeviceImageFormatProperties2(
-        device_data->physical_device, phys_dev_image_fmt_info, pImageFormatProperties);
+    if (!instance_extensions.vk_khr_get_physical_device_properties_2) return VK_ERROR_EXTENSION_NOT_PRESENT;
+    return instance_dispatch_table.GetPhysicalDeviceImageFormatProperties2(physical_device, phys_dev_image_fmt_info,
+                                                                           pImageFormatProperties);
 }
 
 const debug_report_data *CoreChecks::GetReportData(const layer_data *device_data) { return device_data->report_data; }
@@ -5018,13 +5016,9 @@ const VkLayerDispatchTable *CoreChecks::GetDispatchTable(const layer_data *devic
     return &device_data->device_dispatch_table;
 }
 
-const VkPhysicalDeviceProperties *CoreChecks::GetPDProperties(const layer_data *device_data) {
-    return &device_data->phys_dev_props;
-}
+const VkPhysicalDeviceProperties *CoreChecks::GetPDProperties() { return &phys_dev_props; }
 
-const VkPhysicalDeviceMemoryProperties *CoreChecks::GetPhysicalDeviceMemoryProperties(const layer_data *device_data) {
-    return &device_data->phys_dev_mem_props;
-}
+const VkPhysicalDeviceMemoryProperties *CoreChecks::GetPhysicalDeviceMemoryProperties() { return &phys_dev_mem_props; }
 
 const CHECK_DISABLED *CoreChecks::GetDisables(layer_data *device_data) { return &device_data->instance_state->disabled; }
 
@@ -5108,7 +5102,7 @@ bool CoreChecks::ValidatePipelineVertexDivisors(layer_data *dev_data,
                                                 std::vector<std::unique_ptr<PIPELINE_STATE>> const &pipe_state_vec,
                                                 const uint32_t count, const VkGraphicsPipelineCreateInfo *pipe_cis) {
     bool skip = false;
-    const VkPhysicalDeviceLimits *device_limits = &(GetPDProperties(dev_data)->limits);
+    const VkPhysicalDeviceLimits *device_limits = &(GetPDProperties()->limits);
 
     for (uint32_t i = 0; i < count; i++) {
         auto pvids_ci = lvl_find_in_chain<VkPipelineVertexInputDivisorStateCreateInfoEXT>(pipe_cis[i].pVertexInputState->pNext);
diff --git a/layers/core_validation.h b/layers/core_validation.h
index 782b51f87..633778444 100644
--- a/layers/core_validation.h
+++ b/layers/core_validation.h
@@ -511,13 +511,13 @@ class CoreChecks : public ValidationObject {
     bool ValidateCmd(layer_data* dev_data, const GLOBAL_CB_NODE* cb_state, const CMD_TYPE cmd, const char* caller_name);
 
     // Prototypes for layer_data accessor functions.  These should be in their own header file at some point
-    VkFormatProperties GetPDFormatProperties(const layer_data* device_data, const VkFormat format);
-    VkResult GetPDImageFormatProperties(layer_data*, const VkImageCreateInfo*, VkImageFormatProperties*);
-    VkResult GetPDImageFormatProperties2(layer_data*, const VkPhysicalDeviceImageFormatInfo2*, VkImageFormatProperties2*);
+    VkFormatProperties GetPDFormatProperties(const VkFormat format);
+    VkResult GetPDImageFormatProperties(const VkImageCreateInfo*, VkImageFormatProperties*);
+    VkResult GetPDImageFormatProperties2(const VkPhysicalDeviceImageFormatInfo2*, VkImageFormatProperties2*);
     const debug_report_data* GetReportData(const layer_data*);
     const VkLayerDispatchTable* GetDispatchTable(const layer_data*);
-    const VkPhysicalDeviceProperties* GetPDProperties(const layer_data*);
-    const VkPhysicalDeviceMemoryProperties* GetPhysicalDeviceMemoryProperties(const layer_data*);
+    const VkPhysicalDeviceProperties* GetPDProperties();
+    const VkPhysicalDeviceMemoryProperties* GetPhysicalDeviceMemoryProperties();
     const CHECK_DISABLED* GetDisables(layer_data*);
     const CHECK_ENABLED* GetEnables(layer_data*);
     std::unordered_map<VkImage, std::unique_ptr<IMAGE_STATE>>* GetImageMap(layer_data*);
diff --git a/layers/gpu_validation.cpp b/layers/gpu_validation.cpp
index 4a6925d3b..83e8a6960 100644
--- a/layers/gpu_validation.cpp
+++ b/layers/gpu_validation.cpp
@@ -36,7 +36,7 @@ static const uint32_t kNumBindingsInSet = 1;
 
 // Implementation for Device Memory Manager class
 GpuDeviceMemoryManager::GpuDeviceMemoryManager(layer_data *dev_data, uint32_t data_size) {
-    uint32_t align = static_cast<uint32_t>(dev_data->GetPDProperties(dev_data)->limits.minStorageBufferOffsetAlignment);
+    uint32_t align = static_cast<uint32_t>(dev_data->GetPDProperties()->limits.minStorageBufferOffsetAlignment);
     if (0 == align) {
         align = 1;
     }
@@ -124,7 +124,7 @@ bool BlockUsed(GpuDeviceMemoryBlock &block) { return (block.buffer != VK_NULL_HA
 
 bool GpuDeviceMemoryManager::MemoryTypeFromProperties(uint32_t typeBits, VkFlags requirements_mask, uint32_t *typeIndex) {
     // Search memtypes to find first index with those properties
-    const VkPhysicalDeviceMemoryProperties *props = dev_data_->GetPhysicalDeviceMemoryProperties(dev_data_);
+    const VkPhysicalDeviceMemoryProperties *props = dev_data_->GetPhysicalDeviceMemoryProperties();
     for (uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; i++) {
         if ((typeBits & 1) == 1) {
             // Type is available, does it match user properties?
@@ -336,7 +336,7 @@ void CoreChecks::GpuPostCallRecordCreateDevice(layer_data *dev_data) {
     gpu_state->barrier_command_pool = VK_NULL_HANDLE;
     gpu_state->barrier_command_buffer = VK_NULL_HANDLE;
 
-    if (GetPDProperties(dev_data)->apiVersion < VK_API_VERSION_1_1) {
+    if (GetPDProperties()->apiVersion < VK_API_VERSION_1_1) {
         ReportSetupProblem(dev_data, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, HandleToUint64(GetDevice(dev_data)),
                            "GPU-Assisted validation requires Vulkan 1.1 or later.  GPU-Assisted Validation disabled.");
         gpu_state->aborted = true;
@@ -344,7 +344,7 @@ void CoreChecks::GpuPostCallRecordCreateDevice(layer_data *dev_data) {
     }
     // Some devices have extremely high limits here, so set a reasonable max because we have to pad
     // the pipeline layout with dummy descriptor set layouts.
-    gpu_state->adjusted_max_desc_sets = GetPDProperties(dev_data)->limits.maxBoundDescriptorSets;
+    gpu_state->adjusted_max_desc_sets = GetPDProperties()->limits.maxBoundDescriptorSets;
     gpu_state->adjusted_max_desc_sets = std::min(33U, gpu_state->adjusted_max_desc_sets);
 
     // We can't do anything if there is only one.
@@ -1030,7 +1030,7 @@ void CoreChecks::ProcessInstrumentationBuffer(const layer_data *dev_data, VkQueu
             uint32_t block_offset = buffer_info.mem_block.offset;
             uint32_t block_size = gpu_state->memory_manager->GetBlockSize();
             uint32_t offset_to_data = 0;
-            const uint32_t map_align = std::max(1U, static_cast<uint32_t>(GetPDProperties(dev_data)->limits.minMemoryMapAlignment));
+            const uint32_t map_align = std::max(1U, static_cast<uint32_t>(GetPDProperties()->limits.minMemoryMapAlignment));
 
             // Adjust the offset to the alignment required for mapping.
             block_offset = (block_offset / map_align) * map_align;