add passes for vulkan-shader-profiler

Depends on KhronosGroup/SPIRV-Headers#398

Android.mk

@@ -288,6 +288,7 @@ $(eval $(call gen_spvtools_vendor_tables,$(SPVTOOLS_OUT_PATH),spv-amd-shader-bal
 $(eval $(call gen_spvtools_vendor_tables,$(SPVTOOLS_OUT_PATH),spv-amd-shader-explicit-vertex-parameter,""))
 $(eval $(call gen_spvtools_vendor_tables,$(SPVTOOLS_OUT_PATH),spv-amd-shader-trinary-minmax,""))
 $(eval $(call gen_spvtools_vendor_tables,$(SPVTOOLS_OUT_PATH),nonsemantic.clspvreflection,""))
+$(eval $(call gen_spvtools_vendor_tables,$(SPVTOOLS_OUT_PATH),nonsemantic.vkspreflection,""))
 
 define gen_spvtools_enum_string_mapping
 $(call generate-file-dir,$(1)/extension_enum.inc.inc)

BUILD.bazel

@@ -58,6 +58,8 @@ generate_vendor_tables(extension = "debuginfo")
 
 generate_vendor_tables(extension = "nonsemantic.clspvreflection")
 
+generate_vendor_tables(extension = "nonsemantic.vkspreflection")
+
 generate_vendor_tables(
     extension = "opencl.debuginfo.100",
     operand_kind_prefix = "CLDEBUG100_",
@@ -147,6 +149,7 @@ cc_library(
         ":gen_vendor_tables_debuginfo",
         ":gen_vendor_tables_nonsemantic_clspvreflection",
         ":gen_vendor_tables_nonsemantic_shader_debuginfo_100",
+        ":gen_vendor_tables_nonsemantic_vkspreflection",
         ":gen_vendor_tables_opencl_debuginfo_100",
         ":gen_vendor_tables_spv_amd_gcn_shader",
         ":gen_vendor_tables_spv_amd_shader_ballot",

BUILD.gn

@@ -331,6 +331,10 @@ spvtools_vendor_tables = [
     "nonsemantic.shader.debuginfo.100",
     "SHDEBUG100_",
   ],
+  [
+    "nonsemantic.vkspreflection",
+    "...nil...",
+  ],
 ]
 
 foreach(table_def, spvtools_vendor_tables) {

include/spirv-tools/libspirv.h

@@ -327,6 +327,7 @@ typedef enum spv_ext_inst_type_t {
   SPV_EXT_INST_TYPE_OPENCL_DEBUGINFO_100,
   SPV_EXT_INST_TYPE_NONSEMANTIC_CLSPVREFLECTION,
   SPV_EXT_INST_TYPE_NONSEMANTIC_SHADER_DEBUGINFO_100,
+  SPV_EXT_INST_TYPE_NONSEMANTIC_VKSPREFLECTION,
 
   // Multiple distinct extended instruction set types could return this
   // value, if they are prefixed with NonSemantic. and are otherwise

include/spirv-tools/optimizer.hpp

@@ -1003,6 +1003,133 @@ Optimizer::PassToken CreateSwitchDescriptorSetPass(uint32_t ds_from,
 // OpBeginInterlockInvocationEXT and one OpEndInterlockInvocationEXT, in that
 // order.
 Optimizer::PassToken CreateInvocationInterlockPlacementPass();
+
+struct vksp_push_constant {
+  uint32_t offset;
+  uint32_t size;
+  uint32_t stageFlags;
+  const char* pValues;
+};
+
+#define VKSP_DESCRIPTOR_TYPE_STORAGE_BUFFER_COUNTER_BITS (0xf0000000)
+#define VKSP_DESCRIPTOR_TYPE_STORAGE_BUFFER_COUNTER_MASK \
+  (~VKSP_DESCRIPTOR_TYPE_STORAGE_BUFFER_COUNTER_BITS)
+#define VKSP_DESCRIPTOR_TYPE_STORAGE_BUFFER_COUNTER \
+  (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER |              \
+   VKSP_DESCRIPTOR_TYPE_STORAGE_BUFFER_COUNTER_BITS)
+struct vksp_descriptor_set {
+  uint32_t ds;
+  uint32_t binding;
+  uint32_t type;
+  union {
+    struct {
+      uint32_t flags;
+      uint32_t queueFamilyIndexCount;
+      uint32_t sharingMode;
+      uint32_t size;
+      uint32_t usage;
+      uint32_t range;
+      uint32_t offset;
+      uint32_t memorySize;
+      uint32_t memoryType;
+      uint32_t bindOffset;
+    } buffer;
+    struct {
+      uint32_t imageLayout;
+      uint32_t imageFlags;
+      uint32_t imageType;
+      uint32_t format;
+      uint32_t width;
+      uint32_t height;
+      uint32_t depth;
+      uint32_t mipLevels;
+      uint32_t arrayLayers;
+      uint32_t samples;
+      uint32_t tiling;
+      uint32_t usage;
+      uint32_t sharingMode;
+      uint32_t queueFamilyIndexCount;
+      uint32_t initialLayout;
+      uint32_t aspectMask;
+      uint32_t baseMipLevel;
+      uint32_t levelCount;
+      uint32_t baseArrayLayer;
+      uint32_t layerCount;
+      uint32_t viewFlags;
+      uint32_t viewType;
+      uint32_t viewFormat;
+      uint32_t component_a;
+      uint32_t component_b;
+      uint32_t component_g;
+      uint32_t component_r;
+      uint32_t memorySize;
+      uint32_t memoryType;
+      uint32_t bindOffset;
+    } image;
+    struct {
+      uint32_t flags;
+      uint32_t magFilter;
+      uint32_t minFilter;
+      uint32_t mipmapMode;
+      uint32_t addressModeU;
+      uint32_t addressModeV;
+      uint32_t addressModeW;
+      union {
+        float fMipLodBias;
+        uint32_t uMipLodBias;
+      };
+      uint32_t anisotropyEnable;
+      union {
+        float fMaxAnisotropy;
+        uint32_t uMaxAnisotropy;
+      };
+      uint32_t compareEnable;
+      uint32_t compareOp;
+      union {
+        float fMinLod;
+        uint32_t uMinLod;
+      };
+      union {
+        float fMaxLod;
+        uint32_t uMaxLod;
+      };
+      uint32_t borderColor;
+      uint32_t unnormalizedCoordinates;
+    } sampler;
+  };
+};
+
+struct vksp_configuration {
+  const char* enabledExtensionNames;
+  uint32_t specializationInfoDataSize;
+  const char* specializationInfoData;
+  const char* shaderName;
+  const char* entryPoint;
+  uint32_t groupCountX;
+  uint32_t groupCountY;
+  uint32_t groupCountZ;
+};
+
+struct vksp_specialization_map_entry {
+  uint32_t constantID;
+  uint32_t offset;
+  uint32_t size;
+};
+
+struct vksp_counter {
+  uint32_t index;
+  const char* name;
+};
+
+Optimizer::PassToken CreateInsertVkspReflectInfoPass(
+    std::vector<vksp_push_constant>* pc, std::vector<vksp_descriptor_set>* ds,
+    std::vector<vksp_specialization_map_entry>* me, vksp_configuration* config);
+
+Optimizer::PassToken CreateExtractVkspReflectInfoPass(
+    std::vector<vksp_push_constant>* pc, std::vector<vksp_descriptor_set>* ds,
+    std::vector<vksp_specialization_map_entry>* me,
+    std::vector<vksp_counter>* counters, vksp_configuration* config);
+
 }  // namespace spvtools
 
 #endif  // INCLUDE_SPIRV_TOOLS_OPTIMIZER_HPP_

source/CMakeLists.txt

@@ -156,6 +156,7 @@ spvtools_vendor_tables("debuginfo" "debuginfo" "")
 spvtools_vendor_tables("opencl.debuginfo.100" "cldi100" "CLDEBUG100_")
 spvtools_vendor_tables("nonsemantic.shader.debuginfo.100" "shdi100" "SHDEBUG100_")
 spvtools_vendor_tables("nonsemantic.clspvreflection" "clspvreflection" "")
+spvtools_vendor_tables("nonsemantic.vkspreflection" "vkspreflection" "")
 spvtools_extinst_lang_headers("DebugInfo" ${DEBUGINFO_GRAMMAR_JSON_FILE})
 spvtools_extinst_lang_headers("OpenCLDebugInfo100" ${CLDEBUGINFO100_GRAMMAR_JSON_FILE})
 spvtools_extinst_lang_headers("NonSemanticShaderDebugInfo100" ${VKDEBUGINFO100_GRAMMAR_JSON_FILE})

source/ext_inst.cpp

@@ -30,6 +30,7 @@
 #include "glsl.std.450.insts.inc"
 #include "nonsemantic.clspvreflection.insts.inc"
 #include "nonsemantic.shader.debuginfo.100.insts.inc"
+#include "nonsemantic.vkspreflection.insts.inc"
 #include "opencl.debuginfo.100.insts.inc"
 #include "opencl.std.insts.inc"
 
@@ -62,6 +63,9 @@ static const spv_ext_inst_group_t kGroups_1_0[] = {
     {SPV_EXT_INST_TYPE_NONSEMANTIC_CLSPVREFLECTION,
      ARRAY_SIZE(nonsemantic_clspvreflection_entries),
      nonsemantic_clspvreflection_entries},
+    {SPV_EXT_INST_TYPE_NONSEMANTIC_VKSPREFLECTION,
+     ARRAY_SIZE(nonsemantic_vkspreflection_entries),
+     nonsemantic_vkspreflection_entries},
 };
 
 static const spv_ext_inst_table_t kTable_1_0 = {ARRAY_SIZE(kGroups_1_0),
@@ -138,6 +142,9 @@ spv_ext_inst_type_t spvExtInstImportTypeGet(const char* name) {
   if (!strncmp("NonSemantic.ClspvReflection.", name, 28)) {
     return SPV_EXT_INST_TYPE_NONSEMANTIC_CLSPVREFLECTION;
   }
+  if (!strncmp("NonSemantic.VkspReflection.", name, 27)) {
+    return SPV_EXT_INST_TYPE_NONSEMANTIC_VKSPREFLECTION;
+  }
   // ensure to add any known non-semantic extended instruction sets
   // above this point, and update spvExtInstIsNonSemantic()
   if (!strncmp("NonSemantic.", name, 12)) {
@@ -149,7 +156,8 @@ spv_ext_inst_type_t spvExtInstImportTypeGet(const char* name) {
 bool spvExtInstIsNonSemantic(const spv_ext_inst_type_t type) {
   if (type == SPV_EXT_INST_TYPE_NONSEMANTIC_UNKNOWN ||
       type == SPV_EXT_INST_TYPE_NONSEMANTIC_SHADER_DEBUGINFO_100 ||
-      type == SPV_EXT_INST_TYPE_NONSEMANTIC_CLSPVREFLECTION) {
+      type == SPV_EXT_INST_TYPE_NONSEMANTIC_CLSPVREFLECTION ||
+      type == SPV_EXT_INST_TYPE_NONSEMANTIC_VKSPREFLECTION) {
     return true;
   }
   return false;

source/opt/CMakeLists.txt

@@ -133,6 +133,7 @@ set(SPIRV_TOOLS_OPT_SOURCES
   vector_dce.h
   workaround1209.h
   wrap_opkill.h
+  vksp_passes.h
 
   fix_func_call_arguments.cpp
   aggressive_dead_code_elim_pass.cpp
@@ -250,6 +251,7 @@ set(SPIRV_TOOLS_OPT_SOURCES
   vector_dce.cpp
   workaround1209.cpp
   wrap_opkill.cpp
+  vksp_passes.cpp
 )
 
 if(MSVC AND (NOT ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")))

source/opt/constants.cpp

@@ -498,7 +498,7 @@ const Constant* ConstantManager::GetIntConst(uint64_t val, int32_t bitWidth,
     int32_t num_of_bit_to_ignore = 64 - bitWidth;
     val = static_cast<int64_t>(val << num_of_bit_to_ignore) >>
           num_of_bit_to_ignore;
-  } else {
+  } else if (bitWidth < 64) {
     // Clear the upper bit that are not used.
     uint64_t mask = ((1ull << bitWidth) - 1);
     val &= mask;
@@ -511,7 +511,7 @@ const Constant* ConstantManager::GetIntConst(uint64_t val, int32_t bitWidth,
   // If the value is more than 32-bit, we need to split the operands into two
   // 32-bit integers.
   return GetConstant(
-      int_type, {static_cast<uint32_t>(val >> 32), static_cast<uint32_t>(val)});
+      int_type, {static_cast<uint32_t>(val), static_cast<uint32_t>(val >> 32)});
 }
 
 uint32_t ConstantManager::GetUIntConstId(uint32_t val) {

source/opt/optimizer.cpp

@@ -1141,6 +1141,23 @@ Optimizer::PassToken CreateInvocationInterlockPlacementPass() {
   return MakeUnique<Optimizer::PassToken::Impl>(
       MakeUnique<opt::InvocationInterlockPlacementPass>());
 }
+
+Optimizer::PassToken CreateInsertVkspReflectInfoPass(
+    std::vector<vksp_push_constant>* pc, std::vector<vksp_descriptor_set>* ds,
+    std::vector<vksp_specialization_map_entry>* me,
+    vksp_configuration* config) {
+  return MakeUnique<Optimizer::PassToken::Impl>(
+      MakeUnique<opt::InsertVkspReflectInfoPass>(pc, ds, me, config));
+}
+Optimizer::PassToken CreateExtractVkspReflectInfoPass(
+    std::vector<vksp_push_constant>* pc, std::vector<vksp_descriptor_set>* ds,
+    std::vector<vksp_specialization_map_entry>* me,
+    std::vector<vksp_counter>* counters, vksp_configuration* config) {
+  return MakeUnique<Optimizer::PassToken::Impl>(
+      MakeUnique<opt::ExtractVkspReflectInfoPass>(pc, ds, me, counters,
+                                                  config));
+}
+
 }  // namespace spvtools
 
 extern "C" {

source/opt/passes.h

@@ -90,5 +90,6 @@
 #include "source/opt/vector_dce.h"
 #include "source/opt/workaround1209.h"
 #include "source/opt/wrap_opkill.h"
+#include "source/opt/vksp_passes.h"
 
 #endif  // SOURCE_OPT_PASSES_H_