bug-14014: Allow multiple entrypoints in modules

Continue implementation of shader module.

6 files changed, 50 insertions, 20 deletions

diff --git a/demos/cube.c b/demos/cube.c
index 1ffaea14..6bd061ae 100644
--- a/demos/cube.c
+++ b/demos/cube.c
@@ -1204,41 +1204,52 @@ static VkShader demo_prepare_shader(struct demo *demo,
                                       const void *code,
                                       size_t size)
 {
-    VkShaderCreateInfo createInfo;
+    VkShaderModuleCreateInfo moduleCreateInfo;
+    VkShaderCreateInfo shaderCreateInfo;
+    VkShaderModule shaderModule;
     VkShader shader;
     VkResult err;
 
 
-    createInfo.sType = VK_STRUCTURE_TYPE_SHADER_CREATE_INFO;
-    createInfo.pNext = NULL;
+    moduleCreateInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
+    moduleCreateInfo.pNext = NULL;
 
-    if (!demo->use_glsl) {
-        createInfo.codeSize = size;
-        createInfo.pCode = code;
-        createInfo.flags = 0;
+    shaderCreateInfo.sType = VK_STRUCTURE_TYPE_SHADER_CREATE_INFO;
+    shaderCreateInfo.pNext = NULL;
 
-        err = vkCreateShader(demo->device, &createInfo, &shader);
+    if (!demo->use_glsl) {
+        moduleCreateInfo.codeSize = size;
+        moduleCreateInfo.pCode = code;
+        moduleCreateInfo.flags = 0;
+        err = vkCreateShaderModule(demo->device, &moduleCreateInfo, &shaderModule);
         if (err) {
-            free((void *) createInfo.pCode);
+            free((void *) moduleCreateInfo.pCode);
         }
+
+        shaderCreateInfo.flags = 0;
+        shaderCreateInfo.module = shaderModule;
+        err = vkCreateShader(demo->device, &shaderCreateInfo, &shader);
     } else {
         // Create fake SPV structure to feed GLSL
         // to the driver "under the covers"
-        createInfo.codeSize = 3 * sizeof(uint32_t) + size + 1;
-        createInfo.pCode = malloc(createInfo.codeSize);
-        createInfo.flags = 0;
+        moduleCreateInfo.codeSize = 3 * sizeof(uint32_t) + size + 1;
+        moduleCreateInfo.pCode = malloc(moduleCreateInfo.codeSize);
+        moduleCreateInfo.flags = 0;
 
         /* try version 0 first: VkShaderStage followed by GLSL */
-        ((uint32_t *) createInfo.pCode)[0] = ICD_SPV_MAGIC;
-        ((uint32_t *) createInfo.pCode)[1] = 0;
-        ((uint32_t *) createInfo.pCode)[2] = stage;
-        memcpy(((uint32_t *) createInfo.pCode + 3), code, size + 1);
+        ((uint32_t *) moduleCreateInfo.pCode)[0] = ICD_SPV_MAGIC;
+        ((uint32_t *) moduleCreateInfo.pCode)[1] = 0;
+        ((uint32_t *) moduleCreateInfo.pCode)[2] = stage;
+        memcpy(((uint32_t *) moduleCreateInfo.pCode + 3), code, size + 1);
 
-        err = vkCreateShader(demo->device, &createInfo, &shader);
+        err = vkCreateShaderModule(demo->device, &moduleCreateInfo, &shaderModule);
         if (err) {
-            free((void *) createInfo.pCode);
-            return (VkShader) VK_NULL_HANDLE;
+            free((void *) moduleCreateInfo.pCode);
         }
+
+        shaderCreateInfo.flags = 0;
+        shaderCreateInfo.module = shaderModule;
+        err = vkCreateShader(demo->device, &shaderCreateInfo, &shader);
     }
     return shader;
 }
diff --git a/include/vkLayer.h b/include/vkLayer.h
index 9d4ab95b..e456a9cb 100644
--- a/include/vkLayer.h
+++ b/include/vkLayer.h
@@ -17,7 +17,6 @@
 #  define VK_LAYER_EXPORT
 #endif
 
-
 typedef void * (*PFN_vkGPA)(VkObject obj, const char * pName);
 typedef struct VkBaseLayerObject_
 {
@@ -66,6 +65,7 @@ typedef struct VkLayerDispatchTable_
     PFN_vkCreateImageView CreateImageView;
     PFN_vkCreateColorAttachmentView CreateColorAttachmentView;
     PFN_vkCreateDepthStencilView CreateDepthStencilView;
+    PFN_vkCreateShaderModule CreateShaderModule;
     PFN_vkCreateShader CreateShader;
     PFN_vkCreateGraphicsPipeline CreateGraphicsPipeline;
     PFN_vkCreateGraphicsPipelineDerivative CreateGraphicsPipelineDerivative;
diff --git a/loader/gpa_helper.h b/loader/gpa_helper.h
index a51112ce..02e33416 100644
--- a/loader/gpa_helper.h
+++ b/loader/gpa_helper.h
@@ -139,6 +139,8 @@ static inline void* globalGetProcAddr(const char *name)
         return (void*) vkCreateColorAttachmentView;
     if (!strcmp(name, "CreateDepthStencilView"))
         return (void*) vkCreateDepthStencilView;
+    if (!strcmp(name, "CreateShaderModule"))
+        return (void*) vkCreateShaderModule;
     if (!strcmp(name, "CreateShader"))
         return (void*) vkCreateShader;
     if (!strcmp(name, "CreateGraphicsPipeline"))
diff --git a/loader/table_ops.h b/loader/table_ops.h
index a657d552..a29324fd 100644
--- a/loader/table_ops.h
+++ b/loader/table_ops.h
@@ -74,6 +74,7 @@ static inline void loader_init_device_dispatch_table(VkLayerDispatchTable *table
     table->CreateImageView = (PFN_vkCreateImageView) gpa(dev, "vkCreateImageView");
     table->CreateColorAttachmentView = (PFN_vkCreateColorAttachmentView) gpa(dev, "vkCreateColorAttachmentView");
     table->CreateDepthStencilView = (PFN_vkCreateDepthStencilView) gpa(dev, "vkCreateDepthStencilView");
+    table->CreateShaderModule = (PFN_vkCreateShaderModule) gpa(dev, "vkCreateShaderModule");
     table->CreateShader = (PFN_vkCreateShader) gpa(dev, "vkCreateShader");
     table->CreateGraphicsPipeline = (PFN_vkCreateGraphicsPipeline) gpa(dev, "vkCreateGraphicsPipeline");
     table->CreateGraphicsPipelineDerivative = (PFN_vkCreateGraphicsPipelineDerivative) gpa(dev, "vkCreateGraphicsPipelineDerivative");
@@ -226,6 +227,8 @@ static inline void *loader_lookup_device_dispatch_table(
         return (void *) table->CreateColorAttachmentView;
     if (!strcmp(name, "CreateDepthStencilView"))
         return (void *) table->CreateDepthStencilView;
+    if (!strcmp(name, "CreateShaderModule"))
+        return (void *) table->CreateShaderModule;
     if (!strcmp(name, "CreateShader"))
         return (void *) table->CreateShader;
     if (!strcmp(name, "CreateGraphicsPipeline"))
diff --git a/loader/trampoline.c b/loader/trampoline.c
index 1f96b3b8..24d3a60b 100644
--- a/loader/trampoline.c
+++ b/loader/trampoline.c
@@ -615,6 +615,15 @@ LOADER_EXPORT VkResult VKAPI vkCreateDepthStencilView(VkDevice device, const VkD
     return disp->CreateDepthStencilView(device, pCreateInfo, pView);
 }
 
+LOADER_EXPORT VkResult VKAPI vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShader)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->CreateShaderModule(device, pCreateInfo, pShader);
+}
+
 LOADER_EXPORT VkResult VKAPI vkCreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader)
 {
     const VkLayerDispatchTable *disp;
diff --git a/vulkan.py b/vulkan.py
index 6d457fb6..f2dbd5b4 100755
--- a/vulkan.py
+++ b/vulkan.py
@@ -478,6 +478,11 @@ core = Extension(
              Param("const VkDepthStencilViewCreateInfo*", "pCreateInfo"),
              Param("VkDepthStencilView*", "pView")]),
 
+        Proto("VkResult", "CreateShaderModule",
+            [Param("VkDevice", "device"),
+             Param("const VkShaderModuleCreateInfo*", "pCreateInfo"),
+             Param("VkShaderModule*", "pShaderModule")]),
+
         Proto("VkResult", "CreateShader",
             [Param("VkDevice", "device"),
              Param("const VkShaderCreateInfo*", "pCreateInfo"),