Updated spirv-tools.

3rdparty/spirv-tools/include/generated/build-version.inc

@@ -1 +1 @@
-"v2023.6", "SPIRV-Tools v2023.6 v2023.6.rc1-1-g6a47300f"
+"v2023.6", "SPIRV-Tools v2023.6 v2023.6.rc1-7-g57aba7ff"

3rdparty/spirv-tools/include/spirv-tools/libspirv.h

@@ -967,9 +967,16 @@ SPIRV_TOOLS_EXPORT bool spvOptimizerRegisterPassFromFlag(
     spv_optimizer_t* optimizer, const char* flag);
 
 // Registers passes specified by length number of flags in an optimizer object.
+// Passes may remove interface variables that are unused.
 SPIRV_TOOLS_EXPORT bool spvOptimizerRegisterPassesFromFlags(
     spv_optimizer_t* optimizer, const char** flags, const size_t flag_count);
 
+// Registers passes specified by length number of flags in an optimizer object.
+// Passes will not remove interface variables.
+SPIRV_TOOLS_EXPORT bool
+spvOptimizerRegisterPassesFromFlagsWhilePreservingTheInterface(
+    spv_optimizer_t* optimizer, const char** flags, const size_t flag_count);
+
 // Optimizes the SPIR-V code of size |word_count| pointed to by |binary| and
 // returns an optimized spv_binary in |optimized_binary|.
 //

3rdparty/spirv-tools/include/spirv-tools/optimizer.hpp

@@ -100,8 +100,6 @@ class Optimizer {
   //
   // If |preserve_interface| is true, all non-io variables in the entry point
   // interface are considered live and are not eliminated.
-  // |preserve_interface| should be true if HLSL is generated
-  // from the SPIR-V bytecode.
   Optimizer& RegisterPerformancePasses();
   Optimizer& RegisterPerformancePasses(bool preserve_interface);
 
@@ -111,8 +109,6 @@ class Optimizer {
   //
   // If |preserve_interface| is true, all non-io variables in the entry point
   // interface are considered live and are not eliminated.
-  // |preserve_interface| should be true if HLSL is generated
-  // from the SPIR-V bytecode.
   Optimizer& RegisterSizePasses();
   Optimizer& RegisterSizePasses(bool preserve_interface);
 
@@ -127,8 +123,6 @@ class Optimizer {
   //
   // If |preserve_interface| is true, all non-io variables in the entry point
   // interface are considered live and are not eliminated.
-  // |preserve_interface| should be true if HLSL is generated
-  // from the SPIR-V bytecode.
   Optimizer& RegisterLegalizationPasses();
   Optimizer& RegisterLegalizationPasses(bool preserve_interface);
 
@@ -139,8 +133,13 @@ class Optimizer {
   // error message is emitted to the MessageConsumer object (use
   // Optimizer::SetMessageConsumer to define a message consumer, if needed).
   //
+  // If |preserve_interface| is true, all non-io variables in the entry point
+  // interface are considered live and are not eliminated.
+  //
   // If all the passes are registered successfully, it returns true.
   bool RegisterPassesFromFlags(const std::vector<std::string>& flags);
+  bool RegisterPassesFromFlags(const std::vector<std::string>& flags,
+                               bool preserve_interface);
 
   // Registers the optimization pass associated with |flag|.  This only accepts
   // |flag| values of the form "--pass_name[=pass_args]".  If no such pass
@@ -157,7 +156,11 @@ class Optimizer {
   //
   // --legalize-hlsl: Registers all passes that legalize SPIR-V generated by an
   //                  HLSL front-end.
+  //
+  // If |preserve_interface| is true, all non-io variables in the entry point
+  // interface are considered live and are not eliminated.
   bool RegisterPassFromFlag(const std::string& flag);
+  bool RegisterPassFromFlag(const std::string& flag, bool preserve_interface);
 
   // Validates that |flag| has a valid format.  Strings accepted:
   //

3rdparty/spirv-tools/source/opt/optimizer.cpp

@@ -33,6 +33,15 @@
 
 namespace spvtools {
 
+std::vector<std::string> GetVectorOfStrings(const char** strings,
+                                            const size_t string_count) {
+  std::vector<std::string> result;
+  for (uint32_t i = 0; i < string_count; i++) {
+    result.emplace_back(strings[i]);
+  }
+  return result;
+}
+
 struct Optimizer::PassToken::Impl {
   Impl(std::unique_ptr<opt::Pass> p) : pass(std::move(p)) {}
 
@@ -256,8 +265,13 @@ Optimizer& Optimizer::RegisterSizePasses(bool preserve_interface) {
 Optimizer& Optimizer::RegisterSizePasses() { return RegisterSizePasses(false); }
 
 bool Optimizer::RegisterPassesFromFlags(const std::vector<std::string>& flags) {
+  return RegisterPassesFromFlags(flags, false);
+}
+
+bool Optimizer::RegisterPassesFromFlags(const std::vector<std::string>& flags,
+                                        bool preserve_interface) {
   for (const auto& flag : flags) {
-    if (!RegisterPassFromFlag(flag)) {
+    if (!RegisterPassFromFlag(flag, preserve_interface)) {
       return false;
     }
   }
@@ -281,6 +295,11 @@ bool Optimizer::FlagHasValidForm(const std::string& flag) const {
 }
 
 bool Optimizer::RegisterPassFromFlag(const std::string& flag) {
+  return RegisterPassFromFlag(flag, false);
+}
+
+bool Optimizer::RegisterPassFromFlag(const std::string& flag,
+                                     bool preserve_interface) {
   if (!FlagHasValidForm(flag)) {
     return false;
   }
@@ -342,7 +361,7 @@ bool Optimizer::RegisterPassFromFlag(const std::string& flag) {
   } else if (pass_name == "descriptor-scalar-replacement") {
     RegisterPass(CreateDescriptorScalarReplacementPass());
   } else if (pass_name == "eliminate-dead-code-aggressive") {
-    RegisterPass(CreateAggressiveDCEPass());
+    RegisterPass(CreateAggressiveDCEPass(preserve_interface));
   } else if (pass_name == "eliminate-insert-extract") {
     RegisterPass(CreateInsertExtractElimPass());
   } else if (pass_name == "eliminate-local-single-block") {
@@ -513,11 +532,11 @@ bool Optimizer::RegisterPassFromFlag(const std::string& flag) {
   } else if (pass_name == "fix-storage-class") {
     RegisterPass(CreateFixStorageClassPass());
   } else if (pass_name == "O") {
-    RegisterPerformancePasses();
+    RegisterPerformancePasses(preserve_interface);
   } else if (pass_name == "Os") {
-    RegisterSizePasses();
+    RegisterSizePasses(preserve_interface);
   } else if (pass_name == "legalize-hlsl") {
-    RegisterLegalizationPasses();
+    RegisterLegalizationPasses(preserve_interface);
   } else if (pass_name == "remove-unused-interface-variables") {
     RegisterPass(CreateRemoveUnusedInterfaceVariablesPass());
   } else if (pass_name == "graphics-robust-access") {
@@ -1170,13 +1189,19 @@ SPIRV_TOOLS_EXPORT bool spvOptimizerRegisterPassFromFlag(
 
 SPIRV_TOOLS_EXPORT bool spvOptimizerRegisterPassesFromFlags(
     spv_optimizer_t* optimizer, const char** flags, const size_t flag_count) {
-  std::vector<std::string> opt_flags;
-  for (uint32_t i = 0; i < flag_count; i++) {
-    opt_flags.emplace_back(flags[i]);
-  }
+  std::vector<std::string> opt_flags =
+      spvtools::GetVectorOfStrings(flags, flag_count);
+  return reinterpret_cast<spvtools::Optimizer*>(optimizer)
+      ->RegisterPassesFromFlags(opt_flags, false);
+}
 
-  return reinterpret_cast<spvtools::Optimizer*>(optimizer)->
-      RegisterPassesFromFlags(opt_flags);
+SPIRV_TOOLS_EXPORT bool
+spvOptimizerRegisterPassesFromFlagsWhilePreservingTheInterface(
+    spv_optimizer_t* optimizer, const char** flags, const size_t flag_count) {
+  std::vector<std::string> opt_flags =
+      spvtools::GetVectorOfStrings(flags, flag_count);
+  return reinterpret_cast<spvtools::Optimizer*>(optimizer)
+      ->RegisterPassesFromFlags(opt_flags, true);
 }
 
 SPIRV_TOOLS_EXPORT

3rdparty/spirv-tools/source/opt/trim_capabilities_pass.cpp

@@ -137,6 +137,16 @@ static bool Has16BitCapability(const FeatureManager* feature_manager) {
 // Handler names follow the following convention:
 //  Handler_<Opcode>_<Capability>()
 
+static std::optional<spv::Capability> Handler_OpTypeFloat_Float16(
+    const Instruction* instruction) {
+  assert(instruction->opcode() == spv::Op::OpTypeFloat &&
+         "This handler only support OpTypeFloat opcodes.");
+
+  const uint32_t size =
+      instruction->GetSingleWordInOperand(kOpTypeFloatSizeIndex);
+  return size == 16 ? std::optional(spv::Capability::Float16) : std::nullopt;
+}
+
 static std::optional<spv::Capability> Handler_OpTypeFloat_Float64(
     const Instruction* instruction) {
   assert(instruction->opcode() == spv::Op::OpTypeFloat &&
@@ -274,6 +284,16 @@ static std::optional<spv::Capability> Handler_OpTypePointer_StorageUniform16(
                         : std::nullopt;
 }
 
+static std::optional<spv::Capability> Handler_OpTypeInt_Int16(
+    const Instruction* instruction) {
+  assert(instruction->opcode() == spv::Op::OpTypeInt &&
+         "This handler only support OpTypeInt opcodes.");
+
+  const uint32_t size =
+      instruction->GetSingleWordInOperand(kOpTypeIntSizeIndex);
+  return size == 16 ? std::optional(spv::Capability::Int16) : std::nullopt;
+}
+
 static std::optional<spv::Capability> Handler_OpTypeInt_Int64(
     const Instruction* instruction) {
   assert(instruction->opcode() == spv::Op::OpTypeInt &&
@@ -341,12 +361,14 @@ Handler_OpImageSparseRead_StorageImageReadWithoutFormat(
 }
 
 // Opcode of interest to determine capabilities requirements.
-constexpr std::array<std::pair<spv::Op, OpcodeHandler>, 10> kOpcodeHandlers{{
+constexpr std::array<std::pair<spv::Op, OpcodeHandler>, 12> kOpcodeHandlers{{
     // clang-format off
     {spv::Op::OpImageRead,         Handler_OpImageRead_StorageImageReadWithoutFormat},
     {spv::Op::OpImageSparseRead,   Handler_OpImageSparseRead_StorageImageReadWithoutFormat},
+    {spv::Op::OpTypeFloat,         Handler_OpTypeFloat_Float16 },
     {spv::Op::OpTypeFloat,         Handler_OpTypeFloat_Float64 },
     {spv::Op::OpTypeImage,         Handler_OpTypeImage_ImageMSArray},
+    {spv::Op::OpTypeInt,           Handler_OpTypeInt_Int16 },
     {spv::Op::OpTypeInt,           Handler_OpTypeInt_Int64 },
     {spv::Op::OpTypePointer,       Handler_OpTypePointer_StorageInputOutput16},
     {spv::Op::OpTypePointer,       Handler_OpTypePointer_StoragePushConstant16},

3rdparty/spirv-tools/source/opt/trim_capabilities_pass.h

@@ -76,12 +76,14 @@ class TrimCapabilitiesPass : public Pass {
       // clang-format off
       spv::Capability::ComputeDerivativeGroupLinearNV,
       spv::Capability::ComputeDerivativeGroupQuadsNV,
+      spv::Capability::Float16,
       spv::Capability::Float64,
       spv::Capability::FragmentShaderPixelInterlockEXT,
       spv::Capability::FragmentShaderSampleInterlockEXT,
       spv::Capability::FragmentShaderShadingRateInterlockEXT,
       spv::Capability::Groups,
       spv::Capability::ImageMSArray,
+      spv::Capability::Int16,
       spv::Capability::Int64,
       spv::Capability::Linkage,
       spv::Capability::MinLod,