bug 14864: Remove redundant VkPipelineShaderStageCreateInfo.stage field? (WIP)

Removed.

https://cvs.khronos.org/bugzilla/show_bug.cgi?id=14864

6 files changed, 37 insertions, 31 deletions

diff --git a/demos/cube.c b/demos/cube.c
index 9f4ed4ce..b64023fc 100644
--- a/demos/cube.c
+++ b/demos/cube.c
@@ -1623,11 +1623,9 @@ static void demo_prepare_pipeline(struct demo *demo)
     memset(&shaderStages, 0, 2 * sizeof(VkPipelineShaderStageCreateInfo));
 
     shaderStages[0].sType  = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
-    shaderStages[0].stage  = VK_SHADER_STAGE_VERTEX_BIT;
     shaderStages[0].shader = demo_prepare_vs(demo);
 
     shaderStages[1].sType  = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
-    shaderStages[1].stage  = VK_SHADER_STAGE_FRAGMENT_BIT;
     shaderStages[1].shader = demo_prepare_fs(demo);
 
     memset(&pipelineCache, 0, sizeof(pipelineCache));
diff --git a/demos/tri.c b/demos/tri.c
index dd1f449b..3d72f877 100644
--- a/demos/tri.c
+++ b/demos/tri.c
@@ -1374,11 +1374,9 @@ static void demo_prepare_pipeline(struct demo *demo)
     memset(&shaderStages, 0, 2 * sizeof(VkPipelineShaderStageCreateInfo));
 
     shaderStages[0].sType                = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
-    shaderStages[0].stage                = VK_SHADER_STAGE_VERTEX_BIT;
     shaderStages[0].shader               = demo_prepare_vs(demo);
 
     shaderStages[1].sType  = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
-    shaderStages[1].stage  = VK_SHADER_STAGE_FRAGMENT_BIT;
     shaderStages[1].shader = demo_prepare_fs(demo);
 
     pipeline.pVertexInputState   = &vi;
diff --git a/include/vulkan.h b/include/vulkan.h
index 560910a1..83990536 100644
--- a/include/vulkan.h
+++ b/include/vulkan.h
@@ -1552,7 +1552,6 @@ typedef struct {
 typedef struct {
     VkStructureType                             sType;
     const void*                                 pNext;
-    VkShaderStageFlagBits                       stage;
     VkShader                                    shader;
     const VkSpecializationInfo*                 pSpecializationInfo;
 } VkPipelineShaderStageCreateInfo;
diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp
index 492895fd..a9285477 100755
--- a/layers/draw_state.cpp
+++ b/layers/draw_state.cpp
@@ -73,6 +73,7 @@ struct layer_data {
     unordered_map<uint64_t, SET_NODE*> setMap;
     unordered_map<uint64_t, LAYOUT_NODE*> layoutMap;
     unordered_map<uint64_t, PIPELINE_LAYOUT_NODE> pipelineLayoutMap;
+    unordered_map<uint64_t, VkShaderStageFlagBits> shaderStageMap;
     // Map for layout chains
     unordered_map<void*, GLOBAL_CB_NODE*> cmdBufferMap;
     unordered_map<uint64_t, VkRenderPassCreateInfo*> renderPassMap;
@@ -430,7 +431,7 @@ static VkBool32 verifyPipelineCreateState(layer_data* my_data, const VkDevice de
 }
 // Init the pipeline mapping info based on pipeline create info LL tree
 //  Threading note : Calls to this function should wrapped in mutex
-static PIPELINE_NODE* initPipeline(const VkGraphicsPipelineCreateInfo* pCreateInfo, PIPELINE_NODE* pBasePipeline)
+static PIPELINE_NODE* initPipeline(layer_data* dev_data, const VkGraphicsPipelineCreateInfo* pCreateInfo, PIPELINE_NODE* pBasePipeline)
 {
     PIPELINE_NODE* pPipeline = new PIPELINE_NODE;
     if (pBasePipeline) {
@@ -448,7 +449,10 @@ static PIPELINE_NODE* initPipeline(const VkGraphicsPipelineCreateInfo* pCreateIn
     for (uint32_t i = 0; i < pCreateInfo->stageCount; i++) {
         const VkPipelineShaderStageCreateInfo *pPSSCI = &pCreateInfo->pStages[i];
 
-        switch (pPSSCI->stage) {
+        if (dev_data->shaderStageMap.find(pPSSCI->shader.handle) == dev_data->shaderStageMap.end())
+            continue;
+
+        switch (dev_data->shaderStageMap[pPSSCI->shader.handle]) {
             case VK_SHADER_STAGE_VERTEX_BIT:
                 memcpy(&pPipeline->vsCI, pPSSCI, sizeof(VkPipelineShaderStageCreateInfo));
                 pPipeline->active_shaders |= VK_SHADER_STAGE_VERTEX_BIT;
@@ -1798,8 +1802,10 @@ VK_LAYER_EXPORT void VKAPI vkDestroyShaderModule(VkDevice device, VkShaderModule
 
 VK_LAYER_EXPORT void VKAPI vkDestroyShader(VkDevice device, VkShader shader)
 {
-    get_my_data_ptr(get_dispatch_key(device), layer_data_map)->device_dispatch_table->DestroyShader(device, shader);
-    // TODO : Clean up any internal data structures using this obj.
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+    uint64_t handle = shader.handle;
+    dev_data->device_dispatch_table->DestroyShader(device, shader);
+    dev_data->shaderStageMap.erase(handle);
 }
 
 VK_LAYER_EXPORT void VKAPI vkDestroyPipeline(VkDevice device, VkPipeline pipeline)
@@ -1899,6 +1905,23 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageV
     return result;
 }
 
+VK_LAYER_EXPORT VkResult VKAPI vkCreateShader(
+        VkDevice device,
+        const VkShaderCreateInfo *pCreateInfo,
+        VkShader *pShader)
+{
+    layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+    VkResult result = dev_data->device_dispatch_table->CreateShader(device, pCreateInfo, pShader);
+
+    if (VK_SUCCESS == result) {
+        loader_platform_thread_lock_mutex(&globalLock);
+        dev_data->shaderStageMap[pShader->handle] = pCreateInfo->stage;
+        loader_platform_thread_unlock_mutex(&globalLock);
+    }
+
+    return result;
+}
+
 //TODO handle pipeline caches
 VkResult VKAPI vkCreatePipelineCache(
     VkDevice                                    device,
@@ -1955,7 +1978,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateGraphicsPipelines(VkDevice device, VkPipe
     uint32_t i=0;
     loader_platform_thread_lock_mutex(&globalLock);
     for (i=0; i<count; i++) {
-        pPipeNode[i] = initPipeline(&pCreateInfos[i], NULL);
+        pPipeNode[i] = initPipeline(dev_data, &pCreateInfos[i], NULL);
         skipCall |= verifyPipelineCreateState(dev_data, device, pPipeNode[i]);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
@@ -3701,6 +3724,8 @@ VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(VkDevice dev, const
         return (PFN_vkVoidFunction) vkCreateImage;
     if (!strcmp(funcName, "vkCreateImageView"))
         return (PFN_vkVoidFunction) vkCreateImageView;
+    if (!strcmp(funcName, "vkCreateShader"))
+        return (PFN_vkVoidFunction) vkCreateShader;
     if (!strcmp(funcName, "CreatePipelineCache"))
         return (PFN_vkVoidFunction) vkCreatePipelineCache;
     if (!strcmp(funcName, "DestroyPipelineCache"))
diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp
index f93ad1ca..d7c13d40 100644
--- a/layers/param_checker.cpp
+++ b/layers/param_checker.cpp
@@ -3889,15 +3889,6 @@ bool PreCreateGraphicsPipelines(
         "vkCreateGraphicsPipelines parameter, VkStructureType pCreateInfos->pStages->sType, is an invalid enumerator");
         return false;
     }
-    if((pCreateInfos->pStages->stage & (VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT |
-                                       VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT | VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT |
-                                       VK_SHADER_STAGE_GEOMETRY_BIT |
-                                       VK_SHADER_STAGE_COMPUTE_BIT)) == 0)
-    {
-        log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkCreateGraphicsPipelines parameter, VkShaderStage pCreateInfos->pStages->stage, is an unrecognized enumerator");
-        return false;
-    }
     if(pCreateInfos->pStages->pSpecializationInfo != nullptr)
     {
     if(pCreateInfos->pStages->pSpecializationInfo->pMap != nullptr)
@@ -4212,15 +4203,6 @@ bool PreCreateComputePipelines(
         "vkCreateComputePipelines parameter, VkStructureType pCreateInfos->cs.sType, is an invalid enumerator");
         return false;
     }
-    if((pCreateInfos->stage.stage & (VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT |
-                                       VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT | VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT |
-                                       VK_SHADER_STAGE_GEOMETRY_BIT |
-                                       VK_SHADER_STAGE_COMPUTE_BIT)) == 0)
-    {
-        log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
-        "vkCreateComputePipelines parameter, VkShaderStage pCreateInfos->cs.stage, is an unrecognized enumerator");
-        return false;
-    }
     if(pCreateInfos->stage.pSpecializationInfo != nullptr)
     {
     if(pCreateInfos->stage.pSpecializationInfo->pMap != nullptr)
diff --git a/layers/shader_checker.cpp b/layers/shader_checker.cpp
index 64feaf0e..22bb357d 100644
--- a/layers/shader_checker.cpp
+++ b/layers/shader_checker.cpp
@@ -214,10 +214,12 @@ static std::unordered_map<uint64_t, shader_module *> shader_module_map;
 struct shader_object {
     std::string name;
     struct shader_module *module;
+    VkShaderStageFlagBits stage;
 
     shader_object(VkShaderCreateInfo const *pCreateInfo)
     {
         module = shader_module_map[pCreateInfo->module.handle];
+        stage = pCreateInfo->stage;
         name = pCreateInfo->pName;
     }
 };
@@ -1068,16 +1070,18 @@ validate_graphics_pipeline(VkDevice dev, VkGraphicsPipelineCreateInfo const *pCr
         VkPipelineShaderStageCreateInfo const *pStage = &pCreateInfo->pStages[i];
         if (pStage->sType == VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO) {
 
-            if ((pStage->stage & (VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_GEOMETRY_BIT | VK_SHADER_STAGE_FRAGMENT_BIT
+            // always true; pStage->stage may be revived in a later revision and
+            // this will make sense again
+            if ((VK_SHADER_STAGE_VERTEX_BIT & (VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_GEOMETRY_BIT | VK_SHADER_STAGE_FRAGMENT_BIT
                                   | VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT | VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)) == 0) {
                 if (log_msg(mdd(dev), VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_DEVICE, /*dev*/0, 0, SHADER_CHECKER_UNKNOWN_STAGE, "SC",
-                        "Unknown shader stage %d", pStage->stage)) {
+                        "Unknown shader stage %d", VK_SHADER_STAGE_VERTEX_BIT)) {
                     pass = false;
                 }
             }
             else {
                 struct shader_object *shader = shader_object_map[pStage->shader.handle];
-                shaders[get_shader_stage_id(pStage->stage)] = shader->module;
+                shaders[get_shader_stage_id(shader->stage)] = shader->module;
 
                 /* validate descriptor set layout against what the spirv module actually uses */
                 std::map<std::pair<unsigned, unsigned>, interface_var> descriptor_uses;