loader: Add support for 1.0.35 extension

Add support for the NVX_device_generated_commands.  This was
necessary since it exposes one instance command (which takes
a VkPhysicalDevice).

Change-Id: I1da4c24ca0d385a6485581f55a1b19aa7ea51d24

5 files changed, 184 insertions, 0 deletions

diff --git a/loader/extensions.c b/loader/extensions.c
index 5503df52..a57ab729 100644
--- a/loader/extensions.c
+++ b/loader/extensions.c
@@ -215,6 +215,101 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV(
 
 #endif // VK_USE_PLATFORM_WIN32_KHR
 
+// Definitions for the VK_NVX_device_generated_commands
+
+VKAPI_ATTR void VKAPI_CALL vkCmdProcessCommandsNVX(
+    VkCommandBuffer commandBuffer,
+    const VkCmdProcessCommandsInfoNVX *pProcessCommandsInfo) {
+    const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer);
+    disp->CmdProcessCommandsNVX(commandBuffer, pProcessCommandsInfo);
+}
+
+VKAPI_ATTR void VKAPI_CALL vkCmdReserveSpaceForCommandsNVX(
+    VkCommandBuffer commandBuffer,
+    const VkCmdReserveSpaceForCommandsInfoNVX *pReserveSpaceInfo) {
+    const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer);
+    disp->CmdReserveSpaceForCommandsNVX(commandBuffer, pReserveSpaceInfo);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutNVX(
+    VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX *pCreateInfo,
+    const VkAllocationCallbacks *pAllocator,
+    VkIndirectCommandsLayoutNVX *pIndirectCommandsLayout) {
+    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+    return disp->CreateIndirectCommandsLayoutNVX(
+        device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
+}
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutNVX(
+    VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout,
+    const VkAllocationCallbacks *pAllocator) {
+    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+    disp->DestroyIndirectCommandsLayoutNVX(device, indirectCommandsLayout,
+                                           pAllocator);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateObjectTableNVX(
+    VkDevice device, const VkObjectTableCreateInfoNVX *pCreateInfo,
+    const VkAllocationCallbacks *pAllocator, VkObjectTableNVX *pObjectTable) {
+    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+    return disp->CreateObjectTableNVX(device, pCreateInfo, pAllocator,
+                                      pObjectTable);
+}
+
+VKAPI_ATTR void VKAPI_CALL
+vkDestroyObjectTableNVX(VkDevice device, VkObjectTableNVX objectTable,
+                        const VkAllocationCallbacks *pAllocator) {
+    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+    disp->DestroyObjectTableNVX(device, objectTable, pAllocator);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkRegisterObjectsNVX(
+    VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount,
+    const VkObjectTableEntryNVX *const *ppObjectTableEntries,
+    const uint32_t *pObjectIndices) {
+    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+    return disp->RegisterObjectsNVX(device, objectTable, objectCount,
+                                    ppObjectTableEntries, pObjectIndices);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkUnregisterObjectsNVX(
+    VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount,
+    const VkObjectEntryTypeNVX *pObjectEntryTypes,
+    const uint32_t *pObjectIndices) {
+    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+    return disp->UnregisterObjectsNVX(device, objectTable, objectCount,
+                                      pObjectEntryTypes, pObjectIndices);
+}
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
+    VkPhysicalDevice physicalDevice,
+    VkDeviceGeneratedCommandsFeaturesNVX *pFeatures,
+    VkDeviceGeneratedCommandsLimitsNVX *pLimits) {
+    const VkLayerInstanceDispatchTable *disp;
+    VkPhysicalDevice unwrapped_phys_dev =
+        loader_unwrap_physical_device(physicalDevice);
+    disp = loader_get_instance_dispatch(physicalDevice);
+    disp->GetPhysicalDeviceGeneratedCommandsPropertiesNVX(unwrapped_phys_dev,
+                                                          pFeatures, pLimits);
+}
+
+VKAPI_ATTR void VKAPI_CALL
+terminator_GetPhysicalDeviceGeneratedCommandsPropertiesNVX(
+    VkPhysicalDevice physicalDevice,
+    VkDeviceGeneratedCommandsFeaturesNVX *pFeatures,
+    VkDeviceGeneratedCommandsLimitsNVX *pLimits) {
+    struct loader_physical_device_term *phys_dev_term =
+        (struct loader_physical_device_term *)physicalDevice;
+    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
+    if (NULL == icd_term->GetPhysicalDeviceGeneratedCommandsPropertiesNVX) {
+        loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
+                   "ICD associated with VkPhysicalDevice does not support "
+                   "vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX");
+    }
+    icd_term->GetPhysicalDeviceGeneratedCommandsPropertiesNVX(
+        phys_dev_term->phys_dev, pFeatures, pLimits);
+}
+
 // GPA helpers for non-KHR extensions
 
 bool extension_instance_gpa(struct loader_instance *ptr_instance,
@@ -267,6 +362,45 @@ bool extension_instance_gpa(struct loader_instance *ptr_instance,
 
 #endif // VK_USE_PLATFORM_WIN32_KHR
 
+    // Functions for the VK_NVX_device_generated_commands extension
+
+    if (!strcmp("vkCmdProcessCommandsNVX", name)) {
+        *addr = (void *)vkCmdProcessCommandsNVX;
+        return true;
+    }
+    if (!strcmp("vkCmdReserveSpaceForCommandsNVX", name)) {
+        *addr = (void *)vkCmdReserveSpaceForCommandsNVX;
+        return true;
+    }
+    if (!strcmp("vkCreateIndirectCommandsLayoutNVX", name)) {
+        *addr = (void *)vkCreateIndirectCommandsLayoutNVX;
+        return true;
+    }
+    if (!strcmp("vkDestroyIndirectCommandsLayoutNVX", name)) {
+        *addr = (void *)vkDestroyIndirectCommandsLayoutNVX;
+        return true;
+    }
+    if (!strcmp("vkCreateObjectTableNVX", name)) {
+        *addr = (void *)vkCreateObjectTableNVX;
+        return true;
+    }
+    if (!strcmp("vkDestroyObjectTableNVX", name)) {
+        *addr = (void *)vkDestroyObjectTableNVX;
+        return true;
+    }
+    if (!strcmp("vkRegisterObjectsNVX", name)) {
+        *addr = (void *)vkRegisterObjectsNVX;
+        return true;
+    }
+    if (!strcmp("vkUnregisterObjectsNVX", name)) {
+        *addr = (void *)vkUnregisterObjectsNVX;
+        return true;
+    }
+    if (!strcmp("vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX", name)) {
+        *addr = (void *)vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX;
+        return true;
+    }
+
     return false;
 }
 
diff --git a/loader/extensions.h b/loader/extensions.h
index 2e922e5a..71759650 100644
--- a/loader/extensions.h
+++ b/loader/extensions.h
@@ -45,3 +45,11 @@ terminator_GetPhysicalDeviceExternalImageFormatPropertiesNV(
     VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags,
     VkExternalMemoryHandleTypeFlagsNV externalHandleType,
     VkExternalImageFormatPropertiesNV *pExternalImageFormatProperties);
+
+// Instance extension terminators for the VK_NVX_device_generated_commands
+// extension
+VKAPI_ATTR void VKAPI_CALL
+terminator_GetPhysicalDeviceGeneratedCommandsPropertiesNVX(
+    VkPhysicalDevice physicalDevice,
+    VkDeviceGeneratedCommandsFeaturesNVX *pFeatures,
+    VkDeviceGeneratedCommandsLimitsNVX *pLimits);
diff --git a/loader/loader.c b/loader/loader.c
index 3ddbfe31..85b5f48c 100644
--- a/loader/loader.c
+++ b/loader/loader.c
@@ -158,6 +158,10 @@ const VkLayerInstanceDispatchTable instance_disp = {
     .CreateDisplayModeKHR = terminator_CreateDisplayModeKHR,
     .GetDisplayPlaneCapabilitiesKHR = terminator_GetDisplayPlaneCapabilitiesKHR,
     .CreateDisplayPlaneSurfaceKHR = terminator_CreateDisplayPlaneSurfaceKHR,
+
+    // NVX_device_generated_commands
+    .GetPhysicalDeviceGeneratedCommandsPropertiesNVX =
+        terminator_GetPhysicalDeviceGeneratedCommandsPropertiesNVX,
 };
 
 LOADER_PLATFORM_THREAD_ONCE_DECLARATION(once_init);
@@ -1680,7 +1684,10 @@ static bool loader_icd_init_entrys(struct loader_icd_term *icd_term,
     LOOKUP_GIPA(CreateWaylandSurfaceKHR, false);
     LOOKUP_GIPA(GetPhysicalDeviceWaylandPresentationSupportKHR, false);
 #endif
+    // NV_external_memory_capabilities
     LOOKUP_GIPA(GetPhysicalDeviceExternalImageFormatPropertiesNV, false);
+    // NVX_device_generated_commands
+    LOOKUP_GIPA(GetPhysicalDeviceGeneratedCommandsPropertiesNVX, false);
 
 #undef LOOKUP_GIPA
 
diff --git a/loader/loader.h b/loader/loader.h
index fc035ed3..a8a5a2a2 100644
--- a/loader/loader.h
+++ b/loader/loader.h
@@ -249,6 +249,11 @@ struct loader_icd_term {
     PFN_vkCreateDisplayPlaneSurfaceKHR CreateDisplayPlaneSurfaceKHR;
     PFN_vkDestroySurfaceKHR DestroySurfaceKHR;
     PFN_vkCreateSwapchainKHR CreateSwapchainKHR;
+
+    // NVX_device_generated_commands
+    PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX
+        GetPhysicalDeviceGeneratedCommandsPropertiesNVX;
+
     struct loader_icd_term *next;
 };
 
diff --git a/loader/table_ops.h b/loader/table_ops.h
index 0e42d0ca..13c9ac7e 100644
--- a/loader/table_ops.h
+++ b/loader/table_ops.h
@@ -290,6 +290,27 @@ static inline void loader_init_device_extension_dispatch_table(
         (PFN_vkCmdDebugMarkerEndEXT)gpa(dev, "vkCmdDebugMarkerEndEXT");
     table->CmdDebugMarkerInsertEXT =
         (PFN_vkCmdDebugMarkerInsertEXT)gpa(dev, "vkCmdDebugMarkerInsertEXT");
+
+    // NVX_device_generated_commands
+    table->CmdProcessCommandsNVX =
+        (PFN_vkCmdProcessCommandsNVX)gpa(dev, "vkCmdProcessCommandsNVX");
+    table->CmdReserveSpaceForCommandsNVX =
+        (PFN_vkCmdReserveSpaceForCommandsNVX)gpa(
+            dev, "vkCmdReserveSpaceForCommandsNVX");
+    table->CreateIndirectCommandsLayoutNVX =
+        (PFN_vkCreateIndirectCommandsLayoutNVX)gpa(
+            dev, "vkCreateIndirectCommandsLayoutNVX");
+    table->DestroyIndirectCommandsLayoutNVX =
+        (PFN_vkDestroyIndirectCommandsLayoutNVX)gpa(
+            dev, "vkDestroyIndirectCommandsLayoutNVX");
+    table->CreateObjectTableNVX =
+        (PFN_vkCreateObjectTableNVX)gpa(dev, "vkCreateObjectTableNVX");
+    table->DestroyObjectTableNVX =
+        (PFN_vkDestroyObjectTableNVX)gpa(dev, "vkDestroyObjectTableNVX");
+    table->RegisterObjectsNVX =
+        (PFN_vkRegisterObjectsNVX)gpa(dev, "vkRegisterObjectsNVX");
+    table->UnregisterObjectsNVX =
+        (PFN_vkUnregisterObjectsNVX)gpa(dev, "vkUnregisterObjectsNVX");
 }
 
 static inline void *
@@ -687,6 +708,11 @@ static inline void loader_init_instance_extension_dispatch_table(
     table->CreateDisplayPlaneSurfaceKHR =
         (PFN_vkCreateDisplayPlaneSurfaceKHR)gpa(
             inst, "vkCreateDisplayPlaneSurfaceKHR");
+
+    // NVX_device_generated_commands (physical device commands)
+    table->GetPhysicalDeviceGeneratedCommandsPropertiesNVX =
+        (PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX)gpa(
+            inst, "vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX");
 }
 
 static inline void *
@@ -787,6 +813,10 @@ loader_lookup_instance_dispatch_table(const VkLayerInstanceDispatchTable *table,
     if (!strcmp(name, "DebugReportMessageEXT"))
         return (void *)table->DebugReportMessageEXT;
 
+    // NVX_device_generated_commands
+    if (!strcmp(name, "GetPhysicalDeviceGeneratedCommandsPropertiesNVX"))
+        return (void *)table->GetPhysicalDeviceGeneratedCommandsPropertiesNVX;
+
     *found_name = false;
     return NULL;
 }