WIP bug-14815: VkShaderStage

4 files changed, 47 insertions, 23 deletions

diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp
index d36b1af8..3317a43b 100755
--- a/layers/draw_state.cpp
+++ b/layers/draw_state.cpp
@@ -217,7 +217,6 @@ static string cmdTypeToString(CMD_TYPE cmd)
 }
 // Block of code at start here for managing/tracking Pipeline state that this layer cares about
 // Just track 2 shaders for now
-#define VK_NUM_GRAPHICS_SHADERS VK_SHADER_STAGE_COMPUTE
 #define MAX_SLOTS 2048
 #define NUM_COMMAND_BUFFERS_TO_DISPLAY 10
 
@@ -448,27 +447,27 @@ static PIPELINE_NODE* initPipeline(const VkGraphicsPipelineCreateInfo* pCreateIn
         const VkPipelineShaderStageCreateInfo *pPSSCI = &pCreateInfo->pStages[i];
 
         switch (pPSSCI->stage) {
-            case VK_SHADER_STAGE_VERTEX:
+            case VK_SHADER_STAGE_VERTEX_BIT:
                 memcpy(&pPipeline->vsCI, pPSSCI, sizeof(VkPipelineShaderStageCreateInfo));
                 pPipeline->active_shaders |= VK_SHADER_STAGE_VERTEX_BIT;
                 break;
-            case VK_SHADER_STAGE_TESSELLATION_CONTROL:
+            case VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT:
                 memcpy(&pPipeline->tcsCI, pPSSCI, sizeof(VkPipelineShaderStageCreateInfo));
                 pPipeline->active_shaders |= VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT;
                 break;
-            case VK_SHADER_STAGE_TESSELLATION_EVALUATION:
+            case VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT:
                 memcpy(&pPipeline->tesCI, pPSSCI, sizeof(VkPipelineShaderStageCreateInfo));
                 pPipeline->active_shaders |= VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT;
                 break;
-            case VK_SHADER_STAGE_GEOMETRY:
+            case VK_SHADER_STAGE_GEOMETRY_BIT:
                 memcpy(&pPipeline->gsCI, pPSSCI, sizeof(VkPipelineShaderStageCreateInfo));
                 pPipeline->active_shaders |= VK_SHADER_STAGE_GEOMETRY_BIT;
                 break;
-            case VK_SHADER_STAGE_FRAGMENT:
+            case VK_SHADER_STAGE_FRAGMENT_BIT:
                 memcpy(&pPipeline->fsCI, pPSSCI, sizeof(VkPipelineShaderStageCreateInfo));
                 pPipeline->active_shaders |= VK_SHADER_STAGE_FRAGMENT_BIT;
                 break;
-            case VK_SHADER_STAGE_COMPUTE:
+            case VK_SHADER_STAGE_COMPUTE_BIT:
                 // TODO : Flag error, CS is specified through VkComputePipelineCreateInfo
                 pPipeline->active_shaders |= VK_SHADER_STAGE_COMPUTE_BIT;
                 break;
diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp
index da5cf1ac..8ea75ff3 100644
--- a/layers/param_checker.cpp
+++ b/layers/param_checker.cpp
@@ -3978,8 +3978,10 @@ bool PreCreateGraphicsPipelines(
         "vkCreateGraphicsPipelines parameter, VkStructureType pCreateInfos->pStages->sType, is an invalid enumerator");
         return false;
     }
-    if(pCreateInfos->pStages->stage < VK_SHADER_STAGE_BEGIN_RANGE ||
-        pCreateInfos->pStages->stage > VK_SHADER_STAGE_END_RANGE)
+    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");
@@ -4299,8 +4301,10 @@ bool PreCreateComputePipelines(
         "vkCreateComputePipelines parameter, VkStructureType pCreateInfos->cs.sType, is an invalid enumerator");
         return false;
     }
-    if(pCreateInfos->stage.stage < VK_SHADER_STAGE_BEGIN_RANGE ||
-        pCreateInfos->stage.stage > VK_SHADER_STAGE_END_RANGE)
+    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");
diff --git a/layers/shader_checker.cpp b/layers/shader_checker.cpp
index 2b39c529..aae28135 100644
--- a/layers/shader_checker.cpp
+++ b/layers/shader_checker.cpp
@@ -33,6 +33,7 @@
 #include "vk_loader_platform.h"
 #include "vk_dispatch_table_helper.h"
 #include "vk_layer.h"
+#include "vk_layer_utils.h"
 #include "vk_layer_config.h"
 #include "vk_layer_table.h"
 #include "vk_layer_logging.h"
@@ -1013,7 +1014,7 @@ struct shader_stage_attributes {
 
 
 static shader_stage_attributes
-shader_stage_attribs[VK_SHADER_STAGE_FRAGMENT + 1] = {
+shader_stage_attribs[] = {
     { "vertex shader", false },
     { "tessellation control shader", true },
     { "tessellation evaluation shader", false },
@@ -1040,14 +1041,22 @@ find_descriptor_binding(std::vector<std::vector<VkDescriptorSetLayoutBinding>*>*
     return &(*set)[slot.second];
 }
 
+static uint32_t get_shader_stage_id(VkShaderStageFlagBits stage)
+{
+    uint32_t bit_pos = u_ffs(stage);
+    return bit_pos-1;
+}
 
 static bool
 validate_graphics_pipeline(VkDevice dev, VkGraphicsPipelineCreateInfo const *pCreateInfo)
 {
     /* We seem to allow pipeline stages to be specified out of order, so collect and identify them
      * before trying to do anything more: */
+    int vertex_stage = get_shader_stage_id(VK_SHADER_STAGE_VERTEX_BIT);
+    int geometry_stage = get_shader_stage_id(VK_SHADER_STAGE_GEOMETRY_BIT);
+    int fragment_stage = get_shader_stage_id(VK_SHADER_STAGE_FRAGMENT_BIT);
 
-    shader_module const *shaders[VK_SHADER_STAGE_FRAGMENT + 1];  /* exclude CS */
+    shader_module const *shaders[fragment_stage + 1];  /* exclude CS */
     memset(shaders, 0, sizeof(shaders));
     render_pass const *rp = 0;
     VkPipelineVertexInputStateCreateInfo const *vi = 0;
@@ -1059,7 +1068,8 @@ 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 || pStage->stage > VK_SHADER_STAGE_FRAGMENT) {
+            if ((pStage->stage & (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)) {
                     pass = false;
@@ -1067,7 +1077,7 @@ validate_graphics_pipeline(VkDevice dev, VkGraphicsPipelineCreateInfo const *pCr
             }
             else {
                 struct shader_object *shader = shader_object_map[pStage->shader.handle];
-                shaders[pStage->stage] = shader->module;
+                shaders[get_shader_stage_id(pStage->stage)] = shader->module;
 
                 /* validate descriptor set layout against what the spirv module actually uses */
                 std::map<std::pair<unsigned, unsigned>, interface_var> descriptor_uses;
@@ -1106,20 +1116,20 @@ validate_graphics_pipeline(VkDevice dev, VkGraphicsPipelineCreateInfo const *pCr
         pass = validate_vi_consistency(dev, vi) && pass;
     }
 
-    if (shaders[VK_SHADER_STAGE_VERTEX]) {
-        pass = validate_vi_against_vs_inputs(dev, vi, shaders[VK_SHADER_STAGE_VERTEX]) && pass;
+    if (shaders[vertex_stage]) {
+        pass = validate_vi_against_vs_inputs(dev, vi, shaders[vertex_stage]) && pass;
     }
 
     /* TODO: enforce rules about present combinations of shaders */
-    int producer = VK_SHADER_STAGE_VERTEX;
-    int consumer = VK_SHADER_STAGE_GEOMETRY;
+    int producer = get_shader_stage_id(VK_SHADER_STAGE_VERTEX_BIT);
+    int consumer = get_shader_stage_id(VK_SHADER_STAGE_GEOMETRY_BIT);
 
-    while (!shaders[producer] && producer != VK_SHADER_STAGE_FRAGMENT) {
+    while (!shaders[producer] && producer != fragment_stage) {
         producer++;
         consumer++;
     }
 
-    for (; producer != VK_SHADER_STAGE_FRAGMENT && consumer <= VK_SHADER_STAGE_FRAGMENT; consumer++) {
+    for (; producer != fragment_stage && consumer <= fragment_stage; consumer++) {
         assert(shaders[producer]);
         if (shaders[consumer]) {
             pass = validate_interface_between_stages(dev,
@@ -1131,8 +1141,8 @@ validate_graphics_pipeline(VkDevice dev, VkGraphicsPipelineCreateInfo const *pCr
         }
     }
 
-    if (shaders[VK_SHADER_STAGE_FRAGMENT] && rp) {
-        pass = validate_fs_outputs_against_render_pass(dev, shaders[VK_SHADER_STAGE_FRAGMENT], rp, pCreateInfo->subpass) && pass;
+    if (shaders[fragment_stage] && rp) {
+        pass = validate_fs_outputs_against_render_pass(dev, shaders[fragment_stage], rp, pCreateInfo->subpass) && pass;
     }
 
     loader_platform_thread_unlock_mutex(&globalLock);
diff --git a/layers/vk_layer_utils.h b/layers/vk_layer_utils.h
index 643e1d25..bd5eac86 100644
--- a/layers/vk_layer_utils.h
+++ b/layers/vk_layer_utils.h
@@ -24,6 +24,9 @@
  **************************************************************************/
 #pragma once
 #include <stdbool.h>
+#ifndef WIN32
+#include <strings.h> /* for ffs() */
+#endif
 
 #ifdef __cplusplus
 extern "C" {
@@ -48,6 +51,14 @@ bool   vk_format_is_srgb(VkFormat format);
 bool   vk_format_is_compressed(VkFormat format);
 size_t vk_format_get_size(VkFormat format);
 
+static inline int u_ffs(int val)
+{
+#ifdef WIN32
+        return __lzcnt(val) + 1;
+#else
+        return ffs(val);
+#endif
+}
 
 #ifdef __cplusplus
 }