bug-14538: Remove validation error codes

https://cvs.khronos.org/bugzilla/show_bug.cgi?id=14538

9 files changed, 39 insertions, 62 deletions

diff --git a/demos/cube.c b/demos/cube.c
index 608c4801..aa743355 100644
--- a/demos/cube.c
+++ b/demos/cube.c
@@ -2308,7 +2308,7 @@ static void demo_init_vk(struct demo *demo)
                  "(ICD).\n\nPlease look at the Getting Started guide for "
                  "additional information.\n",
                  "vkCreateInstance Failure");
-    } else if (err == VK_ERROR_INVALID_EXTENSION) {
+    } else if (err == VK_ERROR_EXTENSION_NOT_PRESENT) {
         ERR_EXIT("Cannot find a specified extension library"
                  ".\nMake sure your layers path is set appropriately\n",
                  "vkCreateInstance Failure");
diff --git a/demos/tri.c b/demos/tri.c
index 8aa942ed..57661395 100644
--- a/demos/tri.c
+++ b/demos/tri.c
@@ -1833,7 +1833,7 @@ static void demo_init_vk(struct demo *demo)
                  "(ICD).\n\nPlease look at the Getting Started guide for "
                  "additional information.\n",
                  "vkCreateInstance Failure");
-    } else if (err == VK_ERROR_INVALID_EXTENSION) {
+    } else if (err == VK_ERROR_EXTENSION_NOT_PRESENT) {
         ERR_EXIT("Cannot find a specified extension library"
                  ".\nMake sure your layers path is set appropriately\n",
                  "vkCreateInstance Failure");
diff --git a/demos/vulkaninfo.c b/demos/vulkaninfo.c
index 234dbba9..fc2a33ba 100644
--- a/demos/vulkaninfo.c
+++ b/demos/vulkaninfo.c
@@ -137,15 +137,13 @@ static const char *vk_result_string(VkResult err)
     STR(VK_TIMEOUT);
     STR(VK_EVENT_SET);
     STR(VK_EVENT_RESET);
-    STR(VK_ERROR_UNKNOWN);
     STR(VK_ERROR_INITIALIZATION_FAILED);
     STR(VK_ERROR_OUT_OF_HOST_MEMORY);
     STR(VK_ERROR_OUT_OF_DEVICE_MEMORY);
     STR(VK_ERROR_DEVICE_LOST);
-    STR(VK_ERROR_INVALID_EXTENSION);
+    STR(VK_ERROR_LAYER_NOT_PRESENT);
+    STR(VK_ERROR_EXTENSION_NOT_PRESENT);
     STR(VK_ERROR_MEMORY_MAP_FAILED);
-    STR(VK_ERROR_MEMORY_UNMAP_FAILED);
-    STR(VK_ERROR_INCOMPATIBLE_DEVICE);
     STR(VK_ERROR_INCOMPATIBLE_DRIVER);
 #undef STR
     default: return "UNKNOWN_RESULT";
@@ -475,7 +473,7 @@ static void app_dev_init(struct app_dev *dev, struct app_gpu *gpu)
         }
         if (!extension_found) {
             printf("Cannot find extension: %s\n", known_extensions[i]);
-            ERR_EXIT(VK_ERROR_INVALID_EXTENSION);
+            ERR_EXIT(VK_ERROR_EXTENSION_NOT_PRESENT);
         }
     }
 
@@ -614,7 +612,7 @@ static void app_create_instance(struct app_instance *inst)
         }
         if (!extension_found) {
             printf("Cannot find extension: %s\n", known_extensions[i]);
-            ERR_EXIT(VK_ERROR_INVALID_EXTENSION);
+            ERR_EXIT(VK_ERROR_EXTENSION_NOT_PRESENT);
         }
     }
 
@@ -1095,7 +1093,7 @@ int main(int argc, char **argv)
         ERR_EXIT(err);
     if (gpu_count > MAX_GPUS) {
         printf("Too many GPUS found \n");
-        ERR_EXIT(VK_ERROR_UNKNOWN);
+        ERR_EXIT(-1);
     }
     err = vkEnumeratePhysicalDevices(inst.instance, &gpu_count, objs);
     if (err)
diff --git a/icd/nulldrv/nulldrv.c b/icd/nulldrv/nulldrv.c
index 2f471373..68014411 100644
--- a/icd/nulldrv/nulldrv.c
+++ b/icd/nulldrv/nulldrv.c
@@ -202,7 +202,7 @@ static VkResult nulldrv_dev_create(struct nulldrv_gpu *gpu,
                     info->ppEnabledExtensionNames[i]);
 
         if (ext == NULLDRV_EXT_INVALID)
-            return VK_ERROR_INVALID_EXTENSION;
+            return VK_ERROR_EXTENSION_NOT_PRESENT;
 
         dev->exts[ext] = true;
     }
@@ -1667,7 +1667,7 @@ ICD_EXPORT VkResult VKAPI vkMapMemory(
 
     *ppData = ptr;
 
-    return (ptr) ? VK_SUCCESS : VK_ERROR_UNKNOWN;
+    return (ptr) ? VK_SUCCESS : VK_ERROR_MEMORY_MAP_FAILED;
 }
 
 ICD_EXPORT void VKAPI vkUnmapMemory(
diff --git a/include/vulkan.h b/include/vulkan.h
index 1df07a06..89c93a26 100644
--- a/include/vulkan.h
+++ b/include/vulkan.h
@@ -150,20 +150,17 @@ typedef enum {
     VK_EVENT_SET = 4,
     VK_EVENT_RESET = 5,
     VK_INCOMPLETE = 6,
-    VK_ERROR_UNKNOWN = -1,
-    VK_ERROR_OUT_OF_HOST_MEMORY = -2,
-    VK_ERROR_OUT_OF_DEVICE_MEMORY = -3,
-    VK_ERROR_INITIALIZATION_FAILED = -4,
-    VK_ERROR_DEVICE_LOST = -5,
-    VK_ERROR_MEMORY_MAP_FAILED = -6,
-    VK_ERROR_MEMORY_UNMAP_FAILED = -7,
-    VK_ERROR_INCOMPATIBLE_DEVICE = -8,
-    VK_ERROR_INCOMPATIBLE_DRIVER = -9,
-    VK_ERROR_INVALID_EXTENSION = -10,
-    VK_ERROR_INVALID_LAYER = -11,
-    VK_RESULT_BEGIN_RANGE = VK_ERROR_INVALID_LAYER,
+    VK_ERROR_OUT_OF_HOST_MEMORY = -1,
+    VK_ERROR_OUT_OF_DEVICE_MEMORY = -2,
+    VK_ERROR_INITIALIZATION_FAILED = -3,
+    VK_ERROR_DEVICE_LOST = -4,
+    VK_ERROR_MEMORY_MAP_FAILED = -5,
+    VK_ERROR_LAYER_NOT_PRESENT = -6,
+    VK_ERROR_EXTENSION_NOT_PRESENT = -7,
+    VK_ERROR_INCOMPATIBLE_DRIVER = -8,
+    VK_RESULT_BEGIN_RANGE = VK_ERROR_INCOMPATIBLE_DRIVER,
     VK_RESULT_END_RANGE = VK_INCOMPLETE,
-    VK_RESULT_NUM = (VK_INCOMPLETE - VK_ERROR_INVALID_LAYER + 1),
+    VK_RESULT_NUM = (VK_INCOMPLETE - VK_ERROR_INCOMPATIBLE_DRIVER + 1),
     VK_RESULT_MAX_ENUM = 0x7FFFFFFF
 } VkResult;
 
diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp
index 74041192..c93f4875 100644
--- a/layers/param_checker.cpp
+++ b/layers/param_checker.cpp
@@ -185,9 +185,9 @@ std::string EnumeratorString(VkResult const& enumerator)
             return "VK_RESULT_MAX_ENUM";
             break;
         }
-        case VK_ERROR_INVALID_LAYER:
+        case VK_ERROR_LAYER_NOT_PRESENT:
         {
-            return "VK_ERROR_INVALID_LAYER";
+            return "VK_ERROR_LAYER_NOT_PRESENT";
             break;
         }
         case VK_ERROR_INCOMPATIBLE_DRIVER:
@@ -195,11 +195,6 @@ std::string EnumeratorString(VkResult const& enumerator)
             return "VK_ERROR_INCOMPATIBLE_DRIVER";
             break;
         }
-        case VK_ERROR_MEMORY_UNMAP_FAILED:
-        {
-            return "VK_ERROR_MEMORY_UNMAP_FAILED";
-            break;
-        }
         case VK_ERROR_MEMORY_MAP_FAILED:
         {
             return "VK_ERROR_MEMORY_MAP_FAILED";
@@ -215,11 +210,6 @@ std::string EnumeratorString(VkResult const& enumerator)
             return "VK_ERROR_OUT_OF_HOST_MEMORY";
             break;
         }
-        case VK_ERROR_UNKNOWN:
-        {
-            return "VK_ERROR_UNKNOWN";
-            break;
-        }
         case VK_ERROR_INITIALIZATION_FAILED:
         {
             return "VK_ERROR_INITIALIZATION_FAILED";
@@ -255,19 +245,14 @@ std::string EnumeratorString(VkResult const& enumerator)
             return "VK_UNSUPPORTED";
             break;
         }
-        case VK_ERROR_INCOMPATIBLE_DEVICE:
-        {
-            return "VK_ERROR_INCOMPATIBLE_DEVICE";
-            break;
-        }
         case VK_SUCCESS:
         {
             return "VK_SUCCESS";
             break;
         }
-        case VK_ERROR_INVALID_EXTENSION:
+        case VK_ERROR_EXTENSION_NOT_PRESENT:
         {
-            return "VK_ERROR_INVALID_EXTENSION";
+            return "VK_ERROR_EXTENSION_NOT_PRESENT";
             break;
         }
         case VK_ERROR_DEVICE_LOST:
diff --git a/layers/shader_checker.cpp b/layers/shader_checker.cpp
index 632947ab..678b5671 100644
--- a/layers/shader_checker.cpp
+++ b/layers/shader_checker.cpp
@@ -976,7 +976,7 @@ vkCreateGraphicsPipelines(VkDevice device,
         return get_dispatch_table(shader_checker_device_table_map, device)->CreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pPipelines);
     }
     else {
-        return VK_ERROR_UNKNOWN;
+        return VK_ERROR_VALIDATION_FAILED;
     }
 }
 
diff --git a/loader/loader.c b/loader/loader.c
index 29f8e958..c0965289 100644
--- a/loader/loader.c
+++ b/loader/loader.c
@@ -622,7 +622,7 @@ static VkResult loader_add_layer_names_to_list(
         layer_prop = loader_get_layer_property(search_target, search_list);
         if (!layer_prop) {
             loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Unable to find layer %s", search_target);
-            err = VK_ERROR_INVALID_LAYER;
+            err = VK_ERROR_LAYER_NOT_PRESENT;
             continue;
         }
 
@@ -2190,8 +2190,7 @@ VkResult loader_enable_instance_layers(
 {
     VkResult err;
 
-    if (inst == NULL)
-        return VK_ERROR_UNKNOWN;
+    assert(inst && "Cannot have null instance");
 
     if (!loader_init_layer_list(inst, &inst->activated_layer_list)) {
         loader_log(VK_DBG_REPORT_ERROR_BIT, 0, "Failed to alloc Instance activated layer list");
@@ -2323,8 +2322,7 @@ static VkResult loader_enable_device_layers(
 {
     VkResult err;
 
-    if (dev == NULL)
-        return VK_ERROR_UNKNOWN;
+    assert(dev && "Cannot have null device");
 
     if (dev->activated_layer_list.list == NULL || dev->activated_layer_list.capacity == 0) {
         loader_init_layer_list(inst, &dev->activated_layer_list);
@@ -2467,7 +2465,7 @@ VkResult loader_validate_layers(
         prop = loader_get_layer_property(ppEnabledLayerNames[i],
                                   list);
         if (!prop) {
-            return VK_ERROR_INVALID_LAYER;
+            return VK_ERROR_LAYER_NOT_PRESENT;
         }
     }
 
@@ -2513,7 +2511,7 @@ VkResult loader_validate_instance_extensions(
 
         if (!extension_prop) {
             /* Didn't find extension name in any of the global layers, error out */
-            return VK_ERROR_INVALID_EXTENSION;
+            return VK_ERROR_EXTENSION_NOT_PRESENT;
         }
     }
     return VK_SUCCESS;
@@ -2560,7 +2558,7 @@ VkResult loader_validate_device_extensions(
 
         if (!extension_prop) {
             /* Didn't find extension name in any of the device layers, error out */
-            return VK_ERROR_INVALID_EXTENSION;
+            return VK_ERROR_EXTENSION_NOT_PRESENT;
         }
     }
     return VK_SUCCESS;
@@ -2698,7 +2696,7 @@ VkResult loader_init_physical_device_info(
 {
     struct loader_icd *icd;
     uint32_t n, count = 0;
-    VkResult res = VK_ERROR_UNKNOWN;
+    VkResult res;
 
     icd = ptr_instance->icds;
     while (icd) {
@@ -3122,7 +3120,7 @@ LOADER_EXPORT VkResult VKAPI vkEnumerateInstanceExtensionProperties(
 
     if (global_ext_list == NULL) {
         loader_platform_thread_unlock_mutex(&loader_lock);
-        return VK_ERROR_INVALID_LAYER;
+        return VK_ERROR_LAYER_NOT_PRESENT;
     }
 
     if (pProperties == NULL) {
diff --git a/loader/wsi_swapchain.c b/loader/wsi_swapchain.c
index a59f389b..e6f2387f 100644
--- a/loader/wsi_swapchain.c
+++ b/loader/wsi_swapchain.c
@@ -95,17 +95,16 @@ VkResult VKAPI loader_GetPhysicalDeviceSurfaceSupportKHR(
 {
     uint32_t gpu_index;
     struct loader_icd *icd = loader_get_icd(physicalDevice, &gpu_index);
-    VkResult res = VK_ERROR_UNKNOWN;
+
+    assert(pSupported && "GetPhysicalDeviceSurfaceSupportKHR: Error, null pSupported");
     *pSupported = false;
 
-    if (icd->GetPhysicalDeviceSurfaceSupportKHR) {
-        res = icd->GetPhysicalDeviceSurfaceSupportKHR(physicalDevice,
-                                                      queueNodeIndex,
-                                                      pSurfaceDescription,
-                                                      pSupported);
-    }
+    assert(icd->GetPhysicalDeviceSurfaceSupportKHR && "loader: null GetPhysicalDeviceSurfaceSupportKHR ICD pointer");
 
-    return res;
+    return icd->GetPhysicalDeviceSurfaceSupportKHR(physicalDevice,
+                                                  queueNodeIndex,
+                                                  pSurfaceDescription,
+                                                  pSupported);
 }