layers: Rename param_checker to parameter_validation

Also, param_check.h -> parameter_validation.h and .json files changed. Change-Id: I9db10563bcc2640fe6b90588d3c80c4fe50a8a83
author: Mark Lobodzinski <mark@lunarg.com> 2016-03-17 15:08:18 -0600
committer: Mark Lobodzinski <mark@lunarg.com> 2016-03-21 11:31:42 -0600
commit: aaab5c00073a61ef75adf497d2c70d0824cd2e67 (patch)
tree: 61acd42d2854abdac2fb0c0a2496875ae2783d82
parent: 1e22882a98a0f329d6f212355bfe456d690902b3 (diff)
download: usermoji-aaab5c00073a61ef75adf497d2c70d0824cd2e67.tar.xz
18 files changed, 145 insertions, 145 deletions
diff --git a/buildAndroid/android-generate.bat b/buildAndroid/android-generate.bat
index e8a33b01..bf053528 100644
--- a/buildAndroid/android-generate.bat
+++ b/buildAndroid/android-generate.bat
@@ -29,5 +29,5 @@ python ../vk-layer-generate.py Android unique_objects ../include/vulkan/vulkan.h
 
 cd generated
 python ../../genvk.py threading -registry ../../vk.xml thread_check.h
-python ../../genvk.py paramchecker -registry ../../vk.xml param_check.h
-cd ..
-\ No newline at end of file
+python ../../genvk.py paramchecker -registry ../../vk.xml parameter_validation.h
+cd ..
diff --git a/buildAndroid/android-generate.sh b/buildAndroid/android-generate.sh
index 694149f6..e5d3886f 100755
--- a/buildAndroid/android-generate.sh
+++ b/buildAndroid/android-generate.sh
@@ -25,5 +25,5 @@ python ../vk_helper.py --gen_struct_wrappers ../include/vulkan/vulkan.h --abs_ou
 python ../vk-layer-generate.py Android object_tracker ../include/vulkan/vulkan.h > generated/object_tracker.cpp
 python ../vk-layer-generate.py Android unique_objects ../include/vulkan/vulkan.h > generated/unique_objects.cpp
 ( cd generated; python ../../genvk.py threading -registry ../../vk.xml thread_check.h )
-( cd generated; python ../../genvk.py paramchecker -registry ../../vk.xml param_check.h )
+( cd generated; python ../../genvk.py paramchecker -registry ../../vk.xml parameter_validation.h )
 
diff --git a/buildAndroid/jni/Android.mk b/buildAndroid/jni/Android.mk
index 9c681285..deb00f1b 100644
--- a/buildAndroid/jni/Android.mk
+++ b/buildAndroid/jni/Android.mk
@@ -65,8 +65,8 @@ LOCAL_LDLIBS    := -llog
 include $(BUILD_SHARED_LIBRARY)
 
 include $(CLEAR_VARS)
-LOCAL_MODULE := VkLayer_param_checker
-LOCAL_SRC_FILES += $(SRC_DIR)/layers/param_checker.cpp
+LOCAL_MODULE := VkLayer_parameter_validation
+LOCAL_SRC_FILES += $(SRC_DIR)/layers/parameter_validation.cpp
 LOCAL_SRC_FILES += $(SRC_DIR)/layers/vk_layer_table.cpp
 LOCAL_C_INCLUDES += $(SRC_DIR)/include \
                     $(SRC_DIR)/buildAndroid/generated \
diff --git a/buildAndroid/jni/Application.mk b/buildAndroid/jni/Application.mk
index 320db267..13ec240d 100644
--- a/buildAndroid/jni/Application.mk
+++ b/buildAndroid/jni/Application.mk
@@ -16,6 +16,6 @@
 APP_ABI := armeabi-v7a arm64-v8a x86 x86_64 mips mips64
 APP_PLATFORM := android-22
 APP_STL := gnustl_static
-APP_MODULES := layer_utils VkLayer_core_validation VkLayer_device_limits VkLayer_image VkLayer_param_checker VkLayer_object_tracker VkLayer_threading VkLayer_swapchain VkLayer_unique_objects
+APP_MODULES := layer_utils VkLayer_core_validation VkLayer_device_limits VkLayer_image VkLayer_parameter_validation VkLayer_object_tracker VkLayer_threading VkLayer_swapchain VkLayer_unique_objects
 APP_CPPFLAGS += -std=c++11 -DVK_PROTOTYPES -Wall -Werror -Wno-unused-function -Wno-unused-const-variable
 NDK_TOOLCHAIN_VERSION := clang
diff --git a/demos/cube.c b/demos/cube.c
index 70ca2f64..2c5c55a3 100644
--- a/demos/cube.c
+++ b/demos/cube.c
@@ -2134,7 +2134,7 @@ static void demo_init_vk(struct demo *demo) {
     uint32_t enabled_layer_count = 0;
 
     char *instance_validation_layers[] = {
-        "VK_LAYER_GOOGLE_threading",     "VK_LAYER_LUNARG_param_checker",
+        "VK_LAYER_GOOGLE_threading",     "VK_LAYER_LUNARG_parameter_validation",
         "VK_LAYER_LUNARG_device_limits", "VK_LAYER_LUNARG_object_tracker",
         "VK_LAYER_LUNARG_image",         "VK_LAYER_LUNARG_core_validation",
         "VK_LAYER_LUNARG_swapchain",
@@ -2142,7 +2142,7 @@ static void demo_init_vk(struct demo *demo) {
     };
 
     demo->device_validation_layers[0] = "VK_LAYER_GOOGLE_threading";
-    demo->device_validation_layers[1] = "VK_LAYER_LUNARG_param_checker";
+    demo->device_validation_layers[1] = "VK_LAYER_LUNARG_parameter_validation";
     demo->device_validation_layers[2] = "VK_LAYER_LUNARG_device_limits";
     demo->device_validation_layers[3] = "VK_LAYER_LUNARG_object_tracker";
     demo->device_validation_layers[4] = "VK_LAYER_LUNARG_image";
diff --git a/demos/tri.c b/demos/tri.c
index aa0fbced..c1a73ed0 100644
--- a/demos/tri.c
+++ b/demos/tri.c
@@ -1727,7 +1727,7 @@ static void demo_init_vk(struct demo *demo) {
     };
 
     char *instance_validation_layers_alt2[] = {
-        "VK_LAYER_GOOGLE_threading",     "VK_LAYER_LUNARG_param_checker",
+        "VK_LAYER_GOOGLE_threading",     "VK_LAYER_LUNARG_parameter_validation",
         "VK_LAYER_LUNARG_device_limits", "VK_LAYER_LUNARG_object_tracker",
         "VK_LAYER_LUNARG_image",         "VK_LAYER_LUNARG_core_validation",
         "VK_LAYER_LUNARG_swapchain",     "VK_LAYER_GOOGLE_unique_objects"
diff --git a/generator.py b/generator.py
index a9c3852f..8e4cebaf 100644
--- a/generator.py
+++ b/generator.py
@@ -327,7 +327,7 @@ class ThreadGeneratorOptions(GeneratorOptions):
 
 # ParamCheckerGeneratorOptions - subclass of GeneratorOptions.
 #
-# Adds options used by ParamCheckerOutputGenerator objects during param checker
+# Adds options used by ParamCheckerOutputGenerator objects during parameter validation
 # generation.
 #
 # Additional members
@@ -2760,7 +2760,7 @@ class ParamCheckerOutputGenerator(OutputGenerator):
         # Headers
         write('#include "vulkan/vulkan.h"', file=self.outFile)
         write('#include "vk_layer_extension_utils.h"', file=self.outFile)
-        write('#include "param_checker_utils.h"', file=self.outFile)
+        write('#include "parameter_validation_utils.h"', file=self.outFile)
         #
         # Macros
         self.newline()
@@ -3031,13 +3031,13 @@ class ParamCheckerOutputGenerator(OutputGenerator):
                 lenParam = self.getParamByName(params, name)
         return lenParam
     #
-    # Convert a vulkan.h command declaration into a param_check.h definition
+    # Convert a vulkan.h command declaration into a parameter_validation.h definition
     def getCmdDef(self, cmd):
         #
         # Strip the trailing ';' and split into individual lines
         lines = cmd.cdecl[:-1].split('\n')
         # Replace Vulkan prototype
-        lines[0] = 'static VkBool32 param_check_' + cmd.name + '('
+        lines[0] = 'static VkBool32 parameter_validation_' + cmd.name + '('
         # Replace the first argument with debug_report_data, when the first
         # argument is a handle (not vkCreateInstance)
         reportData = '    debug_report_data*'.ljust(self.genOpts.alignFuncParam) + 'report_data,'
@@ -3168,11 +3168,11 @@ class ParamCheckerOutputGenerator(OutputGenerator):
                     #
                     # The name prefix used when reporting an error with a struct member (eg. the 'pCreateInfor->' in 'pCreateInfo->sType')
                     prefix = '(std::string({}) + std::string("{}->")).c_str()'.format(variablePrefix, value.name) if variablePrefix else '"{}->"'.format(value.name)
-                    checkExpr += 'skipCall |= param_check_{}(report_data, {}, {}, {}{});\n'.format(value.type, name, prefix, valuePrefix, value.name)
+                    checkExpr += 'skipCall |= parameter_validation_{}(report_data, {}, {}, {}{});\n'.format(value.type, name, prefix, valuePrefix, value.name)
             elif value.type in self.validatedStructs:
                 # The name prefix used when reporting an error with a struct member (eg. the 'pCreateInfor->' in 'pCreateInfo->sType')
                 prefix = '(std::string({}) + std::string("{}.")).c_str()'.format(variablePrefix, value.name) if variablePrefix else '"{}."'.format(value.name)
-                checkExpr += 'skipCall |= param_check_{}(report_data, {}, {}, &({}{}));\n'.format(value.type, name, prefix, valuePrefix, value.name)
+                checkExpr += 'skipCall |= parameter_validation_{}(report_data, {}, {}, &({}{}));\n'.format(value.type, name, prefix, valuePrefix, value.name)
             #
             # Append the parameter check to the function body for the current command
             if checkExpr:
@@ -3228,7 +3228,7 @@ class ParamCheckerOutputGenerator(OutputGenerator):
             # for a NULL pointer, so needs its indent incremented
             funcBody, unused = self.genFuncBody(self.incIndent(indent), 'pFuncName', struct.members, 'pStruct->', 'pVariableName', struct.name)
             if funcBody:
-                cmdDef = 'static VkBool32 param_check_{}(\n'.format(struct.name)
+                cmdDef = 'static VkBool32 parameter_validation_{}(\n'.format(struct.name)
                 cmdDef += '    debug_report_data*'.ljust(self.genOpts.alignFuncParam) + ' report_data,\n'
                 cmdDef += '    const char*'.ljust(self.genOpts.alignFuncParam) + ' pFuncName,\n'
                 cmdDef += '    const char*'.ljust(self.genOpts.alignFuncParam) + ' pVariableName,\n'
@@ -3254,7 +3254,7 @@ class ParamCheckerOutputGenerator(OutputGenerator):
                 cmdDef += '{\n'
                 # Process unused parameters
                 # Ignore the first dispatch handle parameter, which is not
-                # processed by param_check (except for vkCreateInstance, which
+                # processed by parameter_validation (except for vkCreateInstance, which
                 # does not have a handle as its first parameter)
                 startIndex = 1
                 if command.name == 'vkCreateInstance':
diff --git a/genvk.py b/genvk.py
index 7831f406..88e49a06 100755
--- a/genvk.py
+++ b/genvk.py
@@ -273,7 +273,7 @@ buildList = [
     ],
     [ ParamCheckerOutputGenerator,
       ParamCheckerGeneratorOptions(
-        filename          = 'param_check.h',
+        filename          = 'parameter_validation.h',
         apiname           = 'vulkan',
         profile           = None,
         versions          = allVersions,
diff --git a/layers/CMakeLists.txt b/layers/CMakeLists.txt
index 710e168c..27e11289 100644
--- a/layers/CMakeLists.txt
+++ b/layers/CMakeLists.txt
@@ -25,7 +25,7 @@ set(LAYER_JSON_FILES
     VkLayer_image
     VkLayer_object_tracker
     VkLayer_unique_objects
-    VkLayer_param_checker
+    VkLayer_parameter_validation
     VkLayer_swapchain
     VkLayer_threading
     VkLayer_device_limits
@@ -135,7 +135,7 @@ add_custom_target(generate_vk_layer_helpers DEPENDS
 run_vk_layer_generate(object_tracker object_tracker.cpp)
 run_vk_layer_xml_generate(Threading thread_check.h)
 run_vk_layer_generate(unique_objects unique_objects.cpp)
-run_vk_layer_xml_generate(ParamChecker param_check.h)
+run_vk_layer_xml_generate(ParamChecker parameter_validation.h)
 
 add_library(layer_utils SHARED vk_layer_config.cpp vk_layer_extension_utils.cpp vk_layer_utils.cpp)
 if (WIN32)
@@ -153,4 +153,4 @@ add_vk_layer(swapchain swapchain.cpp vk_layer_table.cpp)
 add_vk_layer(object_tracker object_tracker.cpp vk_layer_table.cpp)
 add_vk_layer(threading threading.cpp thread_check.h vk_layer_table.cpp)
 add_vk_layer(unique_objects unique_objects.cpp vk_layer_table.cpp vk_safe_struct.cpp)
-add_vk_layer(param_checker param_checker.cpp param_check.h vk_layer_table.cpp)
+add_vk_layer(parameter_validation parameter_validation.cpp parameter_validation.h vk_layer_table.cpp)
diff --git a/layers/README.md b/layers/README.md
index 71532017..dcc81d72 100644
--- a/layers/README.md
+++ b/layers/README.md
@@ -34,7 +34,7 @@ Note that some layers are code-generated and will therefore exist in the directo
 For complete details of current validation layers, including all of the validation checks that they perform, please refer to the document layers/vk_validation_layer_details.md. Below is a brief overview of each layer.
 
 ### Standard Validation
-This is a meta-layer managed by the loader. (name = VK_LAYER_LUNARG_standard_validation) - specifying this layer name will cause the loader to load the all of the standard validation layers (listed below) in the following optimal order:  VK_LAYER_GOOGLE_threading, VK_LAYER_LUNARG_param_checker, VK_LAYER_LUNARG_device_limits, VK_LAYER_LUNARG_object_tracker, VK_LAYER_LUNARG_image, VK_LAYER_LUNARG_core_validation, VK_LAYER_LUNARG_swapchain, and VK_LAYER_GOOGLE_unique_objects. Other layers can be specified and the loader will remove duplicates.
+This is a meta-layer managed by the loader. (name = VK_LAYER_LUNARG_standard_validation) - specifying this layer name will cause the loader to load the all of the standard validation layers (listed below) in the following optimal order:  VK_LAYER_GOOGLE_threading, VK_LAYER_LUNARG_parameter_validation, VK_LAYER_LUNARG_device_limits, VK_LAYER_LUNARG_object_tracker, VK_LAYER_LUNARG_image, VK_LAYER_LUNARG_core_validation, VK_LAYER_LUNARG_swapchain, and VK_LAYER_GOOGLE_unique_objects. Other layers can be specified and the loader will remove duplicates.
 
 ### Print Object Stats
 (build dir)/layers/object_tracker.cpp (name=VK_LAYER_LUNARG_object_tracker) - Track object creation, use, and destruction. As objects are created, they're stored in a map. As objects are used, the layer verifies they exist in the map, flagging errors for unknown objects. As objects are destroyed, they're removed from the map. At vkDestroyDevice() and vkDestroyInstance() times, if any objects have not been destroyed, they are reported as leaked objects. If a Dbg callback function is registered, this layer will use callback function(s) for reporting, otherwise uses stdout.
@@ -43,7 +43,7 @@ This is a meta-layer managed by the loader. (name = VK_LAYER_LUNARG_standard_val
 layers/core\_validation.cpp (name=VK\_LAYER\_LUNARG\_core\_validation) - The core\_validation layer does the bulk of the API validation that requires storing state. Some of the state it tracks includes the Descriptor Set, Pipeline State, Shaders, and dynamic state, and memory objects and bindings. It performs some point validation as states are created and used, and further validation Draw call and QueueSubmit time. Of primary interest is making sure that the resources bound to Descriptor Sets correctly align with the layout specified for the Set. Also, all of the image and buffer layouts are validated to make sure explicit layout transitions are properly managed. Related to memory, core\_validation includes tracking object bindings, memory hazards, and memory object lifetimes. It also validates several other hazard-related issues related to command buffers, fences, and memory mapping. Additionally core\_validation include shader validation (formerly separate shader\_checker layer) that inspects the SPIR-V shader images and fixed function pipeline stages at PSO creation time. It flags errors when inconsistencies are found across interfaces between shader stages. The exact behavior of the checks depends on the pair of pipeline stages involved. If a Dbg callback function is registered, this layer will use callback function(s) for reporting, otherwise uses stdout.
 
 ### Check parameters
-layers/param_checker.cpp (name=VK_LAYER_LUNARG_param_checker) - Check the input parameters to API calls for validity. If a Dbg callback function is registered, this layer will use callback function(s) for reporting, otherwise uses stdout.
+layers/parameter_validation.cpp (name=VK_LAYER_LUNARG_parameter_validation) - Check the input parameters to API calls for validity. If a Dbg callback function is registered, this layer will use callback function(s) for reporting, otherwise uses stdout.
 
 ### Image parameters
 layers/image.cpp (name=VK_LAYER_LUNARG_image) - The image layer is intended to validate image parameters, formats, and correct use. Images are a significant enough area that they were given a separate layer. If a Dbg callback function is registered, this layer will use callback function(s) for reporting, otherwise uses stdout.
diff --git a/layers/windows/VkLayer_param_checker.json b/layers/linux/VkLayer_parameter_validation.json
index 76a1b018..a268ce40 100644
--- a/layers/windows/VkLayer_param_checker.json
+++ b/layers/linux/VkLayer_parameter_validation.json
@@ -1,9 +1,9 @@
 {
     "file_format_version" : "1.0.0",
     "layer" : {
-        "name": "VK_LAYER_LUNARG_param_checker",
+        "name": "VK_LAYER_LUNARG_parameter_validation",
         "type": "GLOBAL",
-        "library_path": ".\\VkLayer_param_checker.dll",
+        "library_path": "./libVkLayer_parameter_validation.so",
         "api_version": "1.0.5",
         "implementation_version": "1",
         "description": "LunarG Validation Layer",
diff --git a/layers/param_checker.cpp b/layers/parameter_validation.cpp
index 8504f839..9dff60bb 100644
--- a/layers/param_checker.cpp
+++ b/layers/parameter_validation.cpp
@@ -51,7 +51,7 @@
 #include "vk_layer_extension_utils.h"
 #include "vk_layer_utils.h"
 
-#include "param_check.h"
+#include "parameter_validation.h"
 
 struct layer_data {
     debug_report_data *report_data;
@@ -92,9 +92,9 @@ debug_report_data *mdd(void *object) {
     return data->report_data;
 }
 
-static void init_param_checker(layer_data *my_data, const VkAllocationCallbacks *pAllocator) {
+static void init_parameter_validation(layer_data *my_data, const VkAllocationCallbacks *pAllocator) {
 
-    layer_debug_actions(my_data->report_data, my_data->logging_callback, pAllocator, "lunarg_param_checker");
+    layer_debug_actions(my_data->report_data, my_data->logging_callback, pAllocator, "lunarg_parameter_validation");
 }
 
 VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
@@ -136,7 +136,7 @@ vkEnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount,
 }
 
 static const VkLayerProperties pc_global_layers[] = {{
-    "VK_LAYER_LUNARG_param_checker", VK_API_VERSION, 1, "LunarG Validation Layer",
+    "VK_LAYER_LUNARG_parameter_validation", VK_API_VERSION, 1, "LunarG Validation Layer",
 }};
 
 VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
@@ -147,7 +147,7 @@ vkEnumerateInstanceLayerProperties(uint32_t *pCount, VkLayerProperties *pPropert
 VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,
                                                                                     const char *pLayerName, uint32_t *pCount,
                                                                                     VkExtensionProperties *pProperties) {
-    /* param_checker does not have any physical device extensions */
+    /* parameter_validation does not have any physical device extensions */
     if (pLayerName == NULL) {
         return get_dispatch_table(pc_instance_table_map, physicalDevice)
             ->EnumerateDeviceExtensionProperties(physicalDevice, NULL, pCount, pProperties);
@@ -159,7 +159,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionPropert
 VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
 vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount, VkLayerProperties *pProperties) {
 
-    /* param_checker's physical device layers are the same as global */
+    /* parameter_validation's physical device layers are the same as global */
     return util_GetLayerProperties(ARRAY_SIZE(pc_global_layers), pc_global_layers, pCount, pProperties);
 }
 
@@ -1360,11 +1360,11 @@ vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCall
     my_instance_data->report_data =
         debug_report_create_instance(pTable, *pInstance, pCreateInfo->enabledExtensionCount, pCreateInfo->ppEnabledExtensionNames);
 
-    init_param_checker(my_instance_data, pAllocator);
+    init_parameter_validation(my_instance_data, pAllocator);
 
     // Ordinarily we'd check these before calling down the chain, but none of the layer
     // support is in place until now, if we survive we can report the issue now.
-    param_check_vkCreateInstance(my_instance_data->report_data, pCreateInfo, pAllocator, pInstance);
+    parameter_validation_vkCreateInstance(my_instance_data->report_data, pCreateInfo, pAllocator, pInstance);
 
     if (pCreateInfo->pApplicationInfo) {
         if (pCreateInfo->pApplicationInfo->pApplicationName) {
@@ -1388,7 +1388,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(VkInstance instance
     layer_data *my_data = get_my_data_ptr(key, layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkDestroyInstance(my_data->report_data, pAllocator);
+    skipCall |= parameter_validation_vkDestroyInstance(my_data->report_data, pAllocator);
 
     if (skipCall == VK_FALSE) {
         VkLayerInstanceDispatchTable *pTable = get_dispatch_table(pc_instance_table_map, instance);
@@ -1427,7 +1427,7 @@ vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount,
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkEnumeratePhysicalDevices(my_data->report_data, pPhysicalDeviceCount, pPhysicalDevices);
+    skipCall |= parameter_validation_vkEnumeratePhysicalDevices(my_data->report_data, pPhysicalDeviceCount, pPhysicalDevices);
 
     if (skipCall == VK_FALSE) {
         result = get_dispatch_table(pc_instance_table_map, instance)
@@ -1445,7 +1445,7 @@ vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFea
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkGetPhysicalDeviceFeatures(my_data->report_data, pFeatures);
+    skipCall |= parameter_validation_vkGetPhysicalDeviceFeatures(my_data->report_data, pFeatures);
 
     if (skipCall == VK_FALSE) {
         get_dispatch_table(pc_instance_table_map, physicalDevice)->GetPhysicalDeviceFeatures(physicalDevice, pFeatures);
@@ -1470,7 +1470,7 @@ vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat fo
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkGetPhysicalDeviceFormatProperties(my_data->report_data, format, pFormatProperties);
+    skipCall |= parameter_validation_vkGetPhysicalDeviceFormatProperties(my_data->report_data, format, pFormatProperties);
 
     if (skipCall == VK_FALSE) {
         get_dispatch_table(pc_instance_table_map, physicalDevice)
@@ -1521,7 +1521,7 @@ vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkForm
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkGetPhysicalDeviceImageFormatProperties(my_data->report_data, format, type, tiling, usage, flags,
+    skipCall |= parameter_validation_vkGetPhysicalDeviceImageFormatProperties(my_data->report_data, format, type, tiling, usage, flags,
                                                                      pImageFormatProperties);
 
     if (skipCall == VK_FALSE) {
@@ -1557,7 +1557,7 @@ vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceP
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkGetPhysicalDeviceProperties(my_data->report_data, pProperties);
+    skipCall |= parameter_validation_vkGetPhysicalDeviceProperties(my_data->report_data, pProperties);
 
     if (skipCall == VK_FALSE) {
         get_dispatch_table(pc_instance_table_map, physicalDevice)->GetPhysicalDeviceProperties(physicalDevice, pProperties);
@@ -1573,7 +1573,7 @@ vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkGetPhysicalDeviceQueueFamilyProperties(my_data->report_data, pQueueFamilyPropertyCount,
+    skipCall |= parameter_validation_vkGetPhysicalDeviceQueueFamilyProperties(my_data->report_data, pQueueFamilyPropertyCount,
                                                                      pQueueFamilyProperties);
 
     if (skipCall == VK_FALSE) {
@@ -1588,7 +1588,7 @@ vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalD
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkGetPhysicalDeviceMemoryProperties(my_data->report_data, pMemoryProperties);
+    skipCall |= parameter_validation_vkGetPhysicalDeviceMemoryProperties(my_data->report_data, pMemoryProperties);
 
     if (skipCall == VK_FALSE) {
         get_dispatch_table(pc_instance_table_map, physicalDevice)
@@ -1673,7 +1673,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(VkPhysicalDevice p
     layer_data *my_instance_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
     assert(my_instance_data != nullptr);
 
-    skipCall |= param_check_vkCreateDevice(my_instance_data->report_data, pCreateInfo, pAllocator, pDevice);
+    skipCall |= parameter_validation_vkCreateDevice(my_instance_data->report_data, pCreateInfo, pAllocator, pDevice);
 
     if (pCreateInfo != NULL) {
         if ((pCreateInfo->enabledLayerCount > 0) && (pCreateInfo->ppEnabledLayerNames != NULL)) {
@@ -1737,7 +1737,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(VkDevice device, cons
     layer_data *my_data = get_my_data_ptr(key, layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkDestroyDevice(my_data->report_data, pAllocator);
+    skipCall |= parameter_validation_vkDestroyDevice(my_data->report_data, pAllocator);
 
     if (skipCall == VK_FALSE) {
         layer_debug_report_destroy_device(device);
@@ -1781,7 +1781,7 @@ vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkGetDeviceQueue(my_data->report_data, queueFamilyIndex, queueIndex, pQueue);
+    skipCall |= parameter_validation_vkGetDeviceQueue(my_data->report_data, queueFamilyIndex, queueIndex, pQueue);
 
     if (skipCall == VK_FALSE) {
         PreGetDeviceQueue(device, queueFamilyIndex, queueIndex);
@@ -1808,7 +1808,7 @@ vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits,
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(queue), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkQueueSubmit(my_data->report_data, submitCount, pSubmits, fence);
+    skipCall |= parameter_validation_vkQueueSubmit(my_data->report_data, submitCount, pSubmits, fence);
 
     if (skipCall == VK_FALSE) {
         result = get_dispatch_table(pc_device_table_map, queue)->QueueSubmit(queue, submitCount, pSubmits, fence);
@@ -1877,7 +1877,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory(VkDevice device,
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkAllocateMemory(my_data->report_data, pAllocateInfo, pAllocator, pMemory);
+    skipCall |= parameter_validation_vkAllocateMemory(my_data->report_data, pAllocateInfo, pAllocator, pMemory);
 
     if (skipCall == VK_FALSE) {
         result = get_dispatch_table(pc_device_table_map, device)->AllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
@@ -1894,7 +1894,7 @@ vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkFreeMemory(my_data->report_data, memory, pAllocator);
+    skipCall |= parameter_validation_vkFreeMemory(my_data->report_data, memory, pAllocator);
 
     if (skipCall == VK_FALSE) {
         get_dispatch_table(pc_device_table_map, device)->FreeMemory(device, memory, pAllocator);
@@ -1920,7 +1920,7 @@ vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDevic
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkMapMemory(my_data->report_data, memory, offset, size, flags, ppData);
+    skipCall |= parameter_validation_vkMapMemory(my_data->report_data, memory, offset, size, flags, ppData);
 
     if (skipCall == VK_FALSE) {
         result = get_dispatch_table(pc_device_table_map, device)->MapMemory(device, memory, offset, size, flags, ppData);
@@ -1950,7 +1950,7 @@ vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMa
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkFlushMappedMemoryRanges(my_data->report_data, memoryRangeCount, pMemoryRanges);
+    skipCall |= parameter_validation_vkFlushMappedMemoryRanges(my_data->report_data, memoryRangeCount, pMemoryRanges);
 
     if (skipCall == VK_FALSE) {
         result = get_dispatch_table(pc_device_table_map, device)->FlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
@@ -1980,7 +1980,7 @@ vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkInvalidateMappedMemoryRanges(my_data->report_data, memoryRangeCount, pMemoryRanges);
+    skipCall |= parameter_validation_vkInvalidateMappedMemoryRanges(my_data->report_data, memoryRangeCount, pMemoryRanges);
 
     if (skipCall == VK_FALSE) {
         result =
@@ -1998,7 +1998,7 @@ vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkGetDeviceMemoryCommitment(my_data->report_data, memory, pCommittedMemoryInBytes);
+    skipCall |= parameter_validation_vkGetDeviceMemoryCommitment(my_data->report_data, memory, pCommittedMemoryInBytes);
 
     if (skipCall == VK_FALSE) {
         get_dispatch_table(pc_device_table_map, device)->GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
@@ -2053,7 +2053,7 @@ vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirem
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkGetBufferMemoryRequirements(my_data->report_data, buffer, pMemoryRequirements);
+    skipCall |= parameter_validation_vkGetBufferMemoryRequirements(my_data->report_data, buffer, pMemoryRequirements);
 
     if (skipCall == VK_FALSE) {
         get_dispatch_table(pc_device_table_map, device)->GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
@@ -2066,7 +2066,7 @@ vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirement
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkGetImageMemoryRequirements(my_data->report_data, image, pMemoryRequirements);
+    skipCall |= parameter_validation_vkGetImageMemoryRequirements(my_data->report_data, image, pMemoryRequirements);
 
     if (skipCall == VK_FALSE) {
         get_dispatch_table(pc_device_table_map, device)->GetImageMemoryRequirements(device, image, pMemoryRequirements);
@@ -2096,7 +2096,7 @@ vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t *pSp
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkGetImageSparseMemoryRequirements(my_data->report_data, image, pSparseMemoryRequirementCount,
+    skipCall |= parameter_validation_vkGetImageSparseMemoryRequirements(my_data->report_data, image, pSparseMemoryRequirementCount,
                                                                pSparseMemoryRequirements);
 
     if (skipCall == VK_FALSE) {
@@ -2150,7 +2150,7 @@ vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice,
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkGetPhysicalDeviceSparseImageFormatProperties(my_data->report_data, format, type, samples, usage,
+    skipCall |= parameter_validation_vkGetPhysicalDeviceSparseImageFormatProperties(my_data->report_data, format, type, samples, usage,
                                                                            tiling, pPropertyCount, pProperties);
 
     if (skipCall == VK_FALSE) {
@@ -2182,7 +2182,7 @@ vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(queue), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkQueueBindSparse(my_data->report_data, bindInfoCount, pBindInfo, fence);
+    skipCall |= parameter_validation_vkQueueBindSparse(my_data->report_data, bindInfoCount, pBindInfo, fence);
 
     if (skipCall == VK_FALSE) {
         result = get_dispatch_table(pc_device_table_map, queue)->QueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
@@ -2211,7 +2211,7 @@ vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo, const VkAll
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkCreateFence(my_data->report_data, pCreateInfo, pAllocator, pFence);
+    skipCall |= parameter_validation_vkCreateFence(my_data->report_data, pCreateInfo, pAllocator, pFence);
 
     if (skipCall == VK_FALSE) {
         result = get_dispatch_table(pc_device_table_map, device)->CreateFence(device, pCreateInfo, pAllocator, pFence);
@@ -2227,7 +2227,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyFence(VkDevice device, VkFen
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkDestroyFence(my_data->report_data, fence, pAllocator);
+    skipCall |= parameter_validation_vkDestroyFence(my_data->report_data, fence, pAllocator);
 
     if (skipCall == VK_FALSE) {
         get_dispatch_table(pc_device_table_map, device)->DestroyFence(device, fence, pAllocator);
@@ -2252,7 +2252,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetFences(VkDevice device, ui
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkResetFences(my_data->report_data, fenceCount, pFences);
+    skipCall |= parameter_validation_vkResetFences(my_data->report_data, fenceCount, pFences);
 
     if (skipCall == VK_FALSE) {
         result = get_dispatch_table(pc_device_table_map, device)->ResetFences(device, fenceCount, pFences);
@@ -2302,7 +2302,7 @@ vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, Vk
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkWaitForFences(my_data->report_data, fenceCount, pFences, waitAll, timeout);
+    skipCall |= parameter_validation_vkWaitForFences(my_data->report_data, fenceCount, pFences, waitAll, timeout);
 
     if (skipCall == VK_FALSE) {
         result = get_dispatch_table(pc_device_table_map, device)->WaitForFences(device, fenceCount, pFences, waitAll, timeout);
@@ -2331,7 +2331,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore(VkDevice device
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkCreateSemaphore(my_data->report_data, pCreateInfo, pAllocator, pSemaphore);
+    skipCall |= parameter_validation_vkCreateSemaphore(my_data->report_data, pCreateInfo, pAllocator, pSemaphore);
 
     if (skipCall == VK_FALSE) {
         result = get_dispatch_table(pc_device_table_map, device)->CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
@@ -2348,7 +2348,7 @@ vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCal
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkDestroySemaphore(my_data->report_data, semaphore, pAllocator);
+    skipCall |= parameter_validation_vkDestroySemaphore(my_data->report_data, semaphore, pAllocator);
 
     if (skipCall == VK_FALSE) {
         get_dispatch_table(pc_device_table_map, device)->DestroySemaphore(device, semaphore, pAllocator);
@@ -2373,7 +2373,7 @@ vkCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo, const VkAll
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkCreateEvent(my_data->report_data, pCreateInfo, pAllocator, pEvent);
+    skipCall |= parameter_validation_vkCreateEvent(my_data->report_data, pCreateInfo, pAllocator, pEvent);
 
     if (skipCall == VK_FALSE) {
         result = get_dispatch_table(pc_device_table_map, device)->CreateEvent(device, pCreateInfo, pAllocator, pEvent);
@@ -2389,7 +2389,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyEvent(VkDevice device, VkEve
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkDestroyEvent(my_data->report_data, event, pAllocator);
+    skipCall |= parameter_validation_vkDestroyEvent(my_data->report_data, event, pAllocator);
 
     if (skipCall == VK_FALSE) {
         get_dispatch_table(pc_device_table_map, device)->DestroyEvent(device, event, pAllocator);
@@ -2486,7 +2486,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool(VkDevice device
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkCreateQueryPool(my_data->report_data, pCreateInfo, pAllocator, pQueryPool);
+    skipCall |= parameter_validation_vkCreateQueryPool(my_data->report_data, pCreateInfo, pAllocator, pQueryPool);
 
     if (skipCall == VK_FALSE) {
         PreCreateQueryPool(device, pCreateInfo);
@@ -2505,7 +2505,7 @@ vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCal
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkDestroyQueryPool(my_data->report_data, queryPool, pAllocator);
+    skipCall |= parameter_validation_vkDestroyQueryPool(my_data->report_data, queryPool, pAllocator);
 
     if (skipCall == VK_FALSE) {
         get_dispatch_table(pc_device_table_map, device)->DestroyQueryPool(device, queryPool, pAllocator);
@@ -2533,7 +2533,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults(VkDevice de
     assert(my_data != NULL);
 
     skipCall |=
-        param_check_vkGetQueryPoolResults(my_data->report_data, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
+        parameter_validation_vkGetQueryPoolResults(my_data->report_data, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
 
     if (skipCall == VK_FALSE) {
         result = get_dispatch_table(pc_device_table_map, device)
@@ -2575,7 +2575,7 @@ vkCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo, const VkA
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkCreateBuffer(my_data->report_data, pCreateInfo, pAllocator, pBuffer);
+    skipCall |= parameter_validation_vkCreateBuffer(my_data->report_data, pCreateInfo, pAllocator, pBuffer);
 
     if (skipCall == VK_FALSE) {
         PreCreateBuffer(device, pCreateInfo);
@@ -2594,7 +2594,7 @@ vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *p
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkDestroyBuffer(my_data->report_data, buffer, pAllocator);
+    skipCall |= parameter_validation_vkDestroyBuffer(my_data->report_data, buffer, pAllocator);
 
     if (skipCall == VK_FALSE) {
         get_dispatch_table(pc_device_table_map, device)->DestroyBuffer(device, buffer, pAllocator);
@@ -2631,7 +2631,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView(VkDevice devic
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkCreateBufferView(my_data->report_data, pCreateInfo, pAllocator, pView);
+    skipCall |= parameter_validation_vkCreateBufferView(my_data->report_data, pCreateInfo, pAllocator, pView);
 
     if (skipCall == VK_FALSE) {
         PreCreateBufferView(device, pCreateInfo);
@@ -2650,7 +2650,7 @@ vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocation
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkDestroyBufferView(my_data->report_data, bufferView, pAllocator);
+    skipCall |= parameter_validation_vkDestroyBufferView(my_data->report_data, bufferView, pAllocator);
 
     if (skipCall == VK_FALSE) {
         get_dispatch_table(pc_device_table_map, device)->DestroyBufferView(device, bufferView, pAllocator);
@@ -2702,7 +2702,7 @@ vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo, const VkAll
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkCreateImage(my_data->report_data, pCreateInfo, pAllocator, pImage);
+    skipCall |= parameter_validation_vkCreateImage(my_data->report_data, pCreateInfo, pAllocator, pImage);
 
     if (skipCall == VK_FALSE) {
         PreCreateImage(device, pCreateInfo);
@@ -2720,7 +2720,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyImage(VkDevice device, VkIma
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkDestroyImage(my_data->report_data, image, pAllocator);
+    skipCall |= parameter_validation_vkDestroyImage(my_data->report_data, image, pAllocator);
 
     if (skipCall == VK_FALSE) {
         get_dispatch_table(pc_device_table_map, device)->DestroyImage(device, image, pAllocator);
@@ -2746,7 +2746,7 @@ vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubreso
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkGetImageSubresourceLayout(my_data->report_data, image, pSubresource, pLayout);
+    skipCall |= parameter_validation_vkGetImageSubresourceLayout(my_data->report_data, image, pSubresource, pLayout);
 
     if (skipCall == VK_FALSE) {
         PreGetImageSubresourceLayout(device, pSubresource);
@@ -2814,7 +2814,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView(VkDevice device
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkCreateImageView(my_data->report_data, pCreateInfo, pAllocator, pView);
+    skipCall |= parameter_validation_vkCreateImageView(my_data->report_data, pCreateInfo, pAllocator, pView);
 
     if (skipCall == VK_FALSE) {
         PreCreateImageView(device, pCreateInfo);
@@ -2833,7 +2833,7 @@ vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCal
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkDestroyImageView(my_data->report_data, imageView, pAllocator);
+    skipCall |= parameter_validation_vkDestroyImageView(my_data->report_data, imageView, pAllocator);
 
     if (skipCall == VK_FALSE) {
         get_dispatch_table(pc_device_table_map, device)->DestroyImageView(device, imageView, pAllocator);
@@ -2859,7 +2859,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule(VkDevice dev
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkCreateShaderModule(my_data->report_data, pCreateInfo, pAllocator, pShaderModule);
+    skipCall |= parameter_validation_vkCreateShaderModule(my_data->report_data, pCreateInfo, pAllocator, pShaderModule);
 
     if (skipCall == VK_FALSE) {
         result =
@@ -2877,7 +2877,7 @@ vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllo
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkDestroyShaderModule(my_data->report_data, shaderModule, pAllocator);
+    skipCall |= parameter_validation_vkDestroyShaderModule(my_data->report_data, shaderModule, pAllocator);
 
     if (skipCall == VK_FALSE) {
         get_dispatch_table(pc_device_table_map, device)->DestroyShaderModule(device, shaderModule, pAllocator);
@@ -2903,7 +2903,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache(VkDevice de
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkCreatePipelineCache(my_data->report_data, pCreateInfo, pAllocator, pPipelineCache);
+    skipCall |= parameter_validation_vkCreatePipelineCache(my_data->report_data, pCreateInfo, pAllocator, pPipelineCache);
 
     if (skipCall == VK_FALSE) {
         result =
@@ -2921,7 +2921,7 @@ vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkA
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkDestroyPipelineCache(my_data->report_data, pipelineCache, pAllocator);
+    skipCall |= parameter_validation_vkDestroyPipelineCache(my_data->report_data, pipelineCache, pAllocator);
 
     if (skipCall == VK_FALSE) {
         get_dispatch_table(pc_device_table_map, device)->DestroyPipelineCache(device, pipelineCache, pAllocator);
@@ -2946,7 +2946,7 @@ vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t *p
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkGetPipelineCacheData(my_data->report_data, pipelineCache, pDataSize, pData);
+    skipCall |= parameter_validation_vkGetPipelineCacheData(my_data->report_data, pipelineCache, pDataSize, pData);
 
     if (skipCall == VK_FALSE) {
         result = get_dispatch_table(pc_device_table_map, device)->GetPipelineCacheData(device, pipelineCache, pDataSize, pData);
@@ -2976,7 +2976,7 @@ vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCac
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkMergePipelineCaches(my_data->report_data, dstCache, srcCacheCount, pSrcCaches);
+    skipCall |= parameter_validation_vkMergePipelineCaches(my_data->report_data, dstCache, srcCacheCount, pSrcCaches);
 
     if (skipCall == VK_FALSE) {
         result = get_dispatch_table(pc_device_table_map, device)->MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
@@ -3223,7 +3223,7 @@ vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkCreateGraphicsPipelines(my_data->report_data, pipelineCache, createInfoCount, pCreateInfos,
+    skipCall |= parameter_validation_vkCreateGraphicsPipelines(my_data->report_data, pipelineCache, createInfoCount, pCreateInfos,
                                                       pAllocator, pPipelines);
 
     if (skipCall == VK_FALSE) {
@@ -3271,7 +3271,7 @@ vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkCreateComputePipelines(my_data->report_data, pipelineCache, createInfoCount, pCreateInfos, pAllocator,
+    skipCall |= parameter_validation_vkCreateComputePipelines(my_data->report_data, pipelineCache, createInfoCount, pCreateInfos, pAllocator,
                                                      pPipelines);
 
     if (skipCall == VK_FALSE) {
@@ -3292,7 +3292,7 @@ vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallba
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkDestroyPipeline(my_data->report_data, pipeline, pAllocator);
+    skipCall |= parameter_validation_vkDestroyPipeline(my_data->report_data, pipeline, pAllocator);
 
     if (skipCall == VK_FALSE) {
         get_dispatch_table(pc_device_table_map, device)->DestroyPipeline(device, pipeline, pAllocator);
@@ -3318,7 +3318,7 @@ vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo *pCreat
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkCreatePipelineLayout(my_data->report_data, pCreateInfo, pAllocator, pPipelineLayout);
+    skipCall |= parameter_validation_vkCreatePipelineLayout(my_data->report_data, pCreateInfo, pAllocator, pPipelineLayout);
 
     if (skipCall == VK_FALSE) {
         result =
@@ -3336,7 +3336,7 @@ vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkDestroyPipelineLayout(my_data->report_data, pipelineLayout, pAllocator);
+    skipCall |= parameter_validation_vkDestroyPipelineLayout(my_data->report_data, pipelineLayout, pAllocator);
 
     if (skipCall == VK_FALSE) {
         get_dispatch_table(pc_device_table_map, device)->DestroyPipelineLayout(device, pipelineLayout, pAllocator);
@@ -3429,7 +3429,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler(VkDevice device,
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkCreateSampler(my_data->report_data, pCreateInfo, pAllocator, pSampler);
+    skipCall |= parameter_validation_vkCreateSampler(my_data->report_data, pCreateInfo, pAllocator, pSampler);
 
     if (skipCall == VK_FALSE) {
         PreCreateSampler(device, pCreateInfo);
@@ -3448,7 +3448,7 @@ vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkDestroySampler(my_data->report_data, sampler, pAllocator);
+    skipCall |= parameter_validation_vkDestroySampler(my_data->report_data, sampler, pAllocator);
 
     if (skipCall == VK_FALSE) {
         get_dispatch_table(pc_device_table_map, device)->DestroySampler(device, sampler, pAllocator);
@@ -3490,7 +3490,7 @@ vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateIn
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkCreateDescriptorSetLayout(my_data->report_data, pCreateInfo, pAllocator, pSetLayout);
+    skipCall |= parameter_validation_vkCreateDescriptorSetLayout(my_data->report_data, pCreateInfo, pAllocator, pSetLayout);
 
     if (skipCall == VK_FALSE) {
         PreCreateDescriptorSetLayout(device, pCreateInfo);
@@ -3510,7 +3510,7 @@ vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSe
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkDestroyDescriptorSetLayout(my_data->report_data, descriptorSetLayout, pAllocator);
+    skipCall |= parameter_validation_vkDestroyDescriptorSetLayout(my_data->report_data, descriptorSetLayout, pAllocator);
 
     if (skipCall == VK_FALSE) {
         get_dispatch_table(pc_device_table_map, device)->DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
@@ -3555,7 +3555,7 @@ vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo *pCreat
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkCreateDescriptorPool(my_data->report_data, pCreateInfo, pAllocator, pDescriptorPool);
+    skipCall |= parameter_validation_vkCreateDescriptorPool(my_data->report_data, pCreateInfo, pAllocator, pDescriptorPool);
 
     if (skipCall == VK_FALSE) {
         PreCreateDescriptorPool(device, pCreateInfo);
@@ -3575,7 +3575,7 @@ vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkDestroyDescriptorPool(my_data->report_data, descriptorPool, pAllocator);
+    skipCall |= parameter_validation_vkDestroyDescriptorPool(my_data->report_data, descriptorPool, pAllocator);
 
     if (skipCall == VK_FALSE) {
         get_dispatch_table(pc_device_table_map, device)->DestroyDescriptorPool(device, descriptorPool, pAllocator);
@@ -3622,7 +3622,7 @@ vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAl
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkAllocateDescriptorSets(my_data->report_data, pAllocateInfo, pDescriptorSets);
+    skipCall |= parameter_validation_vkAllocateDescriptorSets(my_data->report_data, pAllocateInfo, pDescriptorSets);
 
     if (skipCall == VK_FALSE) {
         result = get_dispatch_table(pc_device_table_map, device)->AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
@@ -3654,7 +3654,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets(VkDevice dev
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkFreeDescriptorSets(my_data->report_data, descriptorPool, descriptorSetCount, pDescriptorSets);
+    skipCall |= parameter_validation_vkFreeDescriptorSets(my_data->report_data, descriptorPool, descriptorSetCount, pDescriptorSets);
 
     if (skipCall == VK_FALSE) {
         result = get_dispatch_table(pc_device_table_map, device)
@@ -3700,7 +3700,7 @@ vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkW
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkUpdateDescriptorSets(my_data->report_data, descriptorWriteCount, pDescriptorWrites,
+    skipCall |= parameter_validation_vkUpdateDescriptorSets(my_data->report_data, descriptorWriteCount, pDescriptorWrites,
                                                    descriptorCopyCount, pDescriptorCopies);
 
     if (skipCall == VK_FALSE) {
@@ -3730,7 +3730,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer(VkDevice devi
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkCreateFramebuffer(my_data->report_data, pCreateInfo, pAllocator, pFramebuffer);
+    skipCall |= parameter_validation_vkCreateFramebuffer(my_data->report_data, pCreateInfo, pAllocator, pFramebuffer);
 
     if (skipCall == VK_FALSE) {
         result = get_dispatch_table(pc_device_table_map, device)->CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
@@ -3747,7 +3747,7 @@ vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocat
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkDestroyFramebuffer(my_data->report_data, framebuffer, pAllocator);
+    skipCall |= parameter_validation_vkDestroyFramebuffer(my_data->report_data, framebuffer, pAllocator);
 
     if (skipCall == VK_FALSE) {
         get_dispatch_table(pc_device_table_map, device)->DestroyFramebuffer(device, framebuffer, pAllocator);
@@ -3880,7 +3880,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(VkDevice devic
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkCreateRenderPass(my_data->report_data, pCreateInfo, pAllocator, pRenderPass);
+    skipCall |= parameter_validation_vkCreateRenderPass(my_data->report_data, pCreateInfo, pAllocator, pRenderPass);
 
     if (skipCall == VK_FALSE) {
         PreCreateRenderPass(device, pCreateInfo);
@@ -3899,7 +3899,7 @@ vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocation
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkDestroyRenderPass(my_data->report_data, renderPass, pAllocator);
+    skipCall |= parameter_validation_vkDestroyRenderPass(my_data->report_data, renderPass, pAllocator);
 
     if (skipCall == VK_FALSE) {
         get_dispatch_table(pc_device_table_map, device)->DestroyRenderPass(device, renderPass, pAllocator);
@@ -3912,7 +3912,7 @@ vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkGetRenderAreaGranularity(my_data->report_data, renderPass, pGranularity);
+    skipCall |= parameter_validation_vkGetRenderAreaGranularity(my_data->report_data, renderPass, pGranularity);
 
     if (skipCall == VK_FALSE) {
         get_dispatch_table(pc_device_table_map, device)->GetRenderAreaGranularity(device, renderPass, pGranularity);
@@ -3938,7 +3938,7 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(VkDevice devi
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkCreateCommandPool(my_data->report_data, pCreateInfo, pAllocator, pCommandPool);
+    skipCall |= parameter_validation_vkCreateCommandPool(my_data->report_data, pCreateInfo, pAllocator, pCommandPool);
 
     if (skipCall == VK_FALSE) {
         result = get_dispatch_table(pc_device_table_map, device)->CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
@@ -3955,7 +3955,7 @@ vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocat
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkDestroyCommandPool(my_data->report_data, commandPool, pAllocator);
+    skipCall |= parameter_validation_vkDestroyCommandPool(my_data->report_data, commandPool, pAllocator);
 
     if (skipCall == VK_FALSE) {
         get_dispatch_table(pc_device_table_map, device)->DestroyCommandPool(device, commandPool, pAllocator);
@@ -4013,7 +4013,7 @@ vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pAl
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkAllocateCommandBuffers(my_data->report_data, pAllocateInfo, pCommandBuffers);
+    skipCall |= parameter_validation_vkAllocateCommandBuffers(my_data->report_data, pAllocateInfo, pCommandBuffers);
 
     if (skipCall == VK_FALSE) {
         PreCreateCommandBuffer(device, pAllocateInfo);
@@ -4033,7 +4033,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers(VkDevice device,
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkFreeCommandBuffers(my_data->report_data, commandPool, commandBufferCount, pCommandBuffers);
+    skipCall |= parameter_validation_vkFreeCommandBuffers(my_data->report_data, commandPool, commandBufferCount, pCommandBuffers);
 
     if (skipCall == VK_FALSE) {
         get_dispatch_table(pc_device_table_map, device)
@@ -4060,7 +4060,7 @@ vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginIn
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkBeginCommandBuffer(my_data->report_data, pBeginInfo);
+    skipCall |= parameter_validation_vkBeginCommandBuffer(my_data->report_data, pBeginInfo);
 
     if (skipCall == VK_FALSE) {
         result = get_dispatch_table(pc_device_table_map, commandBuffer)->BeginCommandBuffer(commandBuffer, pBeginInfo);
@@ -4136,7 +4136,7 @@ vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkCmdSetViewport(my_data->report_data, firstViewport, viewportCount, pViewports);
+    skipCall |= parameter_validation_vkCmdSetViewport(my_data->report_data, firstViewport, viewportCount, pViewports);
 
     if (skipCall == VK_FALSE) {
         get_dispatch_table(pc_device_table_map, commandBuffer)
@@ -4150,7 +4150,7 @@ vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t s
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkCmdSetScissor(my_data->report_data, firstScissor, scissorCount, pScissors);
+    skipCall |= parameter_validation_vkCmdSetScissor(my_data->report_data, firstScissor, scissorCount, pScissors);
 
     if (skipCall == VK_FALSE) {
         get_dispatch_table(pc_device_table_map, commandBuffer)->CmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors);
@@ -4172,7 +4172,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants(VkCommandBuffe
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkCmdSetBlendConstants(my_data->report_data, blendConstants);
+    skipCall |= parameter_validation_vkCmdSetBlendConstants(my_data->report_data, blendConstants);
 
     if (skipCall == VK_FALSE) {
         get_dispatch_table(pc_device_table_map, commandBuffer)->CmdSetBlendConstants(commandBuffer, blendConstants);
@@ -4219,7 +4219,7 @@ vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipel
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkCmdBindDescriptorSets(my_data->report_data, pipelineBindPoint, layout, firstSet, descriptorSetCount,
+    skipCall |= parameter_validation_vkCmdBindDescriptorSets(my_data->report_data, pipelineBindPoint, layout, firstSet, descriptorSetCount,
                                                     pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
 
     if (skipCall == VK_FALSE) {
@@ -4256,7 +4256,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers(VkCommandBuffe
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkCmdBindVertexBuffers(my_data->report_data, firstBinding, bindingCount, pBuffers, pOffsets);
+    skipCall |= parameter_validation_vkCmdBindVertexBuffers(my_data->report_data, firstBinding, bindingCount, pBuffers, pOffsets);
 
     if (skipCall == VK_FALSE) {
         get_dispatch_table(pc_device_table_map, commandBuffer)
@@ -4325,7 +4325,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer(VkCommandBuffer comma
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkCmdCopyBuffer(my_data->report_data, srcBuffer, dstBuffer, regionCount, pRegions);
+    skipCall |= parameter_validation_vkCmdCopyBuffer(my_data->report_data, srcBuffer, dstBuffer, regionCount, pRegions);
 
     if (skipCall == VK_FALSE) {
         get_dispatch_table(pc_device_table_map, commandBuffer)
@@ -4379,7 +4379,7 @@ vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout sr
     assert(my_data != NULL);
 
     skipCall |=
-        param_check_vkCmdCopyImage(my_data->report_data, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
+        parameter_validation_vkCmdCopyImage(my_data->report_data, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
 
     if (skipCall == VK_FALSE) {
         PreCmdCopyImage(commandBuffer, pRegions);
@@ -4443,7 +4443,7 @@ vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout sr
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkCmdBlitImage(my_data->report_data, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount,
+    skipCall |= parameter_validation_vkCmdBlitImage(my_data->report_data, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount,
                                            pRegions, filter);
 
     if (skipCall == VK_FALSE) {
@@ -4491,7 +4491,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage(VkCommandBuffe
     assert(my_data != NULL);
 
     skipCall |=
-        param_check_vkCmdCopyBufferToImage(my_data->report_data, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
+        parameter_validation_vkCmdCopyBufferToImage(my_data->report_data, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
 
     if (skipCall == VK_FALSE) {
         PreCmdCopyBufferToImage(commandBuffer, pRegions);
@@ -4538,7 +4538,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer(VkCommandBuffe
     assert(my_data != NULL);
 
     skipCall |=
-        param_check_vkCmdCopyImageToBuffer(my_data->report_data, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
+        parameter_validation_vkCmdCopyImageToBuffer(my_data->report_data, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
 
     if (skipCall == VK_FALSE) {
         PreCmdCopyImageToBuffer(commandBuffer, pRegions);
@@ -4556,7 +4556,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer(VkCommandBuffer com
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkCmdUpdateBuffer(my_data->report_data, dstBuffer, dstOffset, dataSize, pData);
+    skipCall |= parameter_validation_vkCmdUpdateBuffer(my_data->report_data, dstBuffer, dstOffset, dataSize, pData);
 
     if (skipCall == VK_FALSE) {
         get_dispatch_table(pc_device_table_map, commandBuffer)
@@ -4588,7 +4588,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage(VkCommandBuffer
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkCmdClearColorImage(my_data->report_data, image, imageLayout, pColor, rangeCount, pRanges);
+    skipCall |= parameter_validation_vkCmdClearColorImage(my_data->report_data, image, imageLayout, pColor, rangeCount, pRanges);
 
     if (skipCall == VK_FALSE) {
         get_dispatch_table(pc_device_table_map, commandBuffer)
@@ -4620,7 +4620,7 @@ vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImag
     assert(my_data != NULL);
 
     skipCall |=
-        param_check_vkCmdClearDepthStencilImage(my_data->report_data, image, imageLayout, pDepthStencil, rangeCount, pRanges);
+        parameter_validation_vkCmdClearDepthStencilImage(my_data->report_data, image, imageLayout, pDepthStencil, rangeCount, pRanges);
 
     if (skipCall == VK_FALSE) {
         get_dispatch_table(pc_device_table_map, commandBuffer)
@@ -4637,7 +4637,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments(VkCommandBuffer
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkCmdClearAttachments(my_data->report_data, attachmentCount, pAttachments, rectCount, pRects);
+    skipCall |= parameter_validation_vkCmdClearAttachments(my_data->report_data, attachmentCount, pAttachments, rectCount, pRects);
 
     if (skipCall == VK_FALSE) {
         get_dispatch_table(pc_device_table_map, commandBuffer)
@@ -4693,7 +4693,7 @@ vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkCmdResolveImage(my_data->report_data, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount,
+    skipCall |= parameter_validation_vkCmdResolveImage(my_data->report_data, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount,
                                               pRegions);
 
     if (skipCall == VK_FALSE) {
@@ -4725,7 +4725,7 @@ vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEven
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkCmdWaitEvents(my_data->report_data, eventCount, pEvents, srcStageMask, dstStageMask,
+    skipCall |= parameter_validation_vkCmdWaitEvents(my_data->report_data, eventCount, pEvents, srcStageMask, dstStageMask,
                                             memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers,
                                             imageMemoryBarrierCount, pImageMemoryBarriers);
 
@@ -4745,7 +4745,7 @@ vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStag
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkCmdPipelineBarrier(my_data->report_data, srcStageMask, dstStageMask, dependencyFlags,
+    skipCall |= parameter_validation_vkCmdPipelineBarrier(my_data->report_data, srcStageMask, dstStageMask, dependencyFlags,
                                                  memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount,
                                                  pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
 
@@ -4799,7 +4799,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants(VkCommandBuffer co
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkCmdPushConstants(my_data->report_data, layout, stageFlags, offset, size, pValues);
+    skipCall |= parameter_validation_vkCmdPushConstants(my_data->report_data, layout, stageFlags, offset, size, pValues);
 
     if (skipCall == VK_FALSE) {
         get_dispatch_table(pc_device_table_map, commandBuffer)
@@ -4824,7 +4824,7 @@ vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkCmdBeginRenderPass(my_data->report_data, pRenderPassBegin, contents);
+    skipCall |= parameter_validation_vkCmdBeginRenderPass(my_data->report_data, pRenderPassBegin, contents);
 
     if (skipCall == VK_FALSE) {
         get_dispatch_table(pc_device_table_map, commandBuffer)->CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
@@ -4860,7 +4860,7 @@ vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount,
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
     assert(my_data != NULL);
 
-    skipCall |= param_check_vkCmdExecuteCommands(my_data->report_data, commandBufferCount, pCommandBuffers);
+    skipCall |= parameter_validation_vkCmdExecuteCommands(my_data->report_data, commandBufferCount, pCommandBuffers);
 
     if (skipCall == VK_FALSE) {
         get_dispatch_table(pc_device_table_map, commandBuffer)
diff --git a/layers/param_checker_utils.h b/layers/parameter_validation_utils.h
index a32a7756..7cb80c06 100644
--- a/layers/param_checker_utils.h
+++ b/layers/parameter_validation_utils.h
@@ -29,8 +29,8 @@
  * Author: Dustin Graves <dustin@lunarg.com>
  */
 
-#ifndef PARAM_CHECKER_UTILS_H
-#define PARAM_CHECKER_UTILS_H
+#ifndef PARAMETER_VALIDATION_UTILS_H
+#define PARAMETER_VALIDATION_UTILS_H
 
 #include <algorithm>
 #include <string>
@@ -374,4 +374,4 @@ static VkBool32 validate_struct_pnext(debug_report_data *report_data, const char
     return skipCall;
 }
 
-#endif // PARAM_CHECKER_UTILS_H
+#endif // PARAMETER_VALIDATION_UTILS_H
diff --git a/layers/vk_layer_settings.txt b/layers/vk_layer_settings.txt
index cdbb1dae..d83b8326 100644
--- a/layers/vk_layer_settings.txt
+++ b/layers/vk_layer_settings.txt
@@ -70,10 +70,10 @@ lunarg_object_tracker.debug_action = VK_DBG_LAYER_ACTION_LOG_MSG
 lunarg_object_tracker.report_flags = error,warn,perf
 lunarg_object_tracker.log_filename = stdout
 
-# VK_LAYER_LUNARG_param_checker Settings
-lunarg_param_checker.debug_action = VK_DBG_LAYER_ACTION_LOG_MSG
-lunarg_param_checker.report_flags = error,warn,perf
-lunarg_param_checker.log_filename = stdout
+# VK_LAYER_LUNARG_parameter_validation Settings
+lunarg_parameter_validation.debug_action = VK_DBG_LAYER_ACTION_LOG_MSG
+lunarg_parameter_validation.report_flags = error,warn,perf
+lunarg_parameter_validation.log_filename = stdout
 
 # VK_LAYER_LUNARG_swapchain Settings
 lunarg_swapchain.debug_action = VK_DBG_LAYER_ACTION_LOG_MSG
diff --git a/layers/vk_validation_layer_details.md b/layers/vk_validation_layer_details.md
index 7bc554e9..7754e2b3 100644
--- a/layers/vk_validation_layer_details.md
+++ b/layers/vk_validation_layer_details.md
@@ -9,7 +9,7 @@
 This is a meta-layer managed by the loader. Specifying this layer name will cause the loader to load the all of the standard validation layers in the following optimal order:
 
  - VK_LAYER_GOOGLE_threading
- - VK_LAYER_LUNARG_param_checker
+ - VK_LAYER_LUNARG_parameter_validation
  - VK_LAYER_LUNARG_device_limits
  - VK_LAYER_LUNARG_object_tracker
  - VK_LAYER_LUNARG_image
@@ -35,7 +35,7 @@ The Draw State portion of the core validation layer tracks state leading into Dr
 | Command Buffer Simultaneous Use | Violation of VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT rules. Most likely attempting to simultaneously use a CmdBuffer w/o having that bit set. This also warns if you add secondary command buffer w/o that bit set to a primary command buffer that does have that bit set. | INVALID_CB_SIMULTANEOUS_USE | vkQueueSubmit vkCmdExecuteCommands | TODO | Write test |
 | Valid Command Buffer Reset | Can only reset individual command buffer that was allocated from a pool with VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT set | INVALID_COMMAND_BUFFER_RESET | vkBeginCommandBuffer vkResetCommandBuffer | CommandBufferResetErrors | None |
 | PSO Bound | Verify that a properly created and valid pipeline object is bound to the CommandBuffer specified in these calls | NO_PIPELINE_BOUND | vkCmdBindDescriptorSets vkCmdBindVertexBuffers | PipelineNotBound | This check is currently more related to VK_LAYER_LUNARG_core_validation internal data structures and less about verifying that PSO is bound at all appropriate points in API. For API purposes, need to make sure this is checked at Draw time and any other relevant calls. |
-| Valid DescriptorPool | Verifies that the descriptor set pool object was properly created and is valid | INVALID_POOL | vkResetDescriptorPool vkAllocateDescriptorSets | None | This is just an internal layer data structure check. VK_LAYER_LUNARG_param_checker or VK_LAYER_LUNARG_object_tracker should really catch bad DSPool |
+| Valid DescriptorPool | Verifies that the descriptor set pool object was properly created and is valid | INVALID_POOL | vkResetDescriptorPool vkAllocateDescriptorSets | None | This is just an internal layer data structure check. VK_LAYER_LUNARG_parameter_validation or VK_LAYER_LUNARG_object_tracker should really catch bad DSPool |
 | Valid DescriptorSet | Validate that descriptor set was properly created and is currently valid | INVALID_SET | vkCmdBindDescriptorSets | None | Is this needed other places (like Update/Clear descriptors) |
 | Valid DescriptorSetLayout | Flag DescriptorSetLayout object that was not properly created | INVALID_LAYOUT | vkAllocateDescriptorSets | None | Anywhere else to check this? |
 | Valid Pipeline | Flag VkPipeline object that was not properly created | INVALID_PIPELINE | vkCmdBindPipeline | InvalidPipeline | NA |
@@ -178,13 +178,13 @@ The Mem Tracker portion of the VK_LAYER_LUNARG_core_validation layer tracks memo
 3. Warn on image/buffer deletion if USAGE bits were set that were not needed
 4. Modify INVALID_FENCE_STATE to be WARNINGs instead of ERROR
 
-## VK_LAYER_LUNARG_param_checker
+## VK_LAYER_LUNARG_parameter_validation
 
-### VK_LAYER_LUNARG_param_checker Overview
+### VK_LAYER_LUNARG_parameter_validation Overview
 
-The VK_LAYER_LUNARG_param_checker layer validates parameter values and flags errors for any values that are outside of acceptable values for the given parameter.
+The VK_LAYER_LUNARG_parameter_validation layer validates parameter values and flags errors for any values that are outside of acceptable values for the given parameter.
 
-### VK_LAYER_LUNARG_param_checker Details Table
+### VK_LAYER_LUNARG_parameter_validation Details Table
 
 | Check | Overview | ENUM | Relevant API | Testname | Notes/TODO |
 | ----- | -------- | ---------------- | ------------ | -------- | ---------- |
@@ -192,7 +192,7 @@ The VK_LAYER_LUNARG_param_checker layer validates parameter values and flags err
 | Call results, Output Parameters | Return values are checked for VK_SUCCESS, returned pointers are checked to be NON-NULL, enumerated types of return values are checked to be within the defined range. | NA | vkEnumeratePhysicalDevices vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceLimits vkGetPhysicalDeviceProperties vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceMemoryProperties vkGetDeviceQueue vkQueueSubmit vkQueueWaitIdle vkDeviceWaitIdle vkAllocateMemory vkFreeMemory vkMapMemory vkUnmapMemory vkFlushMappedMemoryRanges vkInvalidateMappedMemoryRanges vkGetDeviceMemoryCommitment vkBindBufferMemory vkBindImageMemory vkGetBufferMemoryRequirements vkGetImageMemoryRequirements vkGetImageSparseMemoryRequirements vkGetPhysicalDeviceSparseImageFormatProperties vkQueueBindSparse vkCreateFence vkDestroyFence vkResetFences vkGetFenceStatus vkWaitForFences vkCreateSemaphore vkDestroySemaphore vkCreateEvent vkDestroyEvent vkGetEventStatus vkSetEvent vkResetEvent vkCreateQueryPool vkDestroyQueryPool vkGetQueryPoolResults vkCreateBuffer vkDestroyBuffer vkCreateBufferView vkDestroyBufferView vkCreateImage vkDestroyImage vkGetImageSubresourceLayout vkCreateImageView vkDestroyImageView vkDestroyShaderModule vkCreatePipelineCache vkDestroyPipelineCache vkGetPipelineCacheData vkMergePipelineCaches vkCreateGraphicsPipelines vkCreateComputePipelines vkDestroyPipeline vkCreatePipelineLayout vkDestroyPipelineLayout vkCreateSampler vkDestroySampler vkCreateDescriptorSetLayout vkDestroyDescriptorSetLayout vkCreateDescriptorPool vkDestroyDescriptorPool vkResetDescriptorPool vkAllocateDescriptorSets vkFreeDescriptorSets vkUpdateDescriptorSets vkCreateFramebuffer vkDestroyFramebuffer vkCreateRenderPass vkDestroyRenderPass vkGetRenderAreaGranularity vkCreateCommandPool vkDestroyCommandPool vkResetCommandPool vkAllocateCommandBuffers vkFreeCommandBuffers vkBeginCommandBuffer vkEndCommandBuffer vkResetCommandBuffer vkCmdBindPipeline vkCmdBindDescriptorSets vkCmdBindIndexBuffer vkCmdBindVertexBuffers vkCmdDraw vkCmdDrawIndexed vkCmdDrawIndirect vkCmdDrawIndexedIndirect vkCmdDispatch vkCmdDispatchIndirect vkCmdCopyBuffer vkCmdCopyImage vkCmdBlitImage vkCmdCopyBufferToImage vkCmdCopyImageToBuffer vkCmdUpdateBuffer vkCmdFillBuffer vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdClearAttachments vkCmdResolveImage vkCmdSetEvent vkCmdResetEvent vkCmdWaitEvents vkCmdPipelineBarrier vkCmdBeginQuery vkCmdEndQuery vkCmdResetQueryPool vkCmdWriteTimestamp vkCmdCopyQueryPoolResults vkCmdPushConstants vkCmdBeginRenderPass vkCmdNextSubpass vkCmdEndRenderPass vkCmdExecuteCommands | TBD | NA |
 | NA | Enum used for informational messages | NONE | | NA | None |
 
-### VK_LAYER_LUNARG_param_checker Pending Work
+### VK_LAYER_LUNARG_parameter_validation Pending Work
 Additional work to be done
 
  1. Source2 was creating a VK_FORMAT_R8_SRGB texture (and image view) which was not supported by the underlying implementation (rendersystemtest imageformat test).  Checking that formats are supported by the implementation is something the validation layer could do using the VK_FORMAT_INFO_TYPE_PROPERTIES query.   There are probably a bunch of checks here you could be doing around vkCreateImage formats along with whether image/color/depth attachment views are valid.  I’m not sure how much of this is already there.
diff --git a/layers/linux/VkLayer_param_checker.json b/layers/windows/VkLayer_parameter_validation.json
index dcf76ebb..84245d24 100644
--- a/layers/linux/VkLayer_param_checker.json
+++ b/layers/windows/VkLayer_parameter_validation.json
@@ -1,9 +1,9 @@
 {
     "file_format_version" : "1.0.0",
     "layer" : {
-        "name": "VK_LAYER_LUNARG_param_checker",
+        "name": "VK_LAYER_LUNARG_parameter_validation",
         "type": "GLOBAL",
-        "library_path": "./libVkLayer_param_checker.so",
+        "library_path": ".\\VkLayer_parameter_validation.dll",
         "api_version": "1.0.5",
         "implementation_version": "1",
         "description": "LunarG Validation Layer",
diff --git a/loader/LoaderAndLayerInterface.md b/loader/LoaderAndLayerInterface.md
index 535d9baa..d695f472 100644
--- a/loader/LoaderAndLayerInterface.md
+++ b/loader/LoaderAndLayerInterface.md
@@ -183,9 +183,9 @@ An example of using these environment variables to activate the validation
 layer VK\_LAYER\_LUNARG\_param\_checker on Windows or Linux is as follows:
 
 ```
-> $ export VK_INSTANCE_LAYERS=VK_LAYER_LUNARG_param_checker
+> $ export VK_INSTANCE_LAYERS=VK_LAYER_LUNARG_parameter_validation
 
-> $ export VK_DEVICE_LAYERS=VK_LAYER_LUNARG_param_checker
+> $ export VK_DEVICE_LAYERS=VK_LAYER_LUNARG_parameter_validation
 ```
 
 **Note**: Many layers, including all LunarG validation layers are “global”
diff --git a/loader/loader.h b/loader/loader.h
index ae51725c..b0b36632 100644
--- a/loader/loader.h
+++ b/loader/loader.h
@@ -83,7 +83,7 @@ static const char UTF8_DATA_BYTE_CODE = 0x80;
 static const char UTF8_DATA_BYTE_MASK = 0xC0;
 
 static const char std_validation_names[8][VK_MAX_EXTENSION_NAME_SIZE] = {
-    "VK_LAYER_GOOGLE_threading",     "VK_LAYER_LUNARG_param_checker",
+    "VK_LAYER_GOOGLE_threading",     "VK_LAYER_LUNARG_parameter_validation",
     "VK_LAYER_LUNARG_device_limits", "VK_LAYER_LUNARG_object_tracker",
     "VK_LAYER_LUNARG_image",         "VK_LAYER_LUNARG_core_validation",
     "VK_LAYER_LUNARG_swapchain",     "VK_LAYER_GOOGLE_unique_objects"};
author	Mark Lobodzinski <mark@lunarg.com>	2016-03-17 15:08:18 -0600
committer	Mark Lobodzinski <mark@lunarg.com>	2016-03-21 11:31:42 -0600
commit	aaab5c00073a61ef75adf497d2c70d0824cd2e67 (patch)
tree	61acd42d2854abdac2fb0c0a2496875ae2783d82
parent	1e22882a98a0f329d6f212355bfe456d690902b3 (diff)
download	usermoji-aaab5c00073a61ef75adf497d2c70d0824cd2e67.tar.xz