Method ValidateStructPnext

layers/stateless/sl_utils.cpp:234–306

}

bool Context::ValidateStructPnext(const Location& loc, const void* next, size_t allowed_type_count,
                                  const VkStructureType* allowed_types, uint32_t header_version, const char* pnext_vuid,
                                  const char* stype_vuid, const bool is_const_param) const {
    bool skip = false;

    if (HasCustomStypeInfo()) {
        return skip;
    }

    if (next != nullptr) {
        vvl::unordered_set<const void*> cycle_check;
        vvl::unordered_set<VkStructureType, vvl::hash<int>> unique_stype_check;
        const char* disclaimer =
            "This error is based on the Valid Usage documentation for version %" PRIu32
            " 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 the use of %s is undefined and may not work correctly with validation enabled";

        const Location pNext_loc = loc.dot(Field::pNext);
        if (allowed_type_count == 0) {
            std::string message = "must be NULL.\n";
            message += disclaimer;
            skip |=
                log.LogError(pnext_vuid, error_obj.handle, pNext_loc, message.c_str(), header_version, pNext_loc.Fields().c_str());
        } else {
            const VkStructureType* start = allowed_types;
            const VkStructureType* end = allowed_types + allowed_type_count;
            const VkBaseOutStructure* current = reinterpret_cast<const VkBaseOutStructure*>(next);

            while (current != nullptr) {
                if ((loc.function != Func::vkCreateInstance || (current->sType != VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO)) &&
                    (loc.function != Func::vkCreateDevice || (current->sType != VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO))) {
                    if (unique_stype_check.find(current->sType) != unique_stype_check.end() && !IsDuplicatePnext(current->sType)) {
                        // stype_vuid will only be null if there are no listed pNext and will hit disclaimer check
                        skip |= log.LogError(stype_vuid, error_obj.handle, pNext_loc,
                                             "chain contains duplicate structure types: %s appears multiple times.\n%s",
                                             string_VkStructureName(current->sType), PrintPNextChain(loc.structure, next).c_str());
                    } else {
                        unique_stype_check.insert(current->sType);
                    }

                    if (std::find(start, end, current->sType) == end) {
                        const std::string type_name = string_VkStructureType(current->sType);
                        if (type_name.compare("Unhandled VkStructureType") == 0) {
                            std::string message = "chain includes a structure with unknown VkStructureType (%" PRIu32 ").\n%s\n";
                            message += disclaimer;
                            skip |= log.LogError(pnext_vuid, error_obj.handle, pNext_loc, message.c_str(), current->sType,
                                                 PrintPNextChain(Struct::Empty, next).c_str(), header_version,
                                                 pNext_loc.Fields().c_str());
                        } else {
                            std::string message = "chain includes a structure with unexpected VkStructureType %s.\n%s\n";
                            message += disclaimer;
                            skip |= log.LogError(pnext_vuid, error_obj.handle, pNext_loc, message.c_str(), type_name.c_str(),
                                                 PrintPNextChain(Struct::Empty, next).c_str(), header_version,
                                                 pNext_loc.Fields().c_str());
                        }
                    }
                    // Send Location without pNext field so the pNext() connector can be used