build: Update to header v1.4.351

headerbot[bot] · mikes-lunarg · commit 506124c4ac34 · 2026-05-07T19:53:54.000-07:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -18,7 +18,7 @@
 # ~~~
 cmake_minimum_required(VERSION 3.22.1)
 
-project(VULKAN_LOADER VERSION 1.4.350 LANGUAGES C)
+project(VULKAN_LOADER VERSION 1.4.351 LANGUAGES C)
 
 option(CODE_COVERAGE "Enable Code Coverage" OFF)
 if (CODE_COVERAGE)
diff --git a/loader/generated/vk_layer_dispatch_table.h b/loader/generated/vk_layer_dispatch_table.h
@@ -884,6 +884,20 @@ typedef struct VkLayerDispatchTable_ {
     PFN_vkGetMemoryAndroidHardwareBufferANDROID GetMemoryAndroidHardwareBufferANDROID;
 #endif // VK_USE_PLATFORM_ANDROID_KHR
 
+    // ---- VK_AMD_gpa_interface extension commands
+    PFN_vkCreateGpaSessionAMD CreateGpaSessionAMD;
+    PFN_vkDestroyGpaSessionAMD DestroyGpaSessionAMD;
+    PFN_vkSetGpaDeviceClockModeAMD SetGpaDeviceClockModeAMD;
+    PFN_vkGetGpaDeviceClockInfoAMD GetGpaDeviceClockInfoAMD;
+    PFN_vkCmdBeginGpaSessionAMD CmdBeginGpaSessionAMD;
+    PFN_vkCmdEndGpaSessionAMD CmdEndGpaSessionAMD;
+    PFN_vkCmdBeginGpaSampleAMD CmdBeginGpaSampleAMD;
+    PFN_vkCmdEndGpaSampleAMD CmdEndGpaSampleAMD;
+    PFN_vkGetGpaSessionStatusAMD GetGpaSessionStatusAMD;
+    PFN_vkGetGpaSessionResultsAMD GetGpaSessionResultsAMD;
+    PFN_vkResetGpaSessionAMD ResetGpaSessionAMD;
+    PFN_vkCmdCopyGpaSessionResultsAMD CmdCopyGpaSessionResultsAMD;
+
     // ---- VK_AMDX_shader_enqueue extension commands
 #if defined(VK_ENABLE_BETA_EXTENSIONS)
     PFN_vkCreateExecutionGraphPipelinesAMDX CreateExecutionGraphPipelinesAMDX;
diff --git a/loader/generated/vk_loader_extensions.c b/loader/generated/vk_loader_extensions.c
@@ -925,6 +925,20 @@ VKAPI_ATTR void VKAPI_CALL loader_init_device_extension_dispatch_table(struct lo
     table->GetMemoryAndroidHardwareBufferANDROID = (PFN_vkGetMemoryAndroidHardwareBufferANDROID)gdpa(dev, "vkGetMemoryAndroidHardwareBufferANDROID");
 #endif // VK_USE_PLATFORM_ANDROID_KHR
 
+    // ---- VK_AMD_gpa_interface extension commands
+    table->CreateGpaSessionAMD = (PFN_vkCreateGpaSessionAMD)gdpa(dev, "vkCreateGpaSessionAMD");
+    table->DestroyGpaSessionAMD = (PFN_vkDestroyGpaSessionAMD)gdpa(dev, "vkDestroyGpaSessionAMD");
+    table->SetGpaDeviceClockModeAMD = (PFN_vkSetGpaDeviceClockModeAMD)gdpa(dev, "vkSetGpaDeviceClockModeAMD");
+    table->GetGpaDeviceClockInfoAMD = (PFN_vkGetGpaDeviceClockInfoAMD)gdpa(dev, "vkGetGpaDeviceClockInfoAMD");
+    table->CmdBeginGpaSessionAMD = (PFN_vkCmdBeginGpaSessionAMD)gdpa(dev, "vkCmdBeginGpaSessionAMD");
+    table->CmdEndGpaSessionAMD = (PFN_vkCmdEndGpaSessionAMD)gdpa(dev, "vkCmdEndGpaSessionAMD");
+    table->CmdBeginGpaSampleAMD = (PFN_vkCmdBeginGpaSampleAMD)gdpa(dev, "vkCmdBeginGpaSampleAMD");
+    table->CmdEndGpaSampleAMD = (PFN_vkCmdEndGpaSampleAMD)gdpa(dev, "vkCmdEndGpaSampleAMD");
+    table->GetGpaSessionStatusAMD = (PFN_vkGetGpaSessionStatusAMD)gdpa(dev, "vkGetGpaSessionStatusAMD");
+    table->GetGpaSessionResultsAMD = (PFN_vkGetGpaSessionResultsAMD)gdpa(dev, "vkGetGpaSessionResultsAMD");
+    table->ResetGpaSessionAMD = (PFN_vkResetGpaSessionAMD)gdpa(dev, "vkResetGpaSessionAMD");
+    table->CmdCopyGpaSessionResultsAMD = (PFN_vkCmdCopyGpaSessionResultsAMD)gdpa(dev, "vkCmdCopyGpaSessionResultsAMD");
+
     // ---- VK_AMDX_shader_enqueue extension commands
 #if defined(VK_ENABLE_BETA_EXTENSIONS)
     table->CreateExecutionGraphPipelinesAMDX = (PFN_vkCreateExecutionGraphPipelinesAMDX)gdpa(dev, "vkCreateExecutionGraphPipelinesAMDX");
@@ -2998,6 +3012,20 @@ VKAPI_ATTR void* VKAPI_CALL loader_lookup_device_dispatch_table(const VkLayerDis
     if (!strcmp(name, "GetMemoryAndroidHardwareBufferANDROID")) return (void *)table->GetMemoryAndroidHardwareBufferANDROID;
 #endif // VK_USE_PLATFORM_ANDROID_KHR
 
+    // ---- VK_AMD_gpa_interface extension commands
+    if (!strcmp(name, "CreateGpaSessionAMD")) return (void *)table->CreateGpaSessionAMD;
+    if (!strcmp(name, "DestroyGpaSessionAMD")) return (void *)table->DestroyGpaSessionAMD;
+    if (!strcmp(name, "SetGpaDeviceClockModeAMD")) return (void *)table->SetGpaDeviceClockModeAMD;
+    if (!strcmp(name, "GetGpaDeviceClockInfoAMD")) return (void *)table->GetGpaDeviceClockInfoAMD;
+    if (!strcmp(name, "CmdBeginGpaSessionAMD")) return (void *)table->CmdBeginGpaSessionAMD;
+    if (!strcmp(name, "CmdEndGpaSessionAMD")) return (void *)table->CmdEndGpaSessionAMD;
+    if (!strcmp(name, "CmdBeginGpaSampleAMD")) return (void *)table->CmdBeginGpaSampleAMD;
+    if (!strcmp(name, "CmdEndGpaSampleAMD")) return (void *)table->CmdEndGpaSampleAMD;
+    if (!strcmp(name, "GetGpaSessionStatusAMD")) return (void *)table->GetGpaSessionStatusAMD;
+    if (!strcmp(name, "GetGpaSessionResultsAMD")) return (void *)table->GetGpaSessionResultsAMD;
+    if (!strcmp(name, "ResetGpaSessionAMD")) return (void *)table->ResetGpaSessionAMD;
+    if (!strcmp(name, "CmdCopyGpaSessionResultsAMD")) return (void *)table->CmdCopyGpaSessionResultsAMD;
+
     // ---- VK_AMDX_shader_enqueue extension commands
 #if defined(VK_ENABLE_BETA_EXTENSIONS)
     if (!strcmp(name, "CreateExecutionGraphPipelinesAMDX")) return (void *)table->CreateExecutionGraphPipelinesAMDX;
@@ -7124,6 +7152,174 @@ VKAPI_ATTR VkResult VKAPI_CALL GetMemoryAndroidHardwareBufferANDROID(
 
 #endif // VK_USE_PLATFORM_ANDROID_KHR
 
+// ---- VK_AMD_gpa_interface extension trampoline/terminators
+
+VKAPI_ATTR VkResult VKAPI_CALL CreateGpaSessionAMD(
+    VkDevice                                    device,
+    const VkGpaSessionCreateInfoAMD*            pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkGpaSessionAMD*                            pGpaSession) {
+    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+    if (NULL == disp) {
+        loader_log(NULL, VULKAN_LOADER_FATAL_ERROR_BIT | VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0,
+                   "vkCreateGpaSessionAMD: Invalid device "
+                   "[VUID-vkCreateGpaSessionAMD-device-parameter]");
+        abort(); /* Intentionally fail so user can correct issue. */
+    }
+    return disp->CreateGpaSessionAMD(device, pCreateInfo, pAllocator, pGpaSession);
+}
+
+VKAPI_ATTR void VKAPI_CALL DestroyGpaSessionAMD(
+    VkDevice                                    device,
+    VkGpaSessionAMD                             gpaSession,
+    const VkAllocationCallbacks*                pAllocator) {
+    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+    if (NULL == disp) {
+        loader_log(NULL, VULKAN_LOADER_FATAL_ERROR_BIT | VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0,
+                   "vkDestroyGpaSessionAMD: Invalid device "
+                   "[VUID-vkDestroyGpaSessionAMD-device-parameter]");
+        abort(); /* Intentionally fail so user can correct issue. */
+    }
+    disp->DestroyGpaSessionAMD(device, gpaSession, pAllocator);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL SetGpaDeviceClockModeAMD(
+    VkDevice                                    device,
+    VkGpaDeviceClockModeInfoAMD*                pInfo) {
+    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+    if (NULL == disp) {
+        loader_log(NULL, VULKAN_LOADER_FATAL_ERROR_BIT | VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0,
+                   "vkSetGpaDeviceClockModeAMD: Invalid device "
+                   "[VUID-vkSetGpaDeviceClockModeAMD-device-parameter]");
+        abort(); /* Intentionally fail so user can correct issue. */
+    }
+    return disp->SetGpaDeviceClockModeAMD(device, pInfo);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetGpaDeviceClockInfoAMD(
+    VkDevice                                    device,
+    VkGpaDeviceGetClockInfoAMD*                 pInfo) {
+    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+    if (NULL == disp) {
+        loader_log(NULL, VULKAN_LOADER_FATAL_ERROR_BIT | VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0,
+                   "vkGetGpaDeviceClockInfoAMD: Invalid device "
+                   "[VUID-vkGetGpaDeviceClockInfoAMD-device-parameter]");
+        abort(); /* Intentionally fail so user can correct issue. */
+    }
+    return disp->GetGpaDeviceClockInfoAMD(device, pInfo);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CmdBeginGpaSessionAMD(
+    VkCommandBuffer                             commandBuffer,
+    VkGpaSessionAMD                             gpaSession) {
+    const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer);
+    if (NULL == disp) {
+        loader_log(NULL, VULKAN_LOADER_FATAL_ERROR_BIT | VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0,
+                   "vkCmdBeginGpaSessionAMD: Invalid commandBuffer "
+                   "[VUID-vkCmdBeginGpaSessionAMD-commandBuffer-parameter]");
+        abort(); /* Intentionally fail so user can correct issue. */
+    }
+    return disp->CmdBeginGpaSessionAMD(commandBuffer, gpaSession);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CmdEndGpaSessionAMD(
+    VkCommandBuffer                             commandBuffer,
+    VkGpaSessionAMD                             gpaSession) {
+    const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer);
+    if (NULL == disp) {
+        loader_log(NULL, VULKAN_LOADER_FATAL_ERROR_BIT | VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0,
+                   "vkCmdEndGpaSessionAMD: Invalid commandBuffer "
+                   "[VUID-vkCmdEndGpaSessionAMD-commandBuffer-parameter]");
+        abort(); /* Intentionally fail so user can correct issue. */
+    }
+    return disp->CmdEndGpaSessionAMD(commandBuffer, gpaSession);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL CmdBeginGpaSampleAMD(
+    VkCommandBuffer                             commandBuffer,
+    VkGpaSessionAMD                             gpaSession,
+    const VkGpaSampleBeginInfoAMD*              pGpaSampleBeginInfo,
+    uint32_t*                                   pSampleID) {
+    const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer);
+    if (NULL == disp) {
+        loader_log(NULL, VULKAN_LOADER_FATAL_ERROR_BIT | VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0,
+                   "vkCmdBeginGpaSampleAMD: Invalid commandBuffer "
+                   "[VUID-vkCmdBeginGpaSampleAMD-commandBuffer-parameter]");
+        abort(); /* Intentionally fail so user can correct issue. */
+    }
+    return disp->CmdBeginGpaSampleAMD(commandBuffer, gpaSession, pGpaSampleBeginInfo, pSampleID);
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdEndGpaSampleAMD(
+    VkCommandBuffer                             commandBuffer,
+    VkGpaSessionAMD                             gpaSession,
+    uint32_t                                    sampleID) {
+    const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer);
+    if (NULL == disp) {
+        loader_log(NULL, VULKAN_LOADER_FATAL_ERROR_BIT | VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0,
+                   "vkCmdEndGpaSampleAMD: Invalid commandBuffer "
+                   "[VUID-vkCmdEndGpaSampleAMD-commandBuffer-parameter]");
+        abort(); /* Intentionally fail so user can correct issue. */
+    }
+    disp->CmdEndGpaSampleAMD(commandBuffer, gpaSession, sampleID);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetGpaSessionStatusAMD(
+    VkDevice                                    device,
+    VkGpaSessionAMD                             gpaSession) {
+    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+    if (NULL == disp) {
+        loader_log(NULL, VULKAN_LOADER_FATAL_ERROR_BIT | VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0,
+                   "vkGetGpaSessionStatusAMD: Invalid device "
+                   "[VUID-vkGetGpaSessionStatusAMD-device-parameter]");
+        abort(); /* Intentionally fail so user can correct issue. */
+    }
+    return disp->GetGpaSessionStatusAMD(device, gpaSession);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetGpaSessionResultsAMD(
+    VkDevice                                    device,
+    VkGpaSessionAMD                             gpaSession,
+    uint32_t                                    sampleID,
+    size_t*                                     pSizeInBytes,
+    void*                                       pData) {
+    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+    if (NULL == disp) {
+        loader_log(NULL, VULKAN_LOADER_FATAL_ERROR_BIT | VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0,
+                   "vkGetGpaSessionResultsAMD: Invalid device "
+                   "[VUID-vkGetGpaSessionResultsAMD-device-parameter]");
+        abort(); /* Intentionally fail so user can correct issue. */
+    }
+    return disp->GetGpaSessionResultsAMD(device, gpaSession, sampleID, pSizeInBytes, pData);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL ResetGpaSessionAMD(
+    VkDevice                                    device,
+    VkGpaSessionAMD                             gpaSession) {
+    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
+    if (NULL == disp) {
+        loader_log(NULL, VULKAN_LOADER_FATAL_ERROR_BIT | VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0,
+                   "vkResetGpaSessionAMD: Invalid device "
+                   "[VUID-vkResetGpaSessionAMD-device-parameter]");
+        abort(); /* Intentionally fail so user can correct issue. */
+    }
+    return disp->ResetGpaSessionAMD(device, gpaSession);
+}
+
+VKAPI_ATTR void VKAPI_CALL CmdCopyGpaSessionResultsAMD(
+    VkCommandBuffer                             commandBuffer,
+    VkGpaSessionAMD                             gpaSession) {
+    const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer);
+    if (NULL == disp) {
+        loader_log(NULL, VULKAN_LOADER_FATAL_ERROR_BIT | VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0,
+                   "vkCmdCopyGpaSessionResultsAMD: Invalid commandBuffer "
+                   "[VUID-vkCmdCopyGpaSessionResultsAMD-commandBuffer-parameter]");
+        abort(); /* Intentionally fail so user can correct issue. */
+    }
+    disp->CmdCopyGpaSessionResultsAMD(commandBuffer, gpaSession);
+}
+
+
 // ---- VK_AMDX_shader_enqueue extension trampoline/terminators
 
 #if defined(VK_ENABLE_BETA_EXTENSIONS)
@@ -13526,6 +13722,56 @@ bool extension_instance_gpa(struct loader_instance *ptr_instance, const char *na
     }
 #endif // VK_USE_PLATFORM_ANDROID_KHR
 
+    // ---- VK_AMD_gpa_interface extension commands
+    if (!strcmp("vkCreateGpaSessionAMD", name)) {
+        *addr = (void *)CreateGpaSessionAMD;
+        return true;
+    }
+    if (!strcmp("vkDestroyGpaSessionAMD", name)) {
+        *addr = (void *)DestroyGpaSessionAMD;
+        return true;
+    }
+    if (!strcmp("vkSetGpaDeviceClockModeAMD", name)) {
+        *addr = (void *)SetGpaDeviceClockModeAMD;
+        return true;
+    }
+    if (!strcmp("vkGetGpaDeviceClockInfoAMD", name)) {
+        *addr = (void *)GetGpaDeviceClockInfoAMD;
+        return true;
+    }
+    if (!strcmp("vkCmdBeginGpaSessionAMD", name)) {
+        *addr = (void *)CmdBeginGpaSessionAMD;
+        return true;
+    }
+    if (!strcmp("vkCmdEndGpaSessionAMD", name)) {
+        *addr = (void *)CmdEndGpaSessionAMD;
+        return true;
+    }
+    if (!strcmp("vkCmdBeginGpaSampleAMD", name)) {
+        *addr = (void *)CmdBeginGpaSampleAMD;
+        return true;
+    }
+    if (!strcmp("vkCmdEndGpaSampleAMD", name)) {
+        *addr = (void *)CmdEndGpaSampleAMD;
+        return true;
+    }
+    if (!strcmp("vkGetGpaSessionStatusAMD", name)) {
+        *addr = (void *)GetGpaSessionStatusAMD;
+        return true;
+    }
+    if (!strcmp("vkGetGpaSessionResultsAMD", name)) {
+        *addr = (void *)GetGpaSessionResultsAMD;
+        return true;
+    }
+    if (!strcmp("vkResetGpaSessionAMD", name)) {
+        *addr = (void *)ResetGpaSessionAMD;
+        return true;
+    }
+    if (!strcmp("vkCmdCopyGpaSessionResultsAMD", name)) {
+        *addr = (void *)CmdCopyGpaSessionResultsAMD;
+        return true;
+    }
+
     // ---- VK_AMDX_shader_enqueue extension commands
 #if defined(VK_ENABLE_BETA_EXTENSIONS)
     if (!strcmp("vkCreateExecutionGraphPipelinesAMDX", name)) {
diff --git a/loader/generated/vk_object_types.h b/loader/generated/vk_object_types.h
@@ -80,24 +80,25 @@ typedef enum VulkanObjectType {
     kVulkanObjectTypeCuModuleNVX = 39,
     kVulkanObjectTypeCuFunctionNVX = 40,
     kVulkanObjectTypeDebugUtilsMessengerEXT = 41,
-    kVulkanObjectTypeTensorARM = 42,
-    kVulkanObjectTypeValidationCacheEXT = 43,
-    kVulkanObjectTypeAccelerationStructureNV = 44,
-    kVulkanObjectTypePerformanceConfigurationINTEL = 45,
-    kVulkanObjectTypeIndirectCommandsLayoutNV = 46,
-    kVulkanObjectTypeCudaModuleNV = 47,
-    kVulkanObjectTypeCudaFunctionNV = 48,
-    kVulkanObjectTypeBufferCollectionFUCHSIA = 49,
-    kVulkanObjectTypeMicromapEXT = 50,
-    kVulkanObjectTypeTensorViewARM = 51,
-    kVulkanObjectTypeOpticalFlowSessionNV = 52,
-    kVulkanObjectTypeShaderEXT = 53,
-    kVulkanObjectTypeDataGraphPipelineSessionARM = 54,
-    kVulkanObjectTypeExternalComputeQueueNV = 55,
-    kVulkanObjectTypeIndirectExecutionSetEXT = 56,
-    kVulkanObjectTypeIndirectCommandsLayoutEXT = 57,
-    kVulkanObjectTypeShaderInstrumentationARM = 58,
-    kVulkanObjectTypeMax = 59,
+    kVulkanObjectTypeGpaSessionAMD = 42,
+    kVulkanObjectTypeTensorARM = 43,
+    kVulkanObjectTypeValidationCacheEXT = 44,
+    kVulkanObjectTypeAccelerationStructureNV = 45,
+    kVulkanObjectTypePerformanceConfigurationINTEL = 46,
+    kVulkanObjectTypeIndirectCommandsLayoutNV = 47,
+    kVulkanObjectTypeCudaModuleNV = 48,
+    kVulkanObjectTypeCudaFunctionNV = 49,
+    kVulkanObjectTypeBufferCollectionFUCHSIA = 50,
+    kVulkanObjectTypeMicromapEXT = 51,
+    kVulkanObjectTypeTensorViewARM = 52,
+    kVulkanObjectTypeOpticalFlowSessionNV = 53,
+    kVulkanObjectTypeShaderEXT = 54,
+    kVulkanObjectTypeDataGraphPipelineSessionARM = 55,
+    kVulkanObjectTypeExternalComputeQueueNV = 56,
+    kVulkanObjectTypeIndirectExecutionSetEXT = 57,
+    kVulkanObjectTypeIndirectCommandsLayoutEXT = 58,
+    kVulkanObjectTypeShaderInstrumentationARM = 59,
+    kVulkanObjectTypeMax = 60,
     // Aliases for backwards compatibility of "promoted" types
     kVulkanObjectTypeDescriptorUpdateTemplateKHR = kVulkanObjectTypeDescriptorUpdateTemplate,
     kVulkanObjectTypeSamplerYcbcrConversionKHR = kVulkanObjectTypeSamplerYcbcrConversion,
@@ -148,6 +149,7 @@ static const char * const object_string[kVulkanObjectTypeMax] = {
     "CuModuleNVX",
     "CuFunctionNVX",
     "DebugUtilsMessengerEXT",
+    "GpaSessionAMD",
     "TensorARM",
     "ValidationCacheEXT",
     "AccelerationStructureNV",
@@ -211,6 +213,7 @@ const VkDebugReportObjectTypeEXT get_debug_report_enum[] = {
     VK_DEBUG_REPORT_OBJECT_TYPE_CU_MODULE_NVX_EXT,   // kVulkanObjectTypeCuModuleNVX
     VK_DEBUG_REPORT_OBJECT_TYPE_CU_FUNCTION_NVX_EXT,   // kVulkanObjectTypeCuFunctionNVX
     VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT,   // kVulkanObjectTypeDebugUtilsMessengerEXT
+    VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT,   // kVulkanObjectTypeGpaSessionAMD
     VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT,   // kVulkanObjectTypeTensorARM
     VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT,   // kVulkanObjectTypeValidationCacheEXT
     VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT,   // kVulkanObjectTypeAccelerationStructureNV
@@ -274,6 +277,7 @@ const VkObjectType get_object_type_enum[] = {
     VK_OBJECT_TYPE_CU_MODULE_NVX,   // kVulkanObjectTypeCuModuleNVX
     VK_OBJECT_TYPE_CU_FUNCTION_NVX,   // kVulkanObjectTypeCuFunctionNVX
     VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT,   // kVulkanObjectTypeDebugUtilsMessengerEXT
+    VK_OBJECT_TYPE_GPA_SESSION_AMD,   // kVulkanObjectTypeGpaSessionAMD
     VK_OBJECT_TYPE_TENSOR_ARM,   // kVulkanObjectTypeTensorARM
     VK_OBJECT_TYPE_VALIDATION_CACHE_EXT,   // kVulkanObjectTypeValidationCacheEXT
     VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV,   // kVulkanObjectTypeAccelerationStructureNV
diff --git a/loader/loader.rc b/loader/loader.rc
@@ -22,8 +22,8 @@
 #include "winres.h"
 
 // All set through CMake
-#define VER_FILE_VERSION 1, 4, 350, 0
-#define VER_FILE_DESCRIPTION_STR "1.4.350.Dev Build"
+#define VER_FILE_VERSION 1, 4, 351, 0
+#define VER_FILE_DESCRIPTION_STR "1.4.351.Dev Build"
 #define VER_FILE_VERSION_STR "Vulkan Loader - Dev Build"
 #define VER_COPYRIGHT_STR "Copyright (C) 2015-2026"
 
diff --git a/scripts/known_good.json b/scripts/known_good.json
@@ -7,7 +7,7 @@
             "sub_dir": "Vulkan-Headers",
             "build_dir": "Vulkan-Headers/build",
             "install_dir": "Vulkan-Headers/build/install",
-            "commit": "v1.4.350"
+            "commit": "v1.4.351"
         },
         {
             "name": "googletest",
diff --git a/tests/framework/layer/generated/vk_dispatch_table_helper.h b/tests/framework/layer/generated/vk_dispatch_table_helper.h

Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@`
`7`	`7`	`"sub_dir": "Vulkan-Headers",`
`8`	`8`	`"build_dir": "Vulkan-Headers/build",`
`9`	`9`	`"install_dir": "Vulkan-Headers/build/install",`
`10`		`- "commit": "v1.4.350"`
	`10`	`+ "commit": "v1.4.351"`
`11`	`11`	`},`
`12`	`12`	`{`
`13`	`13`	`"name": "googletest",`