WIP bug-14815: VkShaderStage

7 files changed, 73 insertions, 62 deletions

diff --git a/demos/cube.c b/demos/cube.c
index dddf8d65..a74c9097 100644
--- a/demos/cube.c
+++ b/demos/cube.c
@@ -1344,7 +1344,7 @@ static void demo_prepare_render_pass(struct demo *demo)
 }
 
 static VkShader demo_prepare_shader(struct demo* demo,
-                                      VkShaderStage stage,
+                                      VkShaderStageFlagBits stage,
                                       VkShaderModule* pShaderModule,
                                       const void* code,
                                       size_t size)
@@ -1436,7 +1436,7 @@ static VkShader demo_prepare_vs(struct demo *demo)
 
         vertShaderCode = demo_read_spv("cube-vert.spv", &size);
 
-        shader = demo_prepare_shader(demo, VK_SHADER_STAGE_VERTEX, &demo->vert_shader_module,
+        shader = demo_prepare_shader(demo, VK_SHADER_STAGE_VERTEX_BIT, &demo->vert_shader_module,
                                      vertShaderCode, size);
         free(vertShaderCode);
         return shader;
@@ -1464,7 +1464,7 @@ static VkShader demo_prepare_vs(struct demo *demo)
                 "   gl_Position.z = (gl_Position.z + gl_Position.w) / 2.0;\n"
                 "}\n";
 
-        return demo_prepare_shader(demo, VK_SHADER_STAGE_VERTEX, &demo->vert_shader_module,
+        return demo_prepare_shader(demo, VK_SHADER_STAGE_VERTEX_BIT, &demo->vert_shader_module,
                                    (const void *) vertShaderText,
                                    strlen(vertShaderText));
     }
@@ -1479,7 +1479,7 @@ static VkShader demo_prepare_fs(struct demo *demo)
 
         fragShaderCode = demo_read_spv("cube-frag.spv", &size);
 
-        shader = demo_prepare_shader(demo, VK_SHADER_STAGE_FRAGMENT, &demo->frag_shader_module,
+        shader = demo_prepare_shader(demo, VK_SHADER_STAGE_FRAGMENT_BIT, &demo->frag_shader_module,
                                      fragShaderCode, size);
         free(fragShaderCode);
         return shader;
@@ -1496,7 +1496,7 @@ static VkShader demo_prepare_fs(struct demo *demo)
                 "   uFragColor = texture(tex, texcoord.xy);\n"
                 "}\n";
 
-        return demo_prepare_shader(demo, VK_SHADER_STAGE_FRAGMENT, &demo->frag_shader_module,
+        return demo_prepare_shader(demo, VK_SHADER_STAGE_FRAGMENT_BIT, &demo->frag_shader_module,
                                    (const void *) fragShaderText,
                                    strlen(fragShaderText));
     }
@@ -1577,11 +1577,11 @@ 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;
+    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;
+    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 936d07a8..4f211795 100644
--- a/demos/tri.c
+++ b/demos/tri.c
@@ -1113,7 +1113,7 @@ static void demo_prepare_render_pass(struct demo *demo)
 }
 
 static VkShader demo_prepare_shader(struct demo *demo,
-                                      VkShaderStage stage,
+                                      VkShaderStageFlagBits stage,
                                       VkShaderModule* pShaderModule,
                                       const void *code,
                                       size_t size)
@@ -1202,7 +1202,7 @@ static VkShader demo_prepare_vs(struct demo *demo)
 
         vertShaderCode = demo_read_spv("tri-vert.spv", &size);
 
-        shader = demo_prepare_shader(demo, VK_SHADER_STAGE_VERTEX,
+        shader = demo_prepare_shader(demo, VK_SHADER_STAGE_VERTEX_BIT,
                                      &demo->vert_shader_module,
                                      vertShaderCode, size);
         free(vertShaderCode);
@@ -1220,7 +1220,7 @@ static VkShader demo_prepare_vs(struct demo *demo)
             "   gl_Position = pos;\n"
             "}\n";
 
-        return demo_prepare_shader(demo, VK_SHADER_STAGE_VERTEX,
+        return demo_prepare_shader(demo, VK_SHADER_STAGE_VERTEX_BIT,
                                    &demo->vert_shader_module,
                                    (const void *) vertShaderText,
                                    strlen(vertShaderText));
@@ -1236,7 +1236,7 @@ static VkShader demo_prepare_fs(struct demo *demo)
 
         fragShaderCode = demo_read_spv("tri-frag.spv", &size);
 
-        shader = demo_prepare_shader(demo, VK_SHADER_STAGE_FRAGMENT,
+        shader = demo_prepare_shader(demo, VK_SHADER_STAGE_FRAGMENT_BIT,
                                      &demo->frag_shader_module,
                                      fragShaderCode, size);
 
@@ -1254,7 +1254,7 @@ static VkShader demo_prepare_fs(struct demo *demo)
                 "   uFragColor = texture(tex, texcoord);\n"
                 "}\n";
 
-        return demo_prepare_shader(demo, VK_SHADER_STAGE_FRAGMENT,
+        return demo_prepare_shader(demo, VK_SHADER_STAGE_FRAGMENT_BIT,
                                    &demo->frag_shader_module,
                                    (const void *) fragShaderText,
                                    strlen(fragShaderText));
@@ -1341,11 +1341,11 @@ 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;
+    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;
+    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 93b21bc7..5f9a8b94 100644
--- a/include/vulkan.h
+++ b/include/vulkan.h
@@ -500,19 +500,6 @@ typedef enum {
 } VkChannelSwizzle;
 
 typedef enum {
-    VK_SHADER_STAGE_VERTEX = 0,
-    VK_SHADER_STAGE_TESSELLATION_CONTROL = 1,
-    VK_SHADER_STAGE_TESSELLATION_EVALUATION = 2,
-    VK_SHADER_STAGE_GEOMETRY = 3,
-    VK_SHADER_STAGE_FRAGMENT = 4,
-    VK_SHADER_STAGE_COMPUTE = 5,
-    VK_SHADER_STAGE_BEGIN_RANGE = VK_SHADER_STAGE_VERTEX,
-    VK_SHADER_STAGE_END_RANGE = VK_SHADER_STAGE_COMPUTE,
-    VK_SHADER_STAGE_NUM = (VK_SHADER_STAGE_COMPUTE - VK_SHADER_STAGE_VERTEX + 1),
-    VK_SHADER_STAGE_MAX_ENUM = 0x7FFFFFFF
-} VkShaderStage;
-
-typedef enum {
     VK_VERTEX_INPUT_STEP_RATE_VERTEX = 0,
     VK_VERTEX_INPUT_STEP_RATE_INSTANCE = 1,
     VK_VERTEX_INPUT_STEP_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_STEP_RATE_VERTEX,
@@ -973,6 +960,16 @@ typedef VkFlags VkShaderModuleCreateFlags;
 typedef VkFlags VkShaderCreateFlags;
 
 typedef enum {
+    VK_SHADER_STAGE_VERTEX_BIT = 0x00000001,
+    VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002,
+    VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004,
+    VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008,
+    VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010,
+    VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020,
+    VK_SHADER_STAGE_ALL = 0x7FFFFFFF,
+} VkShaderStageFlagBits;
+
+typedef enum {
     VK_CHANNEL_R_BIT = 0x00000001,
     VK_CHANNEL_G_BIT = 0x00000002,
     VK_CHANNEL_B_BIT = 0x00000004,
@@ -986,16 +983,6 @@ typedef enum {
     VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004,
 } VkPipelineCreateFlagBits;
 typedef VkFlags VkPipelineCreateFlags;
-
-typedef enum {
-    VK_SHADER_STAGE_VERTEX_BIT = 0x00000001,
-    VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002,
-    VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004,
-    VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008,
-    VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010,
-    VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020,
-    VK_SHADER_STAGE_ALL = 0x7FFFFFFF,
-} VkShaderStageFlagBits;
 typedef VkFlags VkShaderStageFlags;
 
 typedef enum {
@@ -1556,7 +1543,7 @@ typedef struct {
     VkShaderModule                              module;
     const char*                                 pName;
     VkShaderCreateFlags                         flags;
-    VkShaderStage                               stage;
+    VkShaderStageFlagBits                       stage;
 } VkShaderCreateInfo;
 
 typedef struct {
@@ -1583,7 +1570,7 @@ typedef struct {
 typedef struct {
     VkStructureType                             sType;
     const void*                                 pNext;
-    VkShaderStage                               stage;
+    VkShaderStageFlagBits                       stage;
     VkShader                                    shader;
     const VkSpecializationInfo*                 pSpecializationInfo;
 } VkPipelineShaderStageCreateInfo;
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
 }