bug-14538: Remove driver validation checks

Marked validation checks done in the driver with
TODOVV. Once we verify the check is covered in a
validation layer we can remove the driver code.

13 files changed, 40 insertions, 212 deletions

diff --git a/demos/cube.c b/demos/cube.c
index 272ef0ae..83755c10 100644
--- a/demos/cube.c
+++ b/demos/cube.c
@@ -2436,10 +2436,6 @@ static void demo_init_vk(struct demo *demo)
         switch (err) {
         case VK_SUCCESS:
             break;
-        case VK_ERROR_INVALID_POINTER:
-            ERR_EXIT("dbgCreateMsgCallback: Invalid pointer\n",
-                     "dbgCreateMsgCallback Failure");
-            break;
         case VK_ERROR_OUT_OF_HOST_MEMORY:
             ERR_EXIT("dbgCreateMsgCallback: out of host memory\n",
                      "dbgCreateMsgCallback Failure");
diff --git a/demos/tri.c b/demos/tri.c
index 0f3bcc38..30f95c96 100644
--- a/demos/tri.c
+++ b/demos/tri.c
@@ -1932,10 +1932,6 @@ static void demo_init_vk(struct demo *demo)
         switch (err) {
         case VK_SUCCESS:
             break;
-        case VK_ERROR_INVALID_POINTER:
-            ERR_EXIT("dbgCreateMsgCallback: Invalid pointer\n",
-                     "dbgCreateMsgCallback Failure");
-            break;
         case VK_ERROR_OUT_OF_HOST_MEMORY:
             ERR_EXIT("dbgCreateMsgCallback: out of host memory\n",
                      "dbgCreateMsgCallback Failure");
diff --git a/demos/vulkaninfo.c b/demos/vulkaninfo.c
index fd6c08ae..786a3833 100644
--- a/demos/vulkaninfo.c
+++ b/demos/vulkaninfo.c
@@ -138,36 +138,15 @@ static const char *vk_result_string(VkResult err)
     STR(VK_EVENT_SET);
     STR(VK_EVENT_RESET);
     STR(VK_ERROR_UNKNOWN);
-    STR(VK_ERROR_UNAVAILABLE);
     STR(VK_ERROR_INITIALIZATION_FAILED);
     STR(VK_ERROR_OUT_OF_HOST_MEMORY);
     STR(VK_ERROR_OUT_OF_DEVICE_MEMORY);
-    STR(VK_ERROR_DEVICE_ALREADY_CREATED);
     STR(VK_ERROR_DEVICE_LOST);
-    STR(VK_ERROR_INVALID_POINTER);
-    STR(VK_ERROR_INVALID_VALUE);
-    STR(VK_ERROR_INVALID_HANDLE);
-    STR(VK_ERROR_INVALID_ORDINAL);
-    STR(VK_ERROR_INVALID_MEMORY_SIZE);
     STR(VK_ERROR_INVALID_EXTENSION);
-    STR(VK_ERROR_INVALID_FLAGS);
-    STR(VK_ERROR_INVALID_ALIGNMENT);
-    STR(VK_ERROR_INVALID_FORMAT);
-    STR(VK_ERROR_INVALID_IMAGE);
-    STR(VK_ERROR_INVALID_DESCRIPTOR_SET_DATA);
-    STR(VK_ERROR_INVALID_QUEUE_TYPE);
-    STR(VK_ERROR_UNSUPPORTED_SHADER_IL_VERSION);
-    STR(VK_ERROR_BAD_SHADER_CODE);
-    STR(VK_ERROR_BAD_PIPELINE_DATA);
-    STR(VK_ERROR_NOT_MAPPABLE);
     STR(VK_ERROR_MEMORY_MAP_FAILED);
     STR(VK_ERROR_MEMORY_UNMAP_FAILED);
     STR(VK_ERROR_INCOMPATIBLE_DEVICE);
     STR(VK_ERROR_INCOMPATIBLE_DRIVER);
-    STR(VK_ERROR_INCOMPLETE_COMMAND_BUFFER);
-    STR(VK_ERROR_BUILDING_COMMAND_BUFFER);
-    STR(VK_ERROR_MEMORY_NOT_BOUND);
-    STR(VK_ERROR_INCOMPATIBLE_QUEUE);
 #undef STR
     default: return "UNKNOWN_RESULT";
     }
diff --git a/icd/common/icd-instance.c b/icd/common/icd-instance.c
index 449ff984..3568b763 100644
--- a/icd/common/icd-instance.c
+++ b/icd/common/icd-instance.c
@@ -123,9 +123,10 @@ VkResult icd_instance_create_logger(
 {
     struct icd_instance_logger *logger;
 
-    if (msg_obj == NULL) {
-        return VK_ERROR_INVALID_POINTER;
-    }
+    /* TODOVV: Move this test to a validation layer */
+//    if (msg_obj == NULL) {
+//        return VK_ERROR_INVALID_POINTER;
+//    }
 
     logger = icd_instance_alloc(instance, sizeof(*logger), 0,
             VK_SYSTEM_ALLOC_TYPE_DEBUG);
@@ -157,8 +158,9 @@ VkResult icd_instance_destroy_logger(
             break;
     }
 
-    if (!logger)
-        return VK_ERROR_INVALID_POINTER;
+    /* TODOVV: Move this to validation layer */
+//    if (!logger)
+//        return VK_ERROR_INVALID_POINTER;
 
     if (prev)
         prev->next = logger->next;
diff --git a/include/vulkan.h b/include/vulkan.h
index d1e4727f..23c68058 100644
--- a/include/vulkan.h
+++ b/include/vulkan.h
@@ -151,37 +151,16 @@ typedef enum {
     VK_EVENT_RESET = 5,
     VK_INCOMPLETE = 6,
     VK_ERROR_UNKNOWN = -1,
-    VK_ERROR_UNAVAILABLE = -2,
-    VK_ERROR_INITIALIZATION_FAILED = -3,
-    VK_ERROR_OUT_OF_HOST_MEMORY = -4,
-    VK_ERROR_OUT_OF_DEVICE_MEMORY = -5,
-    VK_ERROR_DEVICE_ALREADY_CREATED = -6,
-    VK_ERROR_DEVICE_LOST = -7,
-    VK_ERROR_INVALID_POINTER = -8,
-    VK_ERROR_INVALID_VALUE = -9,
-    VK_ERROR_INVALID_HANDLE = -10,
-    VK_ERROR_INVALID_ORDINAL = -11,
-    VK_ERROR_INVALID_MEMORY_SIZE = -12,
-    VK_ERROR_INVALID_EXTENSION = -13,
-    VK_ERROR_INVALID_FLAGS = -14,
-    VK_ERROR_INVALID_ALIGNMENT = -15,
-    VK_ERROR_INVALID_FORMAT = -16,
-    VK_ERROR_INVALID_IMAGE = -17,
-    VK_ERROR_INVALID_DESCRIPTOR_SET_DATA = -18,
-    VK_ERROR_INVALID_QUEUE_TYPE = -19,
-    VK_ERROR_UNSUPPORTED_SHADER_IL_VERSION = -20,
-    VK_ERROR_BAD_SHADER_CODE = -21,
-    VK_ERROR_BAD_PIPELINE_DATA = -22,
-    VK_ERROR_NOT_MAPPABLE = -23,
-    VK_ERROR_MEMORY_MAP_FAILED = -24,
-    VK_ERROR_MEMORY_UNMAP_FAILED = -25,
-    VK_ERROR_INCOMPATIBLE_DEVICE = -26,
-    VK_ERROR_INCOMPATIBLE_DRIVER = -27,
-    VK_ERROR_INCOMPLETE_COMMAND_BUFFER = -28,
-    VK_ERROR_BUILDING_COMMAND_BUFFER = -29,
-    VK_ERROR_MEMORY_NOT_BOUND = -30,
-    VK_ERROR_INCOMPATIBLE_QUEUE = -31,
-    VK_ERROR_INVALID_LAYER = -32,
+    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_RESULT_END_RANGE = VK_INCOMPLETE,
     VK_RESULT_NUM = (VK_INCOMPLETE - VK_ERROR_INVALID_LAYER + 1),
diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp
index 04bf3973..0c459ea8 100644
--- a/layers/draw_state.cpp
+++ b/layers/draw_state.cpp
@@ -1733,7 +1733,7 @@ VkResult VKAPI vkMergePipelineCaches(
 
 VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines)
 {
-    VkResult result = VK_ERROR_BAD_PIPELINE_DATA;
+    VkResult result = VK_SUCCESS;
     //TODO handle count > 1  and handle pipelineCache
     // The order of operations here is a little convoluted but gets the job done
     //  1. Pipeline create state is first shadowed into PIPELINE_NODE struct
@@ -1743,6 +1743,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipelines(VkDevice device, VkPipe
     PIPELINE_NODE* pPipeNode = initPipeline(pCreateInfos, NULL);
     VkBool32 valid = verifyPipelineCreateState(device, pPipeNode);
     loader_platform_thread_unlock_mutex(&globalLock);
+    /* TODO: preference is to make API call after reporting any validation errors */
     if (VK_TRUE == valid) {
         result = get_dispatch_table(draw_state_device_table_map, device)->CreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pPipelines);
         log_msg(mdd(device), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_PIPELINE, (*pPipelines).handle, 0, DRAWSTATE_NONE, "DS",
@@ -2061,8 +2062,9 @@ VK_LAYER_EXPORT VkResult VKAPI vkBeginCommandBuffer(VkCmdBuffer cmdBuffer, const
 
 VK_LAYER_EXPORT VkResult VKAPI vkEndCommandBuffer(VkCmdBuffer cmdBuffer)
 {
-    VkResult result = VK_ERROR_BUILDING_COMMAND_BUFFER;
+    VkResult result = VK_SUCCESS;
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
+    /* TODO: preference is to always call API function after reporting any validation errors */
     if (pCB) {
         if (pCB->state == CB_UPDATE_ACTIVE) {
             result = get_dispatch_table(draw_state_device_table_map, cmdBuffer)->EndCommandBuffer(cmdBuffer);
diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp
index d7e83168..49c65f1f 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -2056,7 +2056,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkResetFences(
                 if (!(fence_item->second.createInfo.flags & VK_FENCE_CREATE_SIGNALED_BIT)) {
                     log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_FENCE, pFences[i].handle, 0, MEMTRACK_INVALID_FENCE_STATE, "MEM",
                             "Fence %#" PRIxLEAST64 " submitted to VkResetFences in UNSIGNALED STATE", pFences[i].handle);
-                    result = VK_ERROR_INVALID_VALUE;
+                    result = VK_ERROR_UNKNOWN;
                 }
                 else {
                     fence_item->second.createInfo.flags =
diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp
index 3194f893..50d4e185 100644
--- a/layers/param_checker.cpp
+++ b/layers/param_checker.cpp
@@ -199,16 +199,6 @@ std::string EnumeratorString(VkResult const& enumerator)
             return "VK_ERROR_INVALID_LAYER";
             break;
         }
-        case VK_ERROR_MEMORY_NOT_BOUND:
-        {
-            return "VK_ERROR_MEMORY_NOT_BOUND";
-            break;
-        }
-        case VK_ERROR_BUILDING_COMMAND_BUFFER:
-        {
-            return "VK_ERROR_BUILDING_COMMAND_BUFFER";
-            break;
-        }
         case VK_ERROR_INCOMPATIBLE_DRIVER:
         {
             return "VK_ERROR_INCOMPATIBLE_DRIVER";
@@ -224,36 +214,6 @@ std::string EnumeratorString(VkResult const& enumerator)
             return "VK_ERROR_MEMORY_MAP_FAILED";
             break;
         }
-        case VK_ERROR_BAD_PIPELINE_DATA:
-        {
-            return "VK_ERROR_BAD_PIPELINE_DATA";
-            break;
-        }
-        case VK_ERROR_INVALID_QUEUE_TYPE:
-        {
-            return "VK_ERROR_INVALID_QUEUE_TYPE";
-            break;
-        }
-        case VK_ERROR_BAD_SHADER_CODE:
-        {
-            return "VK_ERROR_BAD_SHADER_CODE";
-            break;
-        }
-        case VK_ERROR_INVALID_IMAGE:
-        {
-            return "VK_ERROR_INVALID_IMAGE";
-            break;
-        }
-        case VK_ERROR_INVALID_FORMAT:
-        {
-            return "VK_ERROR_INVALID_FORMAT";
-            break;
-        }
-        case VK_ERROR_UNAVAILABLE:
-        {
-            return "VK_ERROR_UNAVAILABLE";
-            break;
-        }
         case VK_INCOMPLETE:
         {
             return "VK_INCOMPLETE";
@@ -269,11 +229,6 @@ std::string EnumeratorString(VkResult const& enumerator)
             return "VK_ERROR_UNKNOWN";
             break;
         }
-        case VK_ERROR_UNSUPPORTED_SHADER_IL_VERSION:
-        {
-            return "VK_ERROR_UNSUPPORTED_SHADER_IL_VERSION";
-            break;
-        }
         case VK_ERROR_INITIALIZATION_FAILED:
         {
             return "VK_ERROR_INITIALIZATION_FAILED";
@@ -284,21 +239,6 @@ std::string EnumeratorString(VkResult const& enumerator)
             return "VK_NOT_READY";
             break;
         }
-        case VK_ERROR_INVALID_POINTER:
-        {
-            return "VK_ERROR_INVALID_POINTER";
-            break;
-        }
-        case VK_ERROR_INVALID_VALUE:
-        {
-            return "VK_ERROR_INVALID_VALUE";
-            break;
-        }
-        case VK_ERROR_NOT_MAPPABLE:
-        {
-            return "VK_ERROR_NOT_MAPPABLE";
-            break;
-        }
         case VK_ERROR_OUT_OF_DEVICE_MEMORY:
         {
             return "VK_ERROR_OUT_OF_DEVICE_MEMORY";
@@ -314,31 +254,16 @@ std::string EnumeratorString(VkResult const& enumerator)
             return "VK_TIMEOUT";
             break;
         }
-        case VK_ERROR_INVALID_FLAGS:
-        {
-            return "VK_ERROR_INVALID_FLAGS";
-            break;
-        }
         case VK_EVENT_RESET:
         {
             return "VK_EVENT_RESET";
             break;
         }
-        case VK_ERROR_INVALID_DESCRIPTOR_SET_DATA:
-        {
-            return "VK_ERROR_INVALID_DESCRIPTOR_SET_DATA";
-            break;
-        }
         case VK_UNSUPPORTED:
         {
             return "VK_UNSUPPORTED";
             break;
         }
-        case VK_ERROR_INVALID_HANDLE:
-        {
-            return "VK_ERROR_INVALID_HANDLE";
-            break;
-        }
         case VK_ERROR_INCOMPATIBLE_DEVICE:
         {
             return "VK_ERROR_INCOMPATIBLE_DEVICE";
@@ -349,46 +274,16 @@ std::string EnumeratorString(VkResult const& enumerator)
             return "VK_SUCCESS";
             break;
         }
-        case VK_ERROR_INCOMPATIBLE_QUEUE:
-        {
-            return "VK_ERROR_INCOMPATIBLE_QUEUE";
-            break;
-        }
         case VK_ERROR_INVALID_EXTENSION:
         {
             return "VK_ERROR_INVALID_EXTENSION";
             break;
         }
-        case VK_ERROR_DEVICE_ALREADY_CREATED:
-        {
-            return "VK_ERROR_DEVICE_ALREADY_CREATED";
-            break;
-        }
         case VK_ERROR_DEVICE_LOST:
         {
             return "VK_ERROR_DEVICE_LOST";
             break;
         }
-        case VK_ERROR_INVALID_ORDINAL:
-        {
-            return "VK_ERROR_INVALID_ORDINAL";
-            break;
-        }
-        case VK_ERROR_INVALID_MEMORY_SIZE:
-        {
-            return "VK_ERROR_INVALID_MEMORY_SIZE";
-            break;
-        }
-        case VK_ERROR_INCOMPLETE_COMMAND_BUFFER:
-        {
-            return "VK_ERROR_INCOMPLETE_COMMAND_BUFFER";
-            break;
-        }
-        case VK_ERROR_INVALID_ALIGNMENT:
-        {
-            return "VK_ERROR_INVALID_ALIGNMENT";
-            break;
-        }
         default:
         {
             return "unrecognized enumerator";
diff --git a/layers/vk_layer_extension_utils.cpp b/layers/vk_layer_extension_utils.cpp
index 9e85a5b6..2a5d9a3c 100644
--- a/layers/vk_layer_extension_utils.cpp
+++ b/layers/vk_layer_extension_utils.cpp
@@ -42,10 +42,6 @@ VkResult util_GetExtensionProperties(
 {
     uint32_t copy_size;
 
-    if (pCount == NULL) {
-        return VK_ERROR_INVALID_POINTER;
-    }
-
     if (pProperties == NULL || layer_extensions == NULL) {
         *pCount = count;
         return VK_SUCCESS;
@@ -69,10 +65,6 @@ VkResult util_GetLayerProperties(
 {
     uint32_t copy_size;
 
-    if (pCount == NULL) {
-        return VK_ERROR_INVALID_POINTER;
-    }
-
     if (pProperties == NULL || layer_properties == NULL) {
         *pCount = count;
         return VK_SUCCESS;
diff --git a/loader/debug_report.c b/loader/debug_report.c
index c7c1d9a2..8a6bf5de 100644
--- a/loader/debug_report.c
+++ b/loader/debug_report.c
@@ -141,16 +141,18 @@ VkResult VKAPI loader_DbgCreateMsgCallback(
     VkResult res;
     uint32_t storage_idx;
 
-    if (instance == VK_NULL_HANDLE)
-        return VK_ERROR_INVALID_HANDLE;
+    /* TODOVV: move to validation layer */
+//    if (instance == VK_NULL_HANDLE)
+//        return VK_ERROR_INVALID_HANDLE;
 
     for (inst = loader.instances; inst; inst = inst->next) {
         if ((VkInstance) inst == instance)
             break;
     }
 
-    if (inst == VK_NULL_HANDLE)
-        return VK_ERROR_INVALID_HANDLE;
+    /* TODOVV: move to validation layer */
+//    if (inst == VK_NULL_HANDLE)
+//        return VK_ERROR_INVALID_HANDLE;
 
     icd_info = calloc(sizeof(VkDbgMsgCallback), inst->total_icd_count);
     if (!icd_info) {
@@ -210,16 +212,18 @@ VkResult VKAPI loader_DbgDestroyMsgCallback(
     VkResult res = VK_SUCCESS;
     struct loader_instance *inst;
 
-    if (instance == VK_NULL_HANDLE)
-        return VK_ERROR_INVALID_HANDLE;
+    /* TODOVV: Move to validation layer */
+//    if (instance == VK_NULL_HANDLE)
+//        return VK_ERROR_INVALID_HANDLE;
 
     for (inst = loader.instances; inst; inst = inst->next) {
         if ((VkInstance) inst == instance)
             break;
     }
 
-    if (inst == VK_NULL_HANDLE)
-        return VK_ERROR_INVALID_HANDLE;
+    /* TODOVV: Move to validation layer */
+//    if (inst == VK_NULL_HANDLE)
+//        return VK_ERROR_INVALID_HANDLE;
 
     icd_info = *(VkDbgMsgCallback **) &msgCallback;
     storage_idx = 0;
diff --git a/loader/loader.c b/loader/loader.c
index 0b7d1ba6..b12a065d 100644
--- a/loader/loader.c
+++ b/loader/loader.c
@@ -2664,10 +2664,11 @@ VkResult VKAPI loader_DestroyInstance(
         prev = next;
         next = next->next;
     }
-    if (next  == NULL) {
-        // This must be an invalid instance handle or empty list
-        return VK_ERROR_INVALID_HANDLE;
-    }
+    /* TODOVV: Move this test to validation layer */
+//    if (next  == NULL) {
+//        // This must be an invalid instance handle or empty list
+//        return VK_ERROR_INVALID_HANDLE;
+//    }
 
     while (icds) {
         if (icds->instance) {
@@ -3088,10 +3089,6 @@ LOADER_EXPORT VkResult VKAPI vkGetGlobalExtensionProperties(
     uint32_t copy_size;
 
     tls_instance = NULL;
-    if (pCount == NULL) {
-        return VK_ERROR_INVALID_POINTER;
-    }
-
     memset(&icd_extensions, 0, sizeof(icd_extensions));
     loader_platform_thread_once(&once_init, loader_initialize);
 
@@ -3160,10 +3157,6 @@ LOADER_EXPORT VkResult VKAPI vkGetGlobalLayerProperties(
 
     uint32_t copy_size;
 
-    if (pCount == NULL) {
-        return VK_ERROR_INVALID_POINTER;
-    }
-
     /* TODO: do we still need to lock */
     loader_platform_thread_lock_mutex(&loader_lock);
 
@@ -3203,10 +3196,6 @@ VkResult VKAPI loader_GetPhysicalDeviceExtensionProperties(
     struct loader_icd *icd = loader_get_icd(gpu, &gpu_index);
     uint32_t copy_size;
 
-    if (pCount == NULL) {
-        return VK_ERROR_INVALID_POINTER;
-    }
-
     uint32_t count;
     struct loader_extension_list *dev_ext_list;
 
@@ -3253,10 +3242,6 @@ VkResult VKAPI loader_GetPhysicalDeviceLayerProperties(
     uint32_t gpu_index;
     struct loader_icd *icd = loader_get_icd(gpu, &gpu_index);
 
-    if (pCount == NULL) {
-        return VK_ERROR_INVALID_POINTER;
-    }
-
     uint32_t count = icd->this_instance->device_layer_list.count;
 
     if (pProperties == NULL) {
diff --git a/loader/trampoline.c b/loader/trampoline.c
index 33971c33..4ca018c4 100644
--- a/loader/trampoline.c
+++ b/loader/trampoline.c
@@ -44,8 +44,6 @@ LOADER_EXPORT VkResult VKAPI vkCreateInstance(
     struct loader_instance *ptr_instance = NULL;
     VkResult res = VK_ERROR_INITIALIZATION_FAILED;
 
-    if (pCreateInfo == NULL)
-        return VK_ERROR_INVALID_POINTER;
     loader_platform_thread_once(&once_init, loader_initialize);
 
     if (pCreateInfo->pAllocCb
diff --git a/loader/wsi_swapchain.c b/loader/wsi_swapchain.c
index ec0ee0d0..a59f389b 100644
--- a/loader/wsi_swapchain.c
+++ b/loader/wsi_swapchain.c
@@ -95,7 +95,7 @@ VkResult VKAPI loader_GetPhysicalDeviceSurfaceSupportKHR(
 {
     uint32_t gpu_index;
     struct loader_icd *icd = loader_get_icd(physicalDevice, &gpu_index);
-    VkResult res = VK_ERROR_UNAVAILABLE;
+    VkResult res = VK_ERROR_UNKNOWN;
     *pSupported = false;
 
     if (icd->GetPhysicalDeviceSurfaceSupportKHR) {