819 lines
40 KiB
C++
819 lines
40 KiB
C++
/* Copyright (c) 2015-2016 The Khronos Group Inc.
|
|
* Copyright (c) 2015-2016 Valve Corporation
|
|
* Copyright (c) 2015-2016 LunarG, Inc.
|
|
* Copyright (C) 2015-2016 Google Inc.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*
|
|
* Author: Dustin Graves <dustin@lunarg.com>
|
|
*/
|
|
|
|
#ifndef PARAMETER_VALIDATION_UTILS_H
|
|
#define PARAMETER_VALIDATION_UTILS_H
|
|
|
|
#include <algorithm>
|
|
#include <cstdlib>
|
|
#include <string>
|
|
|
|
#include "vulkan/vulkan.h"
|
|
#include "vk_enum_string_helper.h"
|
|
#include "vk_layer_logging.h"
|
|
#include "vk_validation_error_messages.h"
|
|
|
|
#include "parameter_name.h"
|
|
|
|
#include "parameter_name.h"
|
|
|
|
namespace parameter_validation {
|
|
|
|
enum ErrorCode {
|
|
NONE, // Used for INFO & other non-error messages
|
|
INVALID_USAGE, // The value of a parameter is not consistent
|
|
// with the valid usage criteria defined in
|
|
// the Vulkan specification.
|
|
INVALID_STRUCT_STYPE, // The sType field of a Vulkan structure does
|
|
// not contain the value expected for a structure
|
|
// of that type.
|
|
INVALID_STRUCT_PNEXT, // The pNext field of a Vulkan structure references
|
|
// a value that is not compatible with a structure of
|
|
// that type or is not NULL when a structure of that
|
|
// type has no compatible pNext values.
|
|
REQUIRED_PARAMETER, // A required parameter was specified as 0 or NULL.
|
|
RESERVED_PARAMETER, // A parameter reserved for future use was not
|
|
// specified as 0 or NULL.
|
|
UNRECOGNIZED_VALUE, // A Vulkan enumeration, VkFlags, or VkBool32 parameter
|
|
// contains a value that is not recognized as valid for
|
|
// that type.
|
|
DEVICE_LIMIT, // A specified parameter exceeds the limits returned
|
|
// by the physical device
|
|
DEVICE_FEATURE, // Use of a requested feature is not supported by
|
|
// the device
|
|
FAILURE_RETURN_CODE, // A Vulkan return code indicating a failure condition
|
|
// was encountered.
|
|
};
|
|
|
|
struct GenericHeader {
|
|
VkStructureType sType;
|
|
const void *pNext;
|
|
};
|
|
|
|
// Layer name string to be logged with validation messages.
|
|
const char LayerName[] = "ParameterValidation";
|
|
|
|
// Enables for display-related instance extensions
|
|
struct instance_extension_enables {
|
|
bool wsi_enabled;
|
|
bool xlib_enabled;
|
|
bool xcb_enabled;
|
|
bool wayland_enabled;
|
|
bool mir_enabled;
|
|
bool android_enabled;
|
|
bool win32_enabled;
|
|
};
|
|
|
|
// String returned by string_VkStructureType for an unrecognized type.
|
|
const std::string UnsupportedStructureTypeString = "Unhandled VkStructureType";
|
|
|
|
// String returned by string_VkResult for an unrecognized type.
|
|
const std::string UnsupportedResultString = "Unhandled VkResult";
|
|
|
|
// The base value used when computing the offset for an enumeration token value that is added by an extension.
|
|
// When validating enumeration tokens, any value >= to this value is considered to be provided by an extension.
|
|
// See Appendix C.10 "Assigning Extension Token Values" from the Vulkan specification
|
|
const uint32_t ExtEnumBaseValue = 1000000000;
|
|
|
|
template <typename T> bool is_extension_added_token(T value) {
|
|
return (std::abs(static_cast<int32_t>(value)) >= ExtEnumBaseValue);
|
|
}
|
|
|
|
// VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE token is a special case that was converted from a core token to an
|
|
// extension added token. Its original value was intentionally preserved after the conversion, so it does not use
|
|
// the base value that other extension added tokens use, and it does not fall within the enum's begin/end range.
|
|
template <> bool is_extension_added_token(VkSamplerAddressMode value) {
|
|
bool result = (std::abs(static_cast<int32_t>(value)) >= ExtEnumBaseValue);
|
|
return (result || (value == VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE));
|
|
}
|
|
|
|
/**
|
|
* Validate a minimum value.
|
|
*
|
|
* Verify that the specified value is greater than the specified lower bound.
|
|
*
|
|
* @param report_data debug_report_data object for routing validation messages.
|
|
* @param api_name Name of API call being validated.
|
|
* @param parameter_name Name of parameter being validated.
|
|
* @param value Value to validate.
|
|
* @param lower_bound Lower bound value to use for validation.
|
|
* @return Boolean value indicating that the call should be skipped.
|
|
*/
|
|
template <typename T>
|
|
bool ValidateGreaterThan(debug_report_data *report_data, const char *api_name, const ParameterName ¶meter_name, T value,
|
|
T lower_bound) {
|
|
bool skip_call = false;
|
|
|
|
if (value <= lower_bound) {
|
|
skip_call |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, 1, LayerName,
|
|
"%s: parameter %s must be greater than %d", api_name, parameter_name.get_name().c_str(), lower_bound);
|
|
}
|
|
|
|
return skip_call;
|
|
}
|
|
|
|
/**
|
|
* Validate a required pointer.
|
|
*
|
|
* Verify that a required pointer is not NULL.
|
|
*
|
|
* @param report_data debug_report_data object for routing validation messages.
|
|
* @param apiName Name of API call being validated.
|
|
* @param parameterName Name of parameter being validated.
|
|
* @param value Pointer to validate.
|
|
* @return Boolean value indicating that the call should be skipped.
|
|
*/
|
|
static bool validate_required_pointer(debug_report_data *report_data, const char *apiName, const ParameterName ¶meterName,
|
|
const void *value) {
|
|
bool skip_call = false;
|
|
|
|
if (value == NULL) {
|
|
|
|
skip_call |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
|
|
REQUIRED_PARAMETER, LayerName, "%s: required parameter %s specified as NULL", apiName,
|
|
parameterName.get_name().c_str());
|
|
}
|
|
|
|
return skip_call;
|
|
}
|
|
|
|
/**
|
|
* Validate array count and pointer to array.
|
|
*
|
|
* Verify that required count and array parameters are not 0 or NULL. If the
|
|
* count parameter is not optional, verify that it is not 0. If the array
|
|
* parameter is NULL, and it is not optional, verify that count is 0.
|
|
*
|
|
* @param report_data debug_report_data object for routing validation messages.
|
|
* @param apiName Name of API call being validated.
|
|
* @param countName Name of count parameter.
|
|
* @param arrayName Name of array parameter.
|
|
* @param count Number of elements in the array.
|
|
* @param array Array to validate.
|
|
* @param countRequired The 'count' parameter may not be 0 when true.
|
|
* @param arrayRequired The 'array' parameter may not be NULL when true.
|
|
* @return Boolean value indicating that the call should be skipped.
|
|
*/
|
|
template <typename T>
|
|
bool validate_array(debug_report_data *report_data, const char *apiName, const ParameterName &countName,
|
|
const ParameterName &arrayName, T count, const void *array, bool countRequired, bool arrayRequired) {
|
|
bool skip_call = false;
|
|
|
|
// Count parameters not tagged as optional cannot be 0
|
|
if (countRequired && (count == 0)) {
|
|
skip_call |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
|
|
REQUIRED_PARAMETER, LayerName, "%s: parameter %s must be greater than 0", apiName,
|
|
countName.get_name().c_str());
|
|
}
|
|
|
|
// Array parameters not tagged as optional cannot be NULL, unless the count is 0
|
|
if ((array == NULL) && arrayRequired && (count != 0)) {
|
|
skip_call |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
|
|
REQUIRED_PARAMETER, LayerName, "%s: required parameter %s specified as NULL", apiName,
|
|
arrayName.get_name().c_str());
|
|
}
|
|
|
|
return skip_call;
|
|
}
|
|
|
|
/**
|
|
* Validate pointer to array count and pointer to array.
|
|
*
|
|
* Verify that required count and array parameters are not NULL. If count
|
|
* is not NULL and its value is not optional, verify that it is not 0. If the
|
|
* array parameter is NULL, and it is not optional, verify that count is 0.
|
|
* The array parameter will typically be optional for this case (where count is
|
|
* a pointer), allowing the caller to retrieve the available count.
|
|
*
|
|
* @param report_data debug_report_data object for routing validation messages.
|
|
* @param apiName Name of API call being validated.
|
|
* @param countName Name of count parameter.
|
|
* @param arrayName Name of array parameter.
|
|
* @param count Pointer to the number of elements in the array.
|
|
* @param array Array to validate.
|
|
* @param countPtrRequired The 'count' parameter may not be NULL when true.
|
|
* @param countValueRequired The '*count' value may not be 0 when true.
|
|
* @param arrayRequired The 'array' parameter may not be NULL when true.
|
|
* @return Boolean value indicating that the call should be skipped.
|
|
*/
|
|
template <typename T>
|
|
bool validate_array(debug_report_data *report_data, const char *apiName, const ParameterName &countName,
|
|
const ParameterName &arrayName, const T *count, const void *array, bool countPtrRequired,
|
|
bool countValueRequired, bool arrayRequired) {
|
|
bool skip_call = false;
|
|
|
|
if (count == NULL) {
|
|
if (countPtrRequired) {
|
|
skip_call |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
|
|
REQUIRED_PARAMETER, LayerName, "%s: required parameter %s specified as NULL", apiName,
|
|
countName.get_name().c_str());
|
|
}
|
|
}
|
|
else {
|
|
skip_call |= validate_array(report_data, apiName, countName, arrayName, (*count), array, countValueRequired, arrayRequired);
|
|
}
|
|
|
|
return skip_call;
|
|
}
|
|
|
|
/**
|
|
* Validate a pointer to a Vulkan structure.
|
|
*
|
|
* Verify that a required pointer to a structure is not NULL. If the pointer is
|
|
* not NULL, verify that each structure's sType field is set to the correct
|
|
* VkStructureType value.
|
|
*
|
|
* @param report_data debug_report_data object for routing validation messages.
|
|
* @param apiName Name of API call being validated.
|
|
* @param parameterName Name of struct parameter being validated.
|
|
* @param sTypeName Name of expected VkStructureType value.
|
|
* @param value Pointer to the struct to validate.
|
|
* @param sType VkStructureType for structure validation.
|
|
* @param required The parameter may not be NULL when true.
|
|
* @return Boolean value indicating that the call should be skipped.
|
|
*/
|
|
template <typename T>
|
|
bool validate_struct_type(debug_report_data *report_data, const char *apiName, const ParameterName ¶meterName,
|
|
const char *sTypeName, const T *value, VkStructureType sType, bool required) {
|
|
bool skip_call = false;
|
|
|
|
if (value == NULL) {
|
|
if (required) {
|
|
skip_call |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
|
|
REQUIRED_PARAMETER, LayerName, "%s: required parameter %s specified as NULL", apiName,
|
|
parameterName.get_name().c_str());
|
|
}
|
|
} else if (value->sType != sType) {
|
|
skip_call |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
|
|
INVALID_STRUCT_STYPE, LayerName, "%s: parameter %s->sType must be %s", apiName,
|
|
parameterName.get_name().c_str(), sTypeName);
|
|
}
|
|
|
|
return skip_call;
|
|
}
|
|
|
|
/**
|
|
* Validate an array of Vulkan structures.
|
|
*
|
|
* Verify that required count and array parameters are not NULL. If count
|
|
* is not NULL and its value is not optional, verify that it is not 0.
|
|
* If the array contains 1 or more structures, verify that each structure's
|
|
* sType field is set to the correct VkStructureType value.
|
|
*
|
|
* @param report_data debug_report_data object for routing validation messages.
|
|
* @param apiName Name of API call being validated.
|
|
* @param countName Name of count parameter.
|
|
* @param arrayName Name of array parameter.
|
|
* @param sTypeName Name of expected VkStructureType value.
|
|
* @param count Pointer to the number of elements in the array.
|
|
* @param array Array to validate.
|
|
* @param sType VkStructureType for structure validation.
|
|
* @param countPtrRequired The 'count' parameter may not be NULL when true.
|
|
* @param countValueRequired The '*count' value may not be 0 when true.
|
|
* @param arrayRequired The 'array' parameter may not be NULL when true.
|
|
* @return Boolean value indicating that the call should be skipped.
|
|
*/
|
|
template <typename T>
|
|
bool validate_struct_type_array(debug_report_data *report_data, const char *apiName, const ParameterName &countName,
|
|
const ParameterName &arrayName, const char *sTypeName, const uint32_t *count, const T *array,
|
|
VkStructureType sType, bool countPtrRequired, bool countValueRequired, bool arrayRequired) {
|
|
bool skip_call = false;
|
|
|
|
if (count == NULL) {
|
|
if (countPtrRequired) {
|
|
skip_call |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
|
|
REQUIRED_PARAMETER, LayerName, "%s: required parameter %s specified as NULL", apiName,
|
|
countName.get_name().c_str());
|
|
}
|
|
} else {
|
|
skip_call |= validate_struct_type_array(report_data, apiName, countName, arrayName, sTypeName, (*count), array, sType,
|
|
countValueRequired, arrayRequired);
|
|
}
|
|
|
|
return skip_call;
|
|
}
|
|
|
|
/**
|
|
* Validate an array of Vulkan structures
|
|
*
|
|
* Verify that required count and array parameters are not 0 or NULL. If
|
|
* the array contains 1 or more structures, verify that each structure's
|
|
* sType field is set to the correct VkStructureType value.
|
|
*
|
|
* @param report_data debug_report_data object for routing validation messages.
|
|
* @param apiName Name of API call being validated.
|
|
* @param countName Name of count parameter.
|
|
* @param arrayName Name of array parameter.
|
|
* @param sTypeName Name of expected VkStructureType value.
|
|
* @param count Number of elements in the array.
|
|
* @param array Array to validate.
|
|
* @param sType VkStructureType for structure validation.
|
|
* @param countRequired The 'count' parameter may not be 0 when true.
|
|
* @param arrayRequired The 'array' parameter may not be NULL when true.
|
|
* @return Boolean value indicating that the call should be skipped.
|
|
*/
|
|
template <typename T>
|
|
bool validate_struct_type_array(debug_report_data *report_data, const char *apiName, const ParameterName &countName,
|
|
const ParameterName &arrayName, const char *sTypeName, uint32_t count, const T *array,
|
|
VkStructureType sType, bool countRequired, bool arrayRequired) {
|
|
bool skip_call = false;
|
|
|
|
if ((count == 0) || (array == NULL)) {
|
|
skip_call |= validate_array(report_data, apiName, countName, arrayName, count, array, countRequired, arrayRequired);
|
|
} else {
|
|
// Verify that all structs in the array have the correct type
|
|
for (uint32_t i = 0; i < count; ++i) {
|
|
if (array[i].sType != sType) {
|
|
skip_call |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
|
|
__LINE__, INVALID_STRUCT_STYPE, LayerName, "%s: parameter %s[%d].sType must be %s", apiName,
|
|
arrayName.get_name().c_str(), i, sTypeName);
|
|
}
|
|
}
|
|
}
|
|
|
|
return skip_call;
|
|
}
|
|
|
|
/**
|
|
* Validate a Vulkan handle.
|
|
*
|
|
* Verify that the specified handle is not VK_NULL_HANDLE.
|
|
*
|
|
* @param report_data debug_report_data object for routing validation messages.
|
|
* @param api_name Name of API call being validated.
|
|
* @param parameter_name Name of struct parameter being validated.
|
|
* @param value Handle to validate.
|
|
* @return Boolean value indicating that the call should be skipped.
|
|
*/
|
|
template <typename T>
|
|
bool validate_required_handle(debug_report_data *report_data, const char *api_name, const ParameterName ¶meter_name, T value) {
|
|
bool skip_call = false;
|
|
|
|
if (value == VK_NULL_HANDLE) {
|
|
skip_call |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
|
|
REQUIRED_PARAMETER, LayerName, "%s: required parameter %s specified as VK_NULL_HANDLE", api_name,
|
|
parameter_name.get_name().c_str());
|
|
}
|
|
|
|
return skip_call;
|
|
}
|
|
|
|
/**
|
|
* Validate an array of Vulkan handles.
|
|
*
|
|
* Verify that required count and array parameters are not NULL. If count
|
|
* is not NULL and its value is not optional, verify that it is not 0.
|
|
* If the array contains 1 or more handles, verify that no handle is set to
|
|
* VK_NULL_HANDLE.
|
|
*
|
|
* @note This function is only intended to validate arrays of handles when none
|
|
* of the handles are allowed to be VK_NULL_HANDLE. For arrays of handles
|
|
* that are allowed to contain VK_NULL_HANDLE, use validate_array() instead.
|
|
*
|
|
* @param report_data debug_report_data object for routing validation messages.
|
|
* @param api_name Name of API call being validated.
|
|
* @param count_name Name of count parameter.
|
|
* @param array_name Name of array parameter.
|
|
* @param count Number of elements in the array.
|
|
* @param array Array to validate.
|
|
* @param count_required The 'count' parameter may not be 0 when true.
|
|
* @param array_required The 'array' parameter may not be NULL when true.
|
|
* @return Boolean value indicating that the call should be skipped.
|
|
*/
|
|
template <typename T>
|
|
bool validate_handle_array(debug_report_data *report_data, const char *api_name, const ParameterName &count_name,
|
|
const ParameterName &array_name, uint32_t count, const T *array, bool count_required,
|
|
bool array_required) {
|
|
bool skip_call = false;
|
|
|
|
if ((count == 0) || (array == NULL)) {
|
|
skip_call |= validate_array(report_data, api_name, count_name, array_name, count, array, count_required, array_required);
|
|
} else {
|
|
// Verify that no handles in the array are VK_NULL_HANDLE
|
|
for (uint32_t i = 0; i < count; ++i) {
|
|
if (array[i] == VK_NULL_HANDLE) {
|
|
skip_call |=
|
|
log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
|
|
REQUIRED_PARAMETER, LayerName, "%s: required parameter %s[%d] specified as VK_NULL_HANDLE", api_name,
|
|
array_name.get_name().c_str(), i);
|
|
}
|
|
}
|
|
}
|
|
|
|
return skip_call;
|
|
}
|
|
|
|
/**
|
|
* Validate string array count and content.
|
|
*
|
|
* Verify that required count and array parameters are not 0 or NULL. If the
|
|
* count parameter is not optional, verify that it is not 0. If the array
|
|
* parameter is NULL, and it is not optional, verify that count is 0. If the
|
|
* array parameter is not NULL, verify that none of the strings are NULL.
|
|
*
|
|
* @param report_data debug_report_data object for routing validation messages.
|
|
* @param apiName Name of API call being validated.
|
|
* @param countName Name of count parameter.
|
|
* @param arrayName Name of array parameter.
|
|
* @param count Number of strings in the array.
|
|
* @param array Array of strings to validate.
|
|
* @param countRequired The 'count' parameter may not be 0 when true.
|
|
* @param arrayRequired The 'array' parameter may not be NULL when true.
|
|
* @return Boolean value indicating that the call should be skipped.
|
|
*/
|
|
static bool validate_string_array(debug_report_data *report_data, const char *apiName, const ParameterName &countName,
|
|
const ParameterName &arrayName, uint32_t count, const char *const *array, bool countRequired,
|
|
bool arrayRequired) {
|
|
bool skip_call = false;
|
|
|
|
if ((count == 0) || (array == NULL)) {
|
|
skip_call |= validate_array(report_data, apiName, countName, arrayName, count, array, countRequired, arrayRequired);
|
|
} else {
|
|
// Verify that strings in the array are not NULL
|
|
for (uint32_t i = 0; i < count; ++i) {
|
|
if (array[i] == NULL) {
|
|
skip_call |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
|
|
__LINE__, REQUIRED_PARAMETER, LayerName, "%s: required parameter %s[%d] specified as NULL",
|
|
apiName, arrayName.get_name().c_str(), i);
|
|
}
|
|
}
|
|
}
|
|
|
|
return skip_call;
|
|
}
|
|
|
|
/**
|
|
* Validate a structure's pNext member.
|
|
*
|
|
* Verify that the specified pNext value points to the head of a list of
|
|
* allowed extension structures. If no extension structures are allowed,
|
|
* verify that pNext is null.
|
|
*
|
|
* @param report_data debug_report_data object for routing validation messages.
|
|
* @param api_name Name of API call being validated.
|
|
* @param parameter_name Name of parameter being validated.
|
|
* @param allowed_struct_names Names of allowed structs.
|
|
* @param next Pointer to validate.
|
|
* @param allowed_type_count Total number of allowed structure types.
|
|
* @param allowed_types Array of strcuture types allowed for pNext.
|
|
* @param header_version Version of header defining the pNext validation rules.
|
|
* @return Boolean value indicating that the call should be skipped.
|
|
*/
|
|
static bool validate_struct_pnext(debug_report_data *report_data, const char *api_name, const ParameterName ¶meter_name,
|
|
const char *allowed_struct_names, const void *next, size_t allowed_type_count,
|
|
const VkStructureType *allowed_types, uint32_t header_version) {
|
|
bool skip_call = false;
|
|
const char disclaimer[] = "This warning is based on the Valid Usage documentation for version %d of the Vulkan header. It "
|
|
"is possible that you are using a struct from a private extension or an extension that was added "
|
|
"to a later version of the Vulkan header, in which case your use of %s is perfectly valid but "
|
|
"is not guaranteed to work correctly with validation enabled";
|
|
|
|
if (next != NULL) {
|
|
if (allowed_type_count == 0) {
|
|
std::string message = "%s: value of %s must be NULL. ";
|
|
message += disclaimer;
|
|
skip_call |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
|
|
INVALID_STRUCT_PNEXT, LayerName, message.c_str(), api_name, parameter_name.get_name().c_str(),
|
|
header_version, parameter_name.get_name().c_str());
|
|
} else {
|
|
const VkStructureType *start = allowed_types;
|
|
const VkStructureType *end = allowed_types + allowed_type_count;
|
|
const GenericHeader *current = reinterpret_cast<const GenericHeader *>(next);
|
|
|
|
while (current != NULL) {
|
|
if (std::find(start, end, current->sType) == end) {
|
|
std::string type_name = string_VkStructureType(current->sType);
|
|
|
|
if (type_name == UnsupportedStructureTypeString) {
|
|
std::string message = "%s: %s chain includes a structure with unexpected VkStructureType (%d); Allowed "
|
|
"structures are [%s]. ";
|
|
message += disclaimer;
|
|
skip_call |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT,
|
|
0, __LINE__, INVALID_STRUCT_PNEXT, LayerName, message.c_str(), api_name,
|
|
parameter_name.get_name().c_str(), current->sType, allowed_struct_names,
|
|
header_version, parameter_name.get_name().c_str());
|
|
} else {
|
|
std::string message =
|
|
"%s: %s chain includes a structure with unexpected VkStructureType %s; Allowed structures are [%s]. ";
|
|
message += disclaimer;
|
|
skip_call |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT,
|
|
0, __LINE__, INVALID_STRUCT_PNEXT, LayerName, message.c_str(), api_name,
|
|
parameter_name.get_name().c_str(), type_name.c_str(), allowed_struct_names,
|
|
header_version, parameter_name.get_name().c_str());
|
|
}
|
|
}
|
|
|
|
current = reinterpret_cast<const GenericHeader *>(current->pNext);
|
|
}
|
|
}
|
|
}
|
|
|
|
return skip_call;
|
|
}
|
|
|
|
/**
|
|
* Validate a VkBool32 value.
|
|
*
|
|
* Generate a warning if a VkBool32 value is neither VK_TRUE nor VK_FALSE.
|
|
*
|
|
* @param report_data debug_report_data object for routing validation messages.
|
|
* @param apiName Name of API call being validated.
|
|
* @param parameterName Name of parameter being validated.
|
|
* @param value Boolean value to validate.
|
|
* @return Boolean value indicating that the call should be skipped.
|
|
*/
|
|
static bool validate_bool32(debug_report_data *report_data, const char *apiName, const ParameterName ¶meterName,
|
|
VkBool32 value) {
|
|
bool skip_call = false;
|
|
|
|
if ((value != VK_TRUE) && (value != VK_FALSE)) {
|
|
skip_call |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
|
|
UNRECOGNIZED_VALUE, LayerName, "%s: value of %s (%d) is neither VK_TRUE nor VK_FALSE", apiName,
|
|
parameterName.get_name().c_str(), value);
|
|
}
|
|
|
|
return skip_call;
|
|
}
|
|
|
|
/**
|
|
* Validate a Vulkan enumeration value.
|
|
*
|
|
* Generate a warning if an enumeration token value does not fall within the core enumeration
|
|
* begin and end token values, and was not added to the enumeration by an extension. Extension
|
|
* provided enumerations use the equation specified in Appendix C.10 of the Vulkan specification,
|
|
* with 1,000,000,000 as the base token value.
|
|
*
|
|
* @note This function does not expect to process enumerations defining bitmask flag bits.
|
|
*
|
|
* @param report_data debug_report_data object for routing validation messages.
|
|
* @param apiName Name of API call being validated.
|
|
* @param parameterName Name of parameter being validated.
|
|
* @param enumName Name of the enumeration being validated.
|
|
* @param begin The begin range value for the enumeration.
|
|
* @param end The end range value for the enumeration.
|
|
* @param value Enumeration value to validate.
|
|
* @return Boolean value indicating that the call should be skipped.
|
|
*/
|
|
template <typename T>
|
|
bool validate_ranged_enum(debug_report_data *report_data, const char *apiName, const ParameterName ¶meterName,
|
|
const char *enumName, T begin, T end, T value) {
|
|
bool skip_call = false;
|
|
|
|
if (((value < begin) || (value > end)) && !is_extension_added_token(value)) {
|
|
skip_call |=
|
|
log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
|
|
UNRECOGNIZED_VALUE, LayerName, "%s: value of %s (%d) does not fall within the begin..end range of the core %s "
|
|
"enumeration tokens and is not an extension added token",
|
|
apiName, parameterName.get_name().c_str(), value, enumName);
|
|
}
|
|
|
|
return skip_call;
|
|
}
|
|
|
|
/**
|
|
* Validate an array of Vulkan enumeration value.
|
|
*
|
|
* Process all enumeration token values in the specified array and generate a warning if a value
|
|
* does not fall within the core enumeration begin and end token values, and was not added to
|
|
* the enumeration by an extension. Extension provided enumerations use the equation specified
|
|
* in Appendix C.10 of the Vulkan specification, with 1,000,000,000 as the base token value.
|
|
*
|
|
* @note This function does not expect to process enumerations defining bitmask flag bits.
|
|
*
|
|
* @param report_data debug_report_data object for routing validation messages.
|
|
* @param apiName Name of API call being validated.
|
|
* @param countName Name of count parameter.
|
|
* @param arrayName Name of array parameter.
|
|
* @param enumName Name of the enumeration being validated.
|
|
* @param begin The begin range value for the enumeration.
|
|
* @param end The end range value for the enumeration.
|
|
* @param count Number of enumeration values in the array.
|
|
* @param array Array of enumeration values to validate.
|
|
* @param countRequired The 'count' parameter may not be 0 when true.
|
|
* @param arrayRequired The 'array' parameter may not be NULL when true.
|
|
* @return Boolean value indicating that the call should be skipped.
|
|
*/
|
|
template <typename T>
|
|
static bool validate_ranged_enum_array(debug_report_data *report_data, const char *apiName, const ParameterName &countName,
|
|
const ParameterName &arrayName, const char *enumName, T begin, T end, uint32_t count,
|
|
const T *array, bool countRequired, bool arrayRequired) {
|
|
bool skip_call = false;
|
|
|
|
if ((count == 0) || (array == NULL)) {
|
|
skip_call |= validate_array(report_data, apiName, countName, arrayName, count, array, countRequired, arrayRequired);
|
|
} else {
|
|
for (uint32_t i = 0; i < count; ++i) {
|
|
if (((array[i] < begin) || (array[i] > end)) && !is_extension_added_token(array[i])) {
|
|
skip_call |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
|
|
__LINE__, UNRECOGNIZED_VALUE, LayerName,
|
|
"%s: value of %s[%d] (%d) does not fall within the begin..end range of the core %s "
|
|
"enumeration tokens and is not an extension added token",
|
|
apiName, arrayName.get_name().c_str(), i, array[i], enumName);
|
|
}
|
|
}
|
|
}
|
|
|
|
return skip_call;
|
|
}
|
|
|
|
/**
|
|
* Verify that a reserved VkFlags value is zero.
|
|
*
|
|
* Verify that the specified value is zero, to check VkFlags values that are reserved for
|
|
* future use.
|
|
*
|
|
* @param report_data debug_report_data object for routing validation messages.
|
|
* @param api_name Name of API call being validated.
|
|
* @param parameter_name Name of parameter being validated.
|
|
* @param value Value to validate.
|
|
* @return Boolean value indicating that the call should be skipped.
|
|
*/
|
|
static bool validate_reserved_flags(debug_report_data *report_data, const char *api_name, const ParameterName ¶meter_name,
|
|
VkFlags value) {
|
|
bool skip_call = false;
|
|
|
|
if (value != 0) {
|
|
skip_call |=
|
|
log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
|
|
RESERVED_PARAMETER, LayerName, "%s: parameter %s must be 0", api_name, parameter_name.get_name().c_str());
|
|
}
|
|
|
|
return skip_call;
|
|
}
|
|
|
|
/**
|
|
* Validate a Vulkan bitmask value.
|
|
*
|
|
* Generate a warning if a value with a VkFlags derived type does not contain valid flag bits
|
|
* for that type.
|
|
*
|
|
* @param report_data debug_report_data object for routing validation messages.
|
|
* @param api_name Name of API call being validated.
|
|
* @param parameter_name Name of parameter being validated.
|
|
* @param flag_bits_name Name of the VkFlags type being validated.
|
|
* @param all_flags A bit mask combining all valid flag bits for the VkFlags type being validated.
|
|
* @param value VkFlags value to validate.
|
|
* @param flags_required The 'value' parameter may not be 0 when true.
|
|
* @return Boolean value indicating that the call should be skipped.
|
|
*/
|
|
static bool validate_flags(debug_report_data *report_data, const char *api_name, const ParameterName ¶meter_name,
|
|
const char *flag_bits_name, VkFlags all_flags, VkFlags value, bool flags_required) {
|
|
bool skip_call = false;
|
|
|
|
if (value == 0) {
|
|
if (flags_required) {
|
|
skip_call |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
|
|
REQUIRED_PARAMETER, LayerName, "%s: value of %s must not be 0", api_name,
|
|
parameter_name.get_name().c_str());
|
|
}
|
|
} else if ((value & (~all_flags)) != 0) {
|
|
skip_call |=
|
|
log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
|
|
UNRECOGNIZED_VALUE, LayerName, "%s: value of %s contains flag bits that are not recognized members of %s",
|
|
api_name, parameter_name.get_name().c_str(), flag_bits_name);
|
|
}
|
|
|
|
return skip_call;
|
|
}
|
|
|
|
/**
|
|
* Validate an array of Vulkan bitmask values.
|
|
*
|
|
* Generate a warning if a value with a VkFlags derived type does not contain valid flag bits
|
|
* for that type.
|
|
*
|
|
* @param report_data debug_report_data object for routing validation messages.
|
|
* @param api_name Name of API call being validated.
|
|
* @param count_name Name of parameter being validated.
|
|
* @param array_name Name of parameter being validated.
|
|
* @param flag_bits_name Name of the VkFlags type being validated.
|
|
* @param all_flags A bitmask combining all valid flag bits for the VkFlags type being validated.
|
|
* @param count Number of VkFlags values in the array.
|
|
* @param array Array of VkFlags value to validate.
|
|
* @param count_required The 'count' parameter may not be 0 when true.
|
|
* @param array_required The 'array' parameter may not be NULL when true.
|
|
* @return Boolean value indicating that the call should be skipped.
|
|
*/
|
|
static bool validate_flags_array(debug_report_data *report_data, const char *api_name, const ParameterName &count_name,
|
|
const ParameterName &array_name, const char *flag_bits_name, VkFlags all_flags, uint32_t count,
|
|
const VkFlags *array, bool count_required, bool array_required) {
|
|
bool skip_call = false;
|
|
|
|
if ((count == 0) || (array == NULL)) {
|
|
skip_call |= validate_array(report_data, api_name, count_name, array_name, count, array, count_required, array_required);
|
|
} else {
|
|
// Verify that all VkFlags values in the array
|
|
for (uint32_t i = 0; i < count; ++i) {
|
|
if (array[i] == 0) {
|
|
// Current XML registry logic for validity generation uses the array parameter's optional tag to determine if
|
|
// elements in the array are allowed be 0
|
|
if (array_required) {
|
|
skip_call |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
|
|
__LINE__, REQUIRED_PARAMETER, LayerName, "%s: value of %s[%d] must not be 0", api_name,
|
|
array_name.get_name().c_str(), i);
|
|
}
|
|
} else if ((array[i] & (~all_flags)) != 0) {
|
|
skip_call |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
|
|
__LINE__, UNRECOGNIZED_VALUE, LayerName,
|
|
"%s: value of %s[%d] contains flag bits that are not recognized members of %s", api_name,
|
|
array_name.get_name().c_str(), i, flag_bits_name);
|
|
}
|
|
}
|
|
}
|
|
|
|
return skip_call;
|
|
}
|
|
|
|
/**
|
|
* Get VkResult code description.
|
|
*
|
|
* Returns a string describing the specified VkResult code. The description is based on the language in the Vulkan API
|
|
* specification.
|
|
*
|
|
* @param value VkResult code to process.
|
|
* @return String describing the specified VkResult code.
|
|
*/
|
|
static std::string get_result_description(VkResult result) {
|
|
// clang-format off
|
|
switch (result) {
|
|
case VK_SUCCESS: return "a command completed successfully";
|
|
case VK_NOT_READY: return "a fence or query has not yet completed";
|
|
case VK_TIMEOUT: return "a wait operation has not completed in the specified time";
|
|
case VK_EVENT_SET: return "an event is signaled";
|
|
case VK_EVENT_RESET: return "an event is unsignalled";
|
|
case VK_INCOMPLETE: return "a return array was too small for the result";
|
|
case VK_ERROR_OUT_OF_HOST_MEMORY: return "a host memory allocation has failed";
|
|
case VK_ERROR_OUT_OF_DEVICE_MEMORY: return "a device memory allocation has failed";
|
|
case VK_ERROR_INITIALIZATION_FAILED: return "initialization of an object has failed";
|
|
case VK_ERROR_DEVICE_LOST: return "the logical device has been lost";
|
|
case VK_ERROR_MEMORY_MAP_FAILED: return "mapping of a memory object has failed";
|
|
case VK_ERROR_LAYER_NOT_PRESENT: return "the specified layer does not exist";
|
|
case VK_ERROR_EXTENSION_NOT_PRESENT: return "the specified extension does not exist";
|
|
case VK_ERROR_FEATURE_NOT_PRESENT: return "the requested feature is not available on this device";
|
|
case VK_ERROR_INCOMPATIBLE_DRIVER: return "a Vulkan driver could not be found";
|
|
case VK_ERROR_TOO_MANY_OBJECTS: return "too many objects of the type have already been created";
|
|
case VK_ERROR_FORMAT_NOT_SUPPORTED: return "the requested format is not supported on this device";
|
|
case VK_ERROR_SURFACE_LOST_KHR: return "a surface is no longer available";
|
|
case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR: return "the requested window is already connected to another "
|
|
"VkSurfaceKHR object, or some other non-Vulkan surface object";
|
|
case VK_SUBOPTIMAL_KHR: return "an image became available, and the swapchain no longer "
|
|
"matches the surface properties exactly, but can still be used to "
|
|
"present to the surface successfully.";
|
|
case VK_ERROR_OUT_OF_DATE_KHR: return "a surface has changed in such a way that it is no "
|
|
"longer compatible with the swapchain";
|
|
case VK_ERROR_INCOMPATIBLE_DISPLAY_KHR: return "the display used by a swapchain does not use the same "
|
|
"presentable image layout, or is incompatible in a way that prevents "
|
|
"sharing an image";
|
|
case VK_ERROR_VALIDATION_FAILED_EXT: return "API validation has detected an invalid use of the API";
|
|
case VK_ERROR_INVALID_SHADER_NV: return "one or more shaders failed to compile or link";
|
|
default: return "an error has occurred";
|
|
};
|
|
// clang-format on
|
|
}
|
|
|
|
/**
|
|
* Validate return code.
|
|
*
|
|
* Print a message describing the reason for failure when an error code is returned.
|
|
*
|
|
* @param report_data debug_report_data object for routing validation messages.
|
|
* @param apiName Name of API call being validated.
|
|
* @param value VkResult value to validate.
|
|
*/
|
|
static void validate_result(debug_report_data *report_data, const char *apiName, VkResult result) {
|
|
if (result < 0 && result != VK_ERROR_VALIDATION_FAILED_EXT) {
|
|
std::string resultName = string_VkResult(result);
|
|
|
|
if (resultName == UnsupportedResultString) {
|
|
// Unrecognized result code
|
|
log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
|
|
FAILURE_RETURN_CODE, LayerName, "%s: returned a result code indicating that an error has occurred", apiName);
|
|
} else {
|
|
std::string resultDesc = get_result_description(result);
|
|
log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
|
|
FAILURE_RETURN_CODE, LayerName, "%s: returned %s, indicating that %s", apiName, resultName.c_str(),
|
|
resultDesc.c_str());
|
|
}
|
|
}
|
|
}
|
|
|
|
} // namespace parameter_validation
|
|
|
|
#endif // PARAMETER_VALIDATION_UTILS_H
|