loader: Convert GetInstanceProcAddr and GetDeviceProcAddr over to new semantics

As per Vulkan bug 13288. Still need to handle device extensions correctly.

diff --git a/loader/debug_report.c b/loader/debug_report.c
index 6ede98c..08ef8ca 100644 (file)
--- a/loader/debug_report.c
+++ b/loader/debug_report.c
@@ -323,9 +323,9 @@ bool debug_report_instance_gpa(
         const char* name,
         void **addr)
 {
+    // debug_report is currently advertised to be supported by the loader,
+    // so always return the entry points if name matches and it's enabled
     *addr = NULL;
-    if (ptr_instance == VK_NULL_HANDLE)
-        return false;
 
     if (!strcmp("vkDbgCreateMsgCallback", name)) {
         *addr = ptr_instance->debug_report_enabled ? (void *) debug_report_DbgCreateMsgCallback : NULL;

diff --git a/loader/gpa_helper.h b/loader/gpa_helper.h
index 779a566..5fb1232 100644 (file)
--- a/loader/gpa_helper.h
+++ b/loader/gpa_helper.h
@@ -26,8 +26,294 @@
  */
 
 #include <string.h>
+#include "debug_report.h"
 #include "wsi_swapchain.h"
 
+static inline void* trampolineGetProcAddr(struct loader_instance *inst,
+                                          const char *funcName)
+{
+    //Don't include or check global functions
+    if (!strcmp(funcName, "vkGetInstanceProcAddr"))
+        return (PFN_vkVoidFunction) vkGetInstanceProcAddr;
+    if (!strcmp(funcName, "vkDestroyInstance"))
+        return (PFN_vkVoidFunction) vkDestroyInstance;
+    if (!strcmp(funcName, "vkEnumeratePhysicalDevices"))
+        return (PFN_vkVoidFunction) vkEnumeratePhysicalDevices;
+    if (!strcmp(funcName, "vkGetPhysicalDeviceFeatures"))
+        return (PFN_vkVoidFunction) vkGetPhysicalDeviceFeatures;
+    if (!strcmp(funcName, "vkGetPhysicalDeviceFormatProperties"))
+        return (PFN_vkVoidFunction) vkGetPhysicalDeviceFormatProperties;
+    if (!strcmp(funcName, "vkGetPhysicalDeviceImageFormatProperties"))
+        return (PFN_vkVoidFunction) vkGetPhysicalDeviceImageFormatProperties;
+    if (!strcmp(funcName, "vkGetPhysicalDeviceSparseImageFormatProperties"))
+        return(PFN_vkVoidFunction) vkGetPhysicalDeviceSparseImageFormatProperties;
+    if (!strcmp(funcName, "vkGetPhysicalDeviceProperties"))
+        return (PFN_vkVoidFunction) vkGetPhysicalDeviceProperties;
+    if (!strcmp(funcName, "vkGetPhysicalDeviceQueueFamilyProperties"))
+        return (PFN_vkVoidFunction) vkGetPhysicalDeviceQueueFamilyProperties;
+    if (!strcmp(funcName, "vkGetPhysicalDeviceMemoryProperties"))
+        return (PFN_vkVoidFunction) vkGetPhysicalDeviceMemoryProperties;
+    if (!strcmp(funcName, "vkEnumerateDeviceLayerProperties"))
+        return (PFN_vkVoidFunction) vkEnumerateDeviceLayerProperties;
+    if (!strcmp(funcName, "vkEnumerateDeviceExtensionProperties"))
+        return (PFN_vkVoidFunction) vkEnumerateDeviceExtensionProperties;
+    if (!strcmp(funcName, "vkCreateDevice"))
+        return (PFN_vkVoidFunction) vkCreateDevice;
+    if (!strcmp(funcName, "vkGetDeviceProcAddr"))
+        return (PFN_vkVoidFunction) vkGetDeviceProcAddr;
+    if (!strcmp(funcName, "vkDestroyDevice"))
+        return (PFN_vkVoidFunction) vkDestroyDevice;
+    if (!strcmp(funcName, "vkGetDeviceQueue"))
+        return (PFN_vkVoidFunction) vkGetDeviceQueue;
+    if (!strcmp(funcName, "vkQueueSubmit"))
+        return (PFN_vkVoidFunction) vkQueueSubmit;
+    if (!strcmp(funcName, "vkQueueWaitIdle"))
+        return (PFN_vkVoidFunction) vkQueueWaitIdle;
+    if (!strcmp(funcName, "vkDeviceWaitIdle"))
+        return (PFN_vkVoidFunction) vkDeviceWaitIdle;
+    if (!strcmp(funcName, "vkAllocateMemory"))
+        return (PFN_vkVoidFunction) vkAllocateMemory;
+    if (!strcmp(funcName, "vkFreeMemory"))
+        return (PFN_vkVoidFunction) vkFreeMemory;
+    if (!strcmp(funcName, "vkMapMemory"))
+        return (PFN_vkVoidFunction) vkMapMemory;
+    if (!strcmp(funcName, "vkUnmapMemory"))
+        return (PFN_vkVoidFunction) vkUnmapMemory;
+    if (!strcmp(funcName, "vkFlushMappedMemoryRanges"))
+        return (PFN_vkVoidFunction) vkFlushMappedMemoryRanges;
+    if (!strcmp(funcName, "vkInvalidateMappedMemoryRanges"))
+        return (PFN_vkVoidFunction) vkInvalidateMappedMemoryRanges;
+    if (!strcmp(funcName, "vkGetDeviceMemoryCommitment"))
+        return (PFN_vkVoidFunction) vkGetDeviceMemoryCommitment;
+    if (!strcmp(funcName, "vkGetImageSparseMemoryRequirements"))
+        return (PFN_vkVoidFunction) vkGetImageSparseMemoryRequirements;
+    if (!strcmp(funcName, "vkGetImageMemoryRequirements"))
+        return (PFN_vkVoidFunction) vkGetImageMemoryRequirements;
+    if (!strcmp(funcName, "vkGetBufferMemoryRequirements"))
+        return (PFN_vkVoidFunction) vkGetBufferMemoryRequirements;
+    if (!strcmp(funcName, "vkBindImageMemory"))
+        return (PFN_vkVoidFunction) vkBindImageMemory;
+    if (!strcmp(funcName, "vkBindBufferMemory"))
+        return (PFN_vkVoidFunction) vkBindBufferMemory;
+    if (!strcmp(funcName, "vkQueueBindSparse"))
+        return (PFN_vkVoidFunction) vkQueueBindSparse;
+    if (!strcmp(funcName, "vkCreateFence"))
+        return (PFN_vkVoidFunction) vkCreateFence;
+    if (!strcmp(funcName, "vkDestroyFence"))
+        return (PFN_vkVoidFunction) vkDestroyFence;
+    if (!strcmp(funcName, "vkGetFenceStatus"))
+        return (PFN_vkVoidFunction) vkGetFenceStatus;
+    if (!strcmp(funcName, "vkResetFences"))
+        return (PFN_vkVoidFunction) vkResetFences;
+    if (!strcmp(funcName, "vkWaitForFences"))
+        return (PFN_vkVoidFunction) vkWaitForFences;
+    if (!strcmp(funcName, "vkCreateSemaphore"))
+        return (PFN_vkVoidFunction) vkCreateSemaphore;
+    if (!strcmp(funcName, "vkDestroySemaphore"))
+        return (PFN_vkVoidFunction) vkDestroySemaphore;
+    if (!strcmp(funcName, "vkCreateEvent"))
+        return (PFN_vkVoidFunction) vkCreateEvent;
+    if (!strcmp(funcName, "vkDestroyEvent"))
+        return (PFN_vkVoidFunction) vkDestroyEvent;
+    if (!strcmp(funcName, "vkGetEventStatus"))
+        return (PFN_vkVoidFunction) vkGetEventStatus;
+    if (!strcmp(funcName, "vkSetEvent"))
+        return (PFN_vkVoidFunction) vkSetEvent;
+    if (!strcmp(funcName, "vkResetEvent"))
+        return (PFN_vkVoidFunction) vkResetEvent;
+    if (!strcmp(funcName, "vkCreateQueryPool"))
+        return (PFN_vkVoidFunction) vkCreateQueryPool;
+    if (!strcmp(funcName, "vkDestroyQueryPool"))
+        return (PFN_vkVoidFunction) vkDestroyQueryPool;
+    if (!strcmp(funcName, "vkGetQueryPoolResults"))
+        return (PFN_vkVoidFunction) vkGetQueryPoolResults;
+    if (!strcmp(funcName, "vkCreateBuffer"))
+        return (PFN_vkVoidFunction) vkCreateBuffer;
+    if (!strcmp(funcName, "vkDestroyBuffer"))
+        return (PFN_vkVoidFunction) vkDestroyBuffer;
+    if (!strcmp(funcName, "vkCreateBufferView"))
+        return (PFN_vkVoidFunction) vkCreateBufferView;
+    if (!strcmp(funcName, "vkDestroyBufferView"))
+        return (PFN_vkVoidFunction) vkDestroyBufferView;
+    if (!strcmp(funcName, "vkCreateImage"))
+        return (PFN_vkVoidFunction) vkCreateImage;
+    if (!strcmp(funcName, "vkDestroyImage"))
+        return (PFN_vkVoidFunction) vkDestroyImage;
+    if (!strcmp(funcName, "vkGetImageSubresourceLayout"))
+        return (PFN_vkVoidFunction) vkGetImageSubresourceLayout;
+    if (!strcmp(funcName, "vkCreateImageView"))
+        return (PFN_vkVoidFunction) vkCreateImageView;
+    if (!strcmp(funcName, "vkDestroyImageView"))
+        return (PFN_vkVoidFunction) vkDestroyImageView;
+    if (!strcmp(funcName, "vkCreateShaderModule"))
+        return (PFN_vkVoidFunction) vkCreateShaderModule;
+    if (!strcmp(funcName, "vkDestroyShaderModule"))
+        return (PFN_vkVoidFunction) vkDestroyShaderModule;
+    if (!strcmp(funcName, "vkCreatePipelineCache"))
+        return (PFN_vkVoidFunction) vkCreatePipelineCache;
+    if (!strcmp(funcName, "vkDestroyPipelineCache"))
+        return (PFN_vkVoidFunction) vkDestroyPipelineCache;
+    if (!strcmp(funcName, "vkGetPipelineCacheData"))
+        return (PFN_vkVoidFunction) vkGetPipelineCacheData;
+    if (!strcmp(funcName, "vkMergePipelineCaches"))
+        return (PFN_vkVoidFunction) vkMergePipelineCaches;
+    if (!strcmp(funcName, "vkCreateGraphicsPipelines"))
+        return (PFN_vkVoidFunction) vkCreateGraphicsPipelines;
+    if (!strcmp(funcName, "vkCreateComputePipelines"))
+        return (PFN_vkVoidFunction) vkCreateComputePipelines;
+    if (!strcmp(funcName, "vkDestroyPipeline"))
+        return (PFN_vkVoidFunction) vkDestroyPipeline;
+    if (!strcmp(funcName, "vkCreatePipelineLayout"))
+        return (PFN_vkVoidFunction) vkCreatePipelineLayout;
+    if (!strcmp(funcName, "vkDestroyPipelineLayout"))
+        return (PFN_vkVoidFunction) vkDestroyPipelineLayout;
+    if (!strcmp(funcName, "vkCreateSampler"))
+        return (PFN_vkVoidFunction) vkCreateSampler;
+    if (!strcmp(funcName, "vkDestroySampler"))
+        return (PFN_vkVoidFunction) vkDestroySampler;
+    if (!strcmp(funcName, "vkCreateDescriptorSetLayout"))
+        return (PFN_vkVoidFunction) vkCreateDescriptorSetLayout;
+    if (!strcmp(funcName, "vkDestroyDescriptorSetLayout"))
+        return (PFN_vkVoidFunction) vkDestroyDescriptorSetLayout;
+    if (!strcmp(funcName, "vkCreateDescriptorPool"))
+        return (PFN_vkVoidFunction) vkCreateDescriptorPool;
+    if (!strcmp(funcName, "vkDestroyDescriptorPool"))
+        return (PFN_vkVoidFunction) vkDestroyDescriptorPool;
+    if (!strcmp(funcName, "vkResetDescriptorPool"))
+        return (PFN_vkVoidFunction) vkResetDescriptorPool;
+    if (!strcmp(funcName, "vkAllocateDescriptorSets"))
+        return (PFN_vkVoidFunction) vkAllocateDescriptorSets;
+    if (!strcmp(funcName, "vkFreeDescriptorSets"))
+        return (PFN_vkVoidFunction) vkFreeDescriptorSets;
+    if (!strcmp(funcName, "vkUpdateDescriptorSets"))
+        return (PFN_vkVoidFunction) vkUpdateDescriptorSets;
+    if (!strcmp(funcName, "vkCreateFramebuffer"))
+        return (PFN_vkVoidFunction) vkCreateFramebuffer;
+    if (!strcmp(funcName, "vkDestroyFramebuffer"))
+        return (PFN_vkVoidFunction) vkDestroyFramebuffer;
+    if (!strcmp(funcName, "vkCreateRenderPass"))
+        return (PFN_vkVoidFunction) vkCreateRenderPass;
+    if (!strcmp(funcName, "vkDestroyRenderPass"))
+        return (PFN_vkVoidFunction) vkDestroyRenderPass;
+    if (!strcmp(funcName, "vkGetRenderAreaGranularity"))
+        return (PFN_vkVoidFunction) vkGetRenderAreaGranularity;
+    if (!strcmp(funcName, "vkCreateCommandPool"))
+        return (PFN_vkVoidFunction) vkCreateCommandPool;
+    if (!strcmp(funcName, "vkDestroyCommandPool"))
+        return (PFN_vkVoidFunction) vkDestroyCommandPool;
+    if (!strcmp(funcName, "vkResetCommandPool"))
+        return (PFN_vkVoidFunction) vkResetCommandPool;
+    if (!strcmp(funcName, "vkAllocateCommandBuffers"))
+        return (PFN_vkVoidFunction) vkAllocateCommandBuffers;
+    if (!strcmp(funcName, "vkFreeCommandBuffers"))
+        return (PFN_vkVoidFunction) vkFreeCommandBuffers;
+    if (!strcmp(funcName, "vkBeginCommandBuffer"))
+        return (PFN_vkVoidFunction) vkBeginCommandBuffer;
+    if (!strcmp(funcName, "vkEndCommandBuffer"))
+        return (PFN_vkVoidFunction) vkEndCommandBuffer;
+    if (!strcmp(funcName, "vkResetCommandBuffer"))
+        return (PFN_vkVoidFunction) vkResetCommandBuffer;
+    if (!strcmp(funcName, "vkCmdBindPipeline"))
+        return (PFN_vkVoidFunction) vkCmdBindPipeline;
+    if (!strcmp(funcName, "vkCmdBindDescriptorSets"))
+        return (PFN_vkVoidFunction) vkCmdBindDescriptorSets;
+    if (!strcmp(funcName, "vkCmdBindVertexBuffers"))
+        return (PFN_vkVoidFunction) vkCmdBindVertexBuffers;
+    if (!strcmp(funcName, "vkCmdBindIndexBuffer"))
+        return (PFN_vkVoidFunction) vkCmdBindIndexBuffer;
+    if (!strcmp(funcName, "vkCmdSetViewport"))
+        return (PFN_vkVoidFunction) vkCmdSetViewport;
+    if (!strcmp(funcName, "vkCmdSetScissor"))
+        return (PFN_vkVoidFunction) vkCmdSetScissor;
+    if (!strcmp(funcName, "vkCmdSetLineWidth"))
+        return (PFN_vkVoidFunction) vkCmdSetLineWidth;
+    if (!strcmp(funcName, "vkCmdSetDepthBias"))
+        return (PFN_vkVoidFunction) vkCmdSetDepthBias;
+    if (!strcmp(funcName, "vkCmdSetBlendConstants"))
+        return (PFN_vkVoidFunction) vkCmdSetBlendConstants;
+    if (!strcmp(funcName, "vkCmdSetDepthBounds"))
+        return (PFN_vkVoidFunction) vkCmdSetDepthBounds;
+    if (!strcmp(funcName, "vkCmdSetStencilCompareMask"))
+        return (PFN_vkVoidFunction) vkCmdSetStencilCompareMask;
+    if (!strcmp(funcName, "vkCmdSetStencilWriteMask"))
+        return (PFN_vkVoidFunction) vkCmdSetStencilWriteMask;
+    if (!strcmp(funcName, "vkCmdSetStencilReference"))
+        return (PFN_vkVoidFunction) vkCmdSetStencilReference;
+    if (!strcmp(funcName, "vkCmdDraw"))
+        return (PFN_vkVoidFunction) vkCmdDraw;
+    if (!strcmp(funcName, "vkCmdDrawIndexed"))
+        return (PFN_vkVoidFunction) vkCmdDrawIndexed;
+    if (!strcmp(funcName, "vkCmdDrawIndirect"))
+        return (PFN_vkVoidFunction) vkCmdDrawIndirect;
+    if (!strcmp(funcName, "vkCmdDrawIndexedIndirect"))
+        return (PFN_vkVoidFunction) vkCmdDrawIndexedIndirect;
+    if (!strcmp(funcName, "vkCmdDispatch"))
+        return (PFN_vkVoidFunction) vkCmdDispatch;
+    if (!strcmp(funcName, "vkCmdDispatchIndirect"))
+        return (PFN_vkVoidFunction) vkCmdDispatchIndirect;
+    if (!strcmp(funcName, "vkCmdCopyBuffer"))
+        return (PFN_vkVoidFunction) vkCmdCopyBuffer;
+    if (!strcmp(funcName, "vkCmdCopyImage"))
+        return (PFN_vkVoidFunction) vkCmdCopyImage;
+    if (!strcmp(funcName, "vkCmdBlitImage"))
+        return (PFN_vkVoidFunction) vkCmdBlitImage;
+    if (!strcmp(funcName, "vkCmdCopyBufferToImage"))
+        return (PFN_vkVoidFunction) vkCmdCopyBufferToImage;
+    if (!strcmp(funcName, "vkCmdCopyImageToBuffer"))
+        return (PFN_vkVoidFunction) vkCmdCopyImageToBuffer;
+    if (!strcmp(funcName, "vkCmdUpdateBuffer"))
+        return (PFN_vkVoidFunction) vkCmdUpdateBuffer;
+    if (!strcmp(funcName, "vkCmdFillBuffer"))
+        return (PFN_vkVoidFunction) vkCmdFillBuffer;
+    if (!strcmp(funcName, "vkCmdClearColorImage"))
+        return (PFN_vkVoidFunction) vkCmdClearColorImage;
+    if (!strcmp(funcName, "vkCmdClearDepthStencilImage"))
+        return (PFN_vkVoidFunction) vkCmdClearDepthStencilImage;
+    if (!strcmp(funcName, "vkCmdClearAttachments"))
+        return (PFN_vkVoidFunction) vkCmdClearAttachments;
+    if (!strcmp(funcName, "vkCmdResolveImage"))
+        return (PFN_vkVoidFunction) vkCmdResolveImage;
+    if (!strcmp(funcName, "vkCmdSetEvent"))
+        return (PFN_vkVoidFunction) vkCmdSetEvent;
+    if (!strcmp(funcName, "vkCmdResetEvent"))
+        return (PFN_vkVoidFunction) vkCmdResetEvent;
+    if (!strcmp(funcName, "vkCmdWaitEvents"))
+        return (PFN_vkVoidFunction) vkCmdWaitEvents;
+    if (!strcmp(funcName, "vkCmdPipelineBarrier"))
+        return (PFN_vkVoidFunction) vkCmdPipelineBarrier;
+    if (!strcmp(funcName, "vkCmdBeginQuery"))
+        return (PFN_vkVoidFunction) vkCmdBeginQuery;
+    if (!strcmp(funcName, "vkCmdEndQuery"))
+        return (PFN_vkVoidFunction) vkCmdEndQuery;
+    if (!strcmp(funcName, "vkCmdResetQueryPool"))
+        return (PFN_vkVoidFunction) vkCmdResetQueryPool;
+    if (!strcmp(funcName, "vkCmdWriteTimestamp"))
+        return (PFN_vkVoidFunction) vkCmdWriteTimestamp;
+    if (!strcmp(funcName, "vkCmdCopyQueryPoolResults"))
+        return (PFN_vkVoidFunction) vkCmdCopyQueryPoolResults;
+    if (!strcmp(funcName, "vkCmdPushConstants"))
+        return (PFN_vkVoidFunction) vkCmdPushConstants;
+    if (!strcmp(funcName, "vkCmdBeginRenderPass"))
+        return (PFN_vkVoidFunction) vkCmdBeginRenderPass;
+    if (!strcmp(funcName, "vkCmdNextSubpass"))
+        return (PFN_vkVoidFunction) vkCmdNextSubpass;
+    if (!strcmp(funcName, "vkCmdEndRenderPass"))
+        return (PFN_vkVoidFunction) vkCmdEndRenderPass;
+    if (!strcmp(funcName, "vkCmdExecuteCommands"))
+        return (PFN_vkVoidFunction) vkCmdExecuteCommands;
+
+    // Instance extensions
+    void *addr;
+    if (debug_report_instance_gpa(inst, funcName, &addr))
+        return addr;
+
+    if (wsi_swapchain_instance_gpa(inst, funcName, &addr))
+        return addr;
+
+    //TODO device extensions
+    return NULL;
+}
+
 static inline void* globalGetProcAddr(const char *name)
 {
     if (!name || name[0] != 'v' || name[1] != 'k')
@@ -36,276 +322,11 @@ static inline void* globalGetProcAddr(const char *name)
     name += 2;
     if (!strcmp(name, "CreateInstance"))
         return (void*) vkCreateInstance;
-    if (!strcmp(name, "DestroyInstance"))
-        return (void*) vkDestroyInstance;
-    if (!strcmp(name, "EnumeratePhysicalDevices"))
-        return (void*) vkEnumeratePhysicalDevices;
-    if (!strcmp(name, "GetPhysicalDeviceFeatures"))
-        return (void*) vkGetPhysicalDeviceFeatures;
-    if (!strcmp(name, "GetPhysicalDeviceFormatProperties"))
-        return (void*) vkGetPhysicalDeviceFormatProperties;
-    if (!strcmp(name, "GetPhysicalDeviceImageFormatProperties"))
-        return (void*) vkGetPhysicalDeviceImageFormatProperties;
-    if (!strcmp(name, "GetPhysicalDeviceProperties"))
-        return (void*) vkGetPhysicalDeviceProperties;
-    if (!strcmp(name, "GetPhysicalDeviceQueueFamilyProperties"))
-        return (void*) vkGetPhysicalDeviceQueueFamilyProperties;
-    if (!strcmp(name, "GetPhysicalDeviceMemoryProperties"))
-        return (void*) vkGetPhysicalDeviceMemoryProperties;
-    if (!strcmp(name, "GetInstanceProcAddr"))
-        return (void*) vkGetInstanceProcAddr;
-    if (!strcmp(name, "GetDeviceProcAddr"))
-        return (void*) vkGetDeviceProcAddr;
-    if (!strcmp(name, "CreateDevice"))
-        return (void*) vkCreateDevice;
-    if (!strcmp(name, "DestroyDevice"))
-        return (void*) vkDestroyDevice;
     if (!strcmp(name, "EnumerateInstanceExtensionProperties"))
         return (void*) vkEnumerateInstanceExtensionProperties;
-    if (!strcmp(name, "EnumerateDeviceExtensionProperties"))
-        return (void*) vkEnumerateDeviceExtensionProperties;
     if (!strcmp(name, "EnumerateInstanceLayerProperties"))
         return (void*) vkEnumerateInstanceLayerProperties;
-    if (!strcmp(name, "EnumerateDeviceLayerProperties"))
-        return (void*) vkEnumerateDeviceLayerProperties;
-    if (!strcmp(name, "GetDeviceQueue"))
-        return (void*) vkGetDeviceQueue;
-    if (!strcmp(name, "QueueSubmit"))
-        return (void*) vkQueueSubmit;
-    if (!strcmp(name, "QueueWaitIdle"))
-        return (void*) vkQueueWaitIdle;
-    if (!strcmp(name, "DeviceWaitIdle"))
-        return (void*) vkDeviceWaitIdle;
-    if (!strcmp(name, "AllocateMemory"))
-        return (void*) vkAllocateMemory;
-    if (!strcmp(name, "FreeMemory"))
-        return (void*) vkFreeMemory;
-    if (!strcmp(name, "MapMemory"))
-        return (void*) vkMapMemory;
-    if (!strcmp(name, "UnmapMemory"))
-        return (void*) vkUnmapMemory;
-    if (!strcmp(name, "FlushMappedMemoryRanges"))
-        return (void*) vkFlushMappedMemoryRanges;
-    if (!strcmp(name, "InvalidateMappedMemoryRanges"))
-        return (void*) vkInvalidateMappedMemoryRanges;
-    if (!strcmp(name, "GetDeviceMemoryCommitment"))
-        return (void *) vkGetDeviceMemoryCommitment;
-    if (!strcmp(name, "BindBufferMemory"))
-        return (void*) vkBindBufferMemory;
-    if (!strcmp(name, "BindImageMemory"))
-        return (void*) vkBindImageMemory;
-    if (!strcmp(name, "GetBufferMemoryRequirements"))
-        return (void*) vkGetBufferMemoryRequirements;
-    if (!strcmp(name, "GetImageMemoryRequirements"))
-        return (void*) vkGetImageMemoryRequirements;
-    if (!strcmp(name, "GetImageSparseMemoryRequirements"))
-        return (void*) vkGetImageSparseMemoryRequirements;
-    if (!strcmp(name, "GetPhysicalDeviceSparseImageFormatProperties"))
-        return (void*) vkGetPhysicalDeviceSparseImageFormatProperties;
-    if (!strcmp(name, "QueueBindSparse"))
-        return (void*) vkQueueBindSparse;
-    if (!strcmp(name, "CreateFence"))
-        return (void*) vkCreateFence;
-    if (!strcmp(name, "DestroyFence"))
-        return (void*) vkDestroyFence;
-    if (!strcmp(name, "ResetFences"))
-        return (void*) vkResetFences;
-    if (!strcmp(name, "GetFenceStatus"))
-        return (void*) vkGetFenceStatus;
-    if (!strcmp(name, "WaitForFences"))
-        return (void*) vkWaitForFences;
-    if (!strcmp(name, "CreateSemaphore"))
-        return (void*) vkCreateSemaphore;
-    if (!strcmp(name, "DestroySemaphore"))
-        return (void*) vkDestroySemaphore;
-    if (!strcmp(name, "CreateEvent"))
-        return (void*) vkCreateEvent;
-    if (!strcmp(name, "DestroyEvent"))
-        return (void*) vkDestroyEvent;
-    if (!strcmp(name, "GetEventStatus"))
-        return (void*) vkGetEventStatus;
-    if (!strcmp(name, "SetEvent"))
-        return (void*) vkSetEvent;
-    if (!strcmp(name, "ResetEvent"))
-        return (void*) vkResetEvent;
-    if (!strcmp(name, "CreateQueryPool"))
-        return (void*) vkCreateQueryPool;
-    if (!strcmp(name, "DestroyQueryPool"))
-        return (void*) vkDestroyQueryPool;
-    if (!strcmp(name, "GetQueryPoolResults"))
-        return (void*) vkGetQueryPoolResults;
-    if (!strcmp(name, "CreateBuffer"))
-        return (void*) vkCreateBuffer;
-    if (!strcmp(name, "DestroyBuffer"))
-        return (void*) vkDestroyBuffer;
-    if (!strcmp(name, "CreateBufferView"))
-        return (void*) vkCreateBufferView;
-    if (!strcmp(name, "DestroyBufferView"))
-        return (void*) vkDestroyBufferView;
-    if (!strcmp(name, "CreateImage"))
-        return (void*) vkCreateImage;
-    if (!strcmp(name, "DestroyImage"))
-        return (void*) vkDestroyImage;
-    if (!strcmp(name, "GetImageSubresourceLayout"))
-        return (void*) vkGetImageSubresourceLayout;
-    if (!strcmp(name, "CreateImageView"))
-        return (void*) vkCreateImageView;
-    if (!strcmp(name, "DestroyImageView"))
-        return (void*) vkDestroyImageView;
-    if (!strcmp(name, "CreateShaderModule"))
-        return (void*) vkCreateShaderModule;
-    if (!strcmp(name, "DestroyShaderModule"))
-        return (void*) vkDestroyShaderModule;
-    if (!strcmp(name, "CreatePipelineCache"))
-        return (void*) vkCreatePipelineCache;
-    if (!strcmp(name, "DestroyPipelineCache"))
-        return (void*) vkDestroyPipelineCache;
-    if (!strcmp(name, "GetPipelineCacheData"))
-        return (void*) vkGetPipelineCacheData;
-    if (!strcmp(name, "MergePipelineCaches"))
-        return (void*) vkMergePipelineCaches;
-    if (!strcmp(name, "CreateGraphicsPipelines"))
-        return (void*) vkCreateGraphicsPipelines;
-    if (!strcmp(name, "CreateComputePipelines"))
-        return (void*) vkCreateComputePipelines;
-    if (!strcmp(name, "DestroyPipeline"))
-        return (void*) vkDestroyPipeline;
-    if (!strcmp(name, "CreatePipelineLayout"))
-        return (void*) vkCreatePipelineLayout;
-    if (!strcmp(name, "DestroyPipelineLayout"))
-        return (void*) vkDestroyPipelineLayout;
-    if (!strcmp(name, "CreateSampler"))
-        return (void*) vkCreateSampler;
-    if (!strcmp(name, "DestroySampler"))
-        return (void*) vkDestroySampler;
-    if (!strcmp(name, "CreateDescriptorSetLayout"))
-        return (void*) vkCreateDescriptorSetLayout;
-    if (!strcmp(name, "DestroyDescriptorSetLayout"))
-        return (void*) vkDestroyDescriptorSetLayout;
-    if (!strcmp(name, "CreateDescriptorPool"))
-        return (void*) vkCreateDescriptorPool;
-    if (!strcmp(name, "DestroyDescriptorPool"))
-        return (void*) vkDestroyDescriptorPool;
-    if (!strcmp(name, "ResetDescriptorPool"))
-        return (void*) vkResetDescriptorPool;
-    if (!strcmp(name, "AllocateDescriptorSets"))
-        return (void*) vkAllocateDescriptorSets;
-    if (!strcmp(name, "FreeDescriptorSets"))
-        return (void*) vkFreeDescriptorSets;
-    if (!strcmp(name, "UpdateDescriptorSets"))
-        return (void*) vkUpdateDescriptorSets;
-    if (!strcmp(name, "CreateFramebuffer"))
-        return (void*) vkCreateFramebuffer;
-    if (!strcmp(name, "DestroyFramebuffer"))
-        return (void*) vkDestroyFramebuffer;
-    if (!strcmp(name, "CreateRenderPass"))
-        return (void*) vkCreateRenderPass;
-    if (!strcmp(name, "DestroyRenderPass"))
-        return (void*) vkDestroyRenderPass;
-    if (!strcmp(name, "GetRenderAreaGranularity"))
-        return (void*) vkGetRenderAreaGranularity;
-    if (!strcmp(name, "CreateCommandPool"))
-        return (void*) vkCreateCommandPool;
-    if (!strcmp(name, "DestroyCommandPool"))
-        return (void*) vkDestroyCommandPool;
-    if (!strcmp(name, "ResetCommandPool"))
-        return (void*) vkResetCommandPool;
-    if (!strcmp(name, "AllocateCommandBuffers"))
-        return (void*) vkAllocateCommandBuffers;
-    if (!strcmp(name, "FreeCommandBuffers"))
-        return (void*) vkFreeCommandBuffers;
-    if (!strcmp(name, "BeginCommandBuffer"))
-        return (void*) vkBeginCommandBuffer;
-    if (!strcmp(name, "EndCommandBuffer"))
-        return (void*) vkEndCommandBuffer;
-    if (!strcmp(name, "ResetCommandBuffer"))
-        return (void*) vkResetCommandBuffer;
-    if (!strcmp(name, "CmdBindPipeline"))
-        return (void*) vkCmdBindPipeline;
-    if (!strcmp(name, "CmdSetViewport"))
-        return (void*) vkCmdSetViewport;
-    if (!strcmp(name, "CmdSetScissor"))
-        return (void*) vkCmdSetScissor;
-    if (!strcmp(name, "CmdSetLineWidth"))
-        return (void*) vkCmdSetLineWidth;
-    if (!strcmp(name, "CmdSetDepthBias"))
-        return (void*) vkCmdSetDepthBias;
-    if (!strcmp(name, "CmdSetBlendConstants"))
-        return (void*) vkCmdSetBlendConstants;
-    if (!strcmp(name, "CmdSetDepthBounds"))
-        return (void*) vkCmdSetDepthBounds;
-    if (!strcmp(name, "CmdSetStencilCompareMask"))
-        return (void*) vkCmdSetStencilCompareMask;
-    if (!strcmp(name, "CmdSetStencilWriteMask"))
-        return (void*) vkCmdSetStencilWriteMask;
-    if (!strcmp(name, "CmdSetStencilReference"))
-        return (void*) vkCmdSetStencilReference;
-    if (!strcmp(name, "CmdBindIndexBuffer"))
-        return (void*) vkCmdBindIndexBuffer;
-    if (!strcmp(name, "CmdBindVertexBuffers"))
-        return (void*) vkCmdBindVertexBuffers;
-    if (!strcmp(name, "CmdDraw"))
-        return (void*) vkCmdDraw;
-    if (!strcmp(name, "CmdDrawIndexed"))
-        return (void*) vkCmdDrawIndexed;
-    if (!strcmp(name, "CmdDrawIndirect"))
-        return (void*) vkCmdDrawIndirect;
-    if (!strcmp(name, "CmdDrawIndexedIndirect"))
-        return (void*) vkCmdDrawIndexedIndirect;
-    if (!strcmp(name, "CmdDispatch"))
-        return (void*) vkCmdDispatch;
-    if (!strcmp(name, "CmdDispatchIndirect"))
-        return (void*) vkCmdDispatchIndirect;
-    if (!strcmp(name, "CmdCopyBuffer"))
-        return (void*) vkCmdCopyBuffer;
-    if (!strcmp(name, "CmdCopyImage"))
-        return (void*) vkCmdCopyImage;
-    if (!strcmp(name, "CmdBlitImage"))
-        return (void*) vkCmdBlitImage;
-    if (!strcmp(name, "CmdCopyBufferToImage"))
-        return (void*) vkCmdCopyBufferToImage;
-    if (!strcmp(name, "CmdCopyImageToBuffer"))
-        return (void*) vkCmdCopyImageToBuffer;
-    if (!strcmp(name, "CmdUpdateBuffer"))
-        return (void*) vkCmdUpdateBuffer;
-    if (!strcmp(name, "CmdFillBuffer"))
-        return (void*) vkCmdFillBuffer;
-    if (!strcmp(name, "CmdClearColorImage"))
-        return (void*) vkCmdClearColorImage;
-    if (!strcmp(name, "CmdClearDepthStencilImage"))
-        return (void*) vkCmdClearDepthStencilImage;
-    if (!strcmp(name, "CmdClearAttachments"))
-        return (void*) vkCmdClearAttachments;
-    if (!strcmp(name, "CmdResolveImage"))
-        return (void*) vkCmdResolveImage;
-    if (!strcmp(name, "CmdSetEvent"))
-        return (void*) vkCmdSetEvent;
-    if (!strcmp(name, "CmdResetEvent"))
-        return (void*) vkCmdResetEvent;
-    if (!strcmp(name, "CmdWaitEvents"))
-        return (void*) vkCmdWaitEvents;
-    if (!strcmp(name, "CmdPipelineBarrier"))
-        return (void*) vkCmdPipelineBarrier;
-    if (!strcmp(name, "CmdBeginQuery"))
-        return (void*) vkCmdBeginQuery;
-    if (!strcmp(name, "CmdEndQuery"))
-        return (void*) vkCmdEndQuery;
-    if (!strcmp(name, "CmdResetQueryPool"))
-        return (void*) vkCmdResetQueryPool;
-    if (!strcmp(name, "CmdWriteTimestamp"))
-        return (void*) vkCmdWriteTimestamp;
-    if (!strcmp(name, "CmdCopyQueryPoolResults"))
-        return (void*) vkCmdCopyQueryPoolResults;
-    if (!strcmp(name, "CmdPushConstants"))
-        return (void*) vkCmdPushConstants;
-    if (!strcmp(name, "CmdBeginRenderPass"))
-        return (void*) vkCmdBeginRenderPass;
-    if (!strcmp(name, "CmdNextSubpass"))
-        return (void*) vkCmdNextSubpass;
-    if (!strcmp(name, "CmdEndRenderPass"))
-        return (void*) vkCmdEndRenderPass;
-    if (!strcmp(name, "CmdExecuteCommands"))
-        return (void*) vkCmdExecuteCommands;
+
     return NULL;
 }
 
@@ -349,8 +370,6 @@ static inline void *loader_non_passthrough_gdpa(const char *name)
 
     if (!strcmp(name, "GetDeviceProcAddr"))
         return (void*) vkGetDeviceProcAddr;
-    if (!strcmp(name, "CreateDevice"))
-        return (void*) vkCreateDevice;
     if (!strcmp(name, "DestroyDevice"))
         return (void*) vkDestroyDevice;
     if (!strcmp(name, "GetDeviceQueue"))

diff --git a/loader/loader.c b/loader/loader.c
index 5cef300..d892647 100644 (file)
--- a/loader/loader.c
+++ b/loader/loader.c
@@ -44,6 +44,7 @@
 #include "gpa_helper.h"
 #include "table_ops.h"
 #include "debug_report.h"
+#include "wsi_swapchain.h"
 #include "vk_icd.h"
 #include "cJSON.h"
 
@@ -3075,52 +3076,35 @@ VkResult VKAPI loader_CreateDevice(
  * @param instance
  * @param pName
  * @return
- *    If instance == NULL returns a global level entrypoint for all core entry points
- *    If instance is valid returns a instance relative entry point for instance level
- *    entry points both core and extensions.
- *    Instance relative means call down the instance chain. Global means trampoline entry points.
+ *    If instance == NULL returns a global level functions only
+ *    If instance is valid returns a trampoline entry point for all dispatchable Vulkan
+ *    functions both core and extensions.
  */
 LOADER_EXPORT PFN_vkVoidFunction VKAPI vkGetInstanceProcAddr(VkInstance instance, const char * pName)
 {
 
     void *addr;
 
+    addr = globalGetProcAddr(pName);
     if (instance == VK_NULL_HANDLE) {
-        /* get entrypoint addresses that are global (in the loader),
-           doesn't include any instance extensions since they may not be enabled yet*/
-
-        addr = globalGetProcAddr(pName);
-
-        return addr;
-    }
-
+        // get entrypoint addresses that are global (no dispatchable object)
 
-    /* return any instance entrypoints that must resolve to loader code */
-    addr = loader_non_passthrough_gipa(pName);
-    if (addr) {
         return addr;
+    } else {
+        // if a global entrypoint return NULL
+        if (addr)
+            return NULL;
     }
 
-    /* debug_report is a special case; need to return loader trampoline entrypoints
-     * unless the extension is not enabled; also need to handle debug_report
-     * utility functions */
     struct loader_instance *ptr_instance = loader_get_instance(instance);
-    if (debug_report_instance_gpa(ptr_instance, pName, &addr)) {
-        return addr;
-    }
-
-    /* return the instance dispatch table entrypoint for core and extensions */
-    const VkLayerInstanceDispatchTable *disp_table = * (VkLayerInstanceDispatchTable **) instance;
-    if (disp_table == NULL)
+    if (ptr_instance == NULL)
         return NULL;
+    // Return trampoline code for non-global entrypoints including any extensions.
+    // Device extensions are returned if a layer or ICD supports the extension.
+    // Instance extensions are returned if the extension is enabled and the loader
+    // or someone else supports the extension
+    return trampolineGetProcAddr(ptr_instance, pName);
 
-    addr = loader_lookup_instance_dispatch_table(disp_table, pName);
-    if (addr)
-        return addr;
-
-    // NOTE: any instance extensions must be known to loader and resolved
-    // in the above call to loader_lookup_instance_dispatch_table())
-    return NULL;
 }
 
 /**
@@ -3128,22 +3112,14 @@ LOADER_EXPORT PFN_vkVoidFunction VKAPI vkGetInstanceProcAddr(VkInstance instance
  * @param device
  * @param pName
  * @return
- *    If device == NULL, returns a global level entrypoint for all core entry points
  *    If device is valid, returns a device relative entry point for device level
  *    entry points both core and extensions.
- *    Device relative means call down the device chain. Global means trampoline entry points.
+ *    Device relative means call down the device chain.
  */
 LOADER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(VkDevice device, const char * pName)
 {
     void *addr;
 
-    if (device == VK_NULL_HANDLE) {
-        /* get entrypoint addresses that are global (in the loader)*/
-        addr = globalGetProcAddr(pName);
-        return addr;
-    }
-
-
     /* for entrypoints that loader must handle (ie non-dispatchable or create object)
        make sure the loader entrypoint is returned */
     addr = loader_non_passthrough_gdpa(pName);
@@ -3151,6 +3127,12 @@ LOADER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(VkDevice device, cons
         return addr;
     }
 
+    /* Although CreateDevice is on device chain it's dispatchable object isn't
+     * a VkDevice or child of VkDevice so return NULL.
+     */
+    if (!strcmp(pName, "CreateDevice"))
+        return NULL;
+
     /* return the dispatch table entrypoint for the fastest case */
     const VkLayerDispatchTable *disp_table = * (VkLayerDispatchTable **) device;
     if (disp_table == NULL)
@@ -3159,11 +3141,10 @@ LOADER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(VkDevice device, cons
     addr = loader_lookup_device_dispatch_table(disp_table, pName);
     if (addr)
         return addr;
-    else  {
-        if (disp_table->GetDeviceProcAddr == NULL)
-            return NULL;
-        return disp_table->GetDeviceProcAddr(device, pName);
-    }
+
+    if (disp_table->GetDeviceProcAddr == NULL)
+        return NULL;
+    return disp_table->GetDeviceProcAddr(device, pName);
 }
 
 LOADER_EXPORT VkResult VKAPI vkEnumerateInstanceExtensionProperties(

diff --git a/loader/loader.h b/loader/loader.h
index f27b892..41deacf 100644 (file)
--- a/loader/loader.h
+++ b/loader/loader.h
@@ -33,6 +33,7 @@
 #define LOADER_H
 
 #include <vulkan.h>
+#include <vk_loader_platform.h>
 #include <vk_debug_report_lunarg.h>
 #include <vk_ext_khr_swapchain.h>
 #include <vk_layer.h>

diff --git a/loader/wsi_swapchain.c b/loader/wsi_swapchain.c
index cea306e..97193b2 100644 (file)
--- a/loader/wsi_swapchain.c
+++ b/loader/wsi_swapchain.c
@@ -105,5 +105,14 @@ VkResult VKAPI loader_GetPhysicalDeviceSurfaceSupportKHR(
                                                   pSupported);
 }
 
+bool wsi_swapchain_instance_gpa(struct loader_instance *ptr_instance,
+                                 const char* name, void **addr)
+{
+    *addr = NULL;
 
-
+    if (!strcmp("vkGetPhysicalDeviceSurfaceSupportKHR", name)) {
+        *addr = ptr_instance->wsi_swapchain_enabled ? (void *) wsi_swapchain_GetPhysicalDeviceSurfaceSupportKHR : NULL;
+        return true;
+    }
+    return false;
+}

diff --git a/loader/wsi_swapchain.h b/loader/wsi_swapchain.h
index c263ca9..bf292bd 100644 (file)
--- a/loader/wsi_swapchain.h
+++ b/loader/wsi_swapchain.h
@@ -28,6 +28,8 @@
 #include "loader.h"
 #include "vk_ext_khr_swapchain.h"
 
+bool wsi_swapchain_instance_gpa(struct loader_instance *ptr_instance,
+                                 const char* name, void **addr);
 void wsi_swapchain_add_instance_extensions(
         const struct loader_instance *inst,
         struct loader_extension_list *ext_list);