Make validation errors a test error.

The current use of the validation layer will emit a message, but it will
not case a test to fail. By adding a call back that returns true for
error messages and warnings, test that have a validation error or
warning will fail.

I've made other changes to keep tests that already pass passing.

xfail test/Basic/TestPipeline.test.

Modify the VkBufferUsageFlagBits for cbuffers. They are uniform buffers
not uniform texel buffers.

Author: s-perron

lib/API/VK/Device.cpp

@@ -67,7 +67,7 @@ static VkBufferUsageFlagBits getFlagBits(const ResourceKind RK) {
   case ResourceKind::RWStructuredBuffer:
     return VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
   case ResourceKind::ConstantBuffer:
-    return VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT;
+    return VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
   }
   llvm_unreachable("All cases handled");
 }
@@ -86,6 +86,74 @@ static bool isUniform(const ResourceKind RK) {
   }
   llvm_unreachable("All cases handled");
 }
+
+static std::string getMessageSeverityString(
+    VkDebugUtilsMessageSeverityFlagBitsEXT MessageSeverity) {
+  if (MessageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT)
+    return "Error";
+  if (MessageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT)
+    return "Warning";
+  if (MessageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT)
+    return "Info";
+  if (MessageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT)
+    return "Verbose";
+  return "Unknown";
+}
+
+static VkBool32
+debugCallback(VkDebugUtilsMessageSeverityFlagBitsEXT MessageSeverity,
+              VkDebugUtilsMessageTypeFlagsEXT MessageType,
+              const VkDebugUtilsMessengerCallbackDataEXT *Data, void *) {
+  // Only interested in messages from the validation layers.
+  if (!(MessageType & VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT))
+    return VK_FALSE;
+
+  llvm::dbgs() << "Validation " << getMessageSeverityString(MessageSeverity);
+  llvm::dbgs() << ": [ " << Data->pMessageIdName << " ]\n";
+  llvm::dbgs() << Data->pMessage;
+
+  for (uint32_t I = 0; I < Data->objectCount; I++) {
+    llvm::dbgs() << '\n';
+    if (Data->pObjects[I].pObjectName) {
+      llvm::dbgs() << "[" << Data->pObjects[I].pObjectName << "]";
+    }
+  }
+  llvm::dbgs() << '\n';
+
+  // Return true to true the validation error or warning into an error in the
+  // vulkan API. This should causes tests to fail.
+  const bool IsErrorOrWarning =
+      MessageSeverity & (VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT |
+                         VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT);
+  if (IsErrorOrWarning)
+    return VK_TRUE;
+
+  // Continue to run even with VERBOSE and INFO messages.
+  return VK_FALSE;
+}
+
+static  VkDebugUtilsMessengerEXT registerDebugUtilCallback(VkInstance Instance) {
+    VkDebugUtilsMessengerCreateInfoEXT CreateInfo = {};
+    CreateInfo.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
+    CreateInfo.messageSeverity =
+        VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT |
+        VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT |
+        VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT;
+    CreateInfo.messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT |
+                             VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT |
+                             VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT;
+    CreateInfo.pfnUserCallback = debugCallback;
+    CreateInfo.pUserData = nullptr; // Optional
+    auto Func = (PFN_vkCreateDebugUtilsMessengerEXT)vkGetInstanceProcAddr(
+        Instance, "vkCreateDebugUtilsMessengerEXT");
+    if (Func == nullptr)
+      return VK_NULL_HANDLE;
+
+    VkDebugUtilsMessengerEXT DebugMessenger;
+    Func(Instance, &CreateInfo, nullptr, &DebugMessenger);
+    return DebugMessenger;
+}
+
 namespace {
 
 class VKDevice : public offloadtest::Device {
@@ -800,6 +868,7 @@ class VKDevice : public offloadtest::Device {
 class VKContext {
 private:
   VkInstance Instance = VK_NULL_HANDLE;
+  VkDebugUtilsMessengerEXT DebugMessenger = VK_NULL_HANDLE;
   llvm::SmallVector<std::shared_ptr<VKDevice>> Devices;
 
   VKContext() = default;
@@ -813,6 +882,13 @@ class VKContext {
   }
 
   void cleanup() {
+#ifndef NDEBUG
+    auto Func = (PFN_vkDestroyDebugUtilsMessengerEXT)vkGetInstanceProcAddr(
+        Instance, "vkDestroyDebugUtilsMessengerEXT");
+    if (Func != nullptr) {
+      Func(Instance, DebugMessenger, nullptr);
+    }
+#endif
     vkDestroyInstance(Instance, NULL);
     Instance = VK_NULL_HANDLE;
   }
@@ -860,6 +936,10 @@ class VKContext {
     const char *ValidationLayer = "VK_LAYER_KHRONOS_validation";
     CreateInfo.ppEnabledLayerNames = &ValidationLayer;
     CreateInfo.enabledLayerCount = 1;
+
+    const char *DebugUtilsExtensionName = "VK_EXT_debug_utils";
+    CreateInfo.ppEnabledExtensionNames = &DebugUtilsExtensionName;
+    CreateInfo.enabledExtensionCount = 1;
 #endif
 
     Res = vkCreateInstance(&CreateInfo, NULL, &Instance);
@@ -871,6 +951,10 @@ class VKContext {
                                      "Unknown Vulkan initialization error %d",
                                      Res);
 
+#ifndef NDEBUG
+    DebugMessenger = registerDebugUtilCallback(Instance);
+#endif
+
     DeviceCount = 0;
     if (vkEnumeratePhysicalDevices(Instance, &DeviceCount, nullptr))
       return llvm::createStringError(std::errc::no_such_device,

test/Basic/TestPipeline.test

@@ -40,6 +40,9 @@ DescriptorSets:
 ...
 #--- end
 
+# Tracking issue: https://github.com/llvm/llvm-project/issues/144580
+# XFAIL: Clang-Vulkan
+
 # RUN: split-file %s %t
 # RUN: %dxc_target -T cs_6_0 -E CSMain -Fo %t.o %t/source.hlsl
 # RUN: %offloader %t/pipeline.yaml %t.o | FileCheck %s