SPV_QCOM_tile_shading

wooyoungqcom · wooyoungqcom · commit 2c0ba22f5c2e · 2025-05-06T08:51:12.000-07:00
diff --git a/source/val/validate_annotation.cpp b/source/val/validate_annotation.cpp
@@ -233,7 +233,8 @@ spv_result_t ValidateDecorationTarget(ValidationState_t& _, spv::Decoration dec,
       case spv::Decoration::DescriptorSet:
         if (sc != spv::StorageClass::StorageBuffer &&
             sc != spv::StorageClass::Uniform &&
-            sc != spv::StorageClass::UniformConstant) {
+            sc != spv::StorageClass::UniformConstant &&
+            sc != spv::StorageClass::TileAttachmentQCOM) {
           return fail(6491) << "must be in the StorageBuffer, Uniform, or "
                                "UniformConstant storage class";
         }
diff --git a/source/val/validate_decorations.cpp b/source/val/validate_decorations.cpp
@@ -404,8 +404,7 @@ bool IsAlignedTo(uint32_t offset, uint32_t alignment) {
 // or row major-ness.
 spv_result_t checkLayout(uint32_t struct_id, const char* storage_class_str,
                          const char* decoration_str, bool blockRules,
-                         bool scalar_block_layout,
-                         uint32_t incoming_offset,
+                         bool scalar_block_layout, uint32_t incoming_offset,
                          MemberConstraints& constraints,
                          ValidationState_t& vstate) {
   if (vstate.options()->skip_block_layout) return SPV_SUCCESS;
@@ -1023,7 +1022,7 @@ spv_result_t CheckDecorationsOfEntryPoints(ValidationState_t& vstate) {
         }
         if (num_workgroup_variables_with_block > 1 &&
             num_workgroup_variables_with_block !=
-            num_workgroup_variables_with_aliased) {
+                num_workgroup_variables_with_aliased) {
           return vstate.diag(SPV_ERROR_INVALID_BINARY,
                              vstate.FindDef(entry_point))
                  << "When declaring WorkgroupMemoryExplicitLayoutKHR, "
@@ -1246,10 +1245,10 @@ spv_result_t CheckDecorationsOfBuffers(ValidationState_t& vstate) {
         }
         // Prepare for messages
         const char* sc_str =
-            uniform ? "Uniform"
-                    : (push_constant ? "PushConstant"
-                                     : (workgroup ? "Workgroup"
-                                                  : "StorageBuffer"));
+            uniform
+                ? "Uniform"
+                : (push_constant ? "PushConstant"
+                                 : (workgroup ? "Workgroup" : "StorageBuffer"));
 
         if (spvIsVulkanEnv(vstate.context()->target_env)) {
           const bool block = hasDecoration(id, spv::Decoration::Block, vstate);
@@ -1765,6 +1764,7 @@ spv_result_t CheckNonWritableDecoration(ValidationState_t& vstate,
          var_storage_class == spv::StorageClass::Private) &&
         vstate.features().nonwritable_var_in_function_or_private) {
       // New permitted feature in SPIR-V 1.4.
+    } else if (var_storage_class == spv::StorageClass::TileAttachmentQCOM) {
     } else if (
         // It may point to a UBO, SSBO, storage image, or raw access chain.
         vstate.IsPointerToUniformBlock(type_id) ||
@@ -2030,7 +2030,8 @@ spv_result_t CheckRelaxPrecisionDecoration(ValidationState_t& vstate,
   {                                             \
     spv_result_t e##LINE = (X);                 \
     if (e##LINE != SPV_SUCCESS) return e##LINE; \
-  } static_assert(true, "require extra semicolon")
+  }                                             \
+  static_assert(true, "require extra semicolon")
 #define PASS_OR_BAIL(X) PASS_OR_BAIL_AT_LINE(X, __LINE__)
 
 // Check rules for decorations where we start from the decoration rather
diff --git a/source/val/validate_memory.cpp b/source/val/validate_memory.cpp
@@ -937,6 +937,65 @@ spv_result_t ValidateVariable(ValidationState_t& _, const Instruction* inst) {
     }
   }
 
+  if (_.HasCapability(spv::Capability::TileShadingQCOM) &&
+      storage_class == spv::StorageClass::TileAttachmentQCOM) {
+    if (result_type->opcode() == spv::Op::OpTypePointer) {
+      const auto pointee_type =
+          _.FindDef(result_type->GetOperandAs<uint32_t>(2));
+      if (pointee_type && pointee_type->opcode() == spv::Op::OpTypeImage) {
+        spv::Dim dim = static_cast<spv::Dim>(pointee_type->word(3));
+        if (dim != spv::Dim::Dim2D) {
+          return _.diag(SPV_ERROR_INVALID_DATA, inst)
+                 << "Any OpTypeImage variable in the TileAttachmentQCOM "
+                    "Storage Class must "
+                    "have 2D as its dimension";
+        }
+        unsigned sampled = pointee_type->word(7);
+        if (sampled != 1 && sampled != 2) {
+          return _.diag(SPV_ERROR_INVALID_DATA, inst)
+                 << "Any OpyTpeImage variable in the TileAttachmentQCOM "
+                    "Storage Class must "
+                    "have 1 or 2 as Image 'Sampled' parameter";
+        }
+        for (const auto& pair_o : inst->uses()) {
+          const auto* use_inst_o = pair_o.first;
+          if (use_inst_o->opcode() == spv::Op::OpLoad) {
+            for (const auto& pair_i : use_inst_o->uses()) {
+              const auto* use_inst_i = pair_i.first;
+              switch (use_inst_i->opcode()) {
+                case spv::Op::OpImageQueryFormat:
+                case spv::Op::OpImageQueryOrder:
+                case spv::Op::OpImageQuerySizeLod:
+                case spv::Op::OpImageQuerySize:
+                case spv::Op::OpImageQueryLod:
+                case spv::Op::OpImageQueryLevels:
+                case spv::Op::OpImageQuerySamples:
+                  return _.diag(SPV_ERROR_INVALID_DATA, inst)
+                         << "Any variable in the TileAttachmentQCOM Storage "
+                            "Class must "
+                            "not be consumed by an OpImageQuery* instruction";
+                default:
+                  break;
+              }
+            }
+          }
+        }
+      }
+    }
+
+    if (!(_.HasDecoration(inst->id(), spv::Decoration::DescriptorSet) &&
+          _.HasDecoration(inst->id(), spv::Decoration::Binding))) {
+      return _.diag(SPV_ERROR_INVALID_ID, inst)
+             << "Any variable in the TileAttachmentQCOM Storage Class must "
+                "be decorated with DescriptorSet and Binding";
+    }
+    if (_.HasDecoration(inst->id(), spv::Decoration::Component)) {
+      return _.diag(SPV_ERROR_INVALID_ID, inst)
+             << "Any variable in the TileAttachmentQCOM Storage Class must "
+                "not be decorated with Component decoration";
+    }
+  }
+
   return SPV_SUCCESS;
 }
 
diff --git a/source/val/validate_mode_setting.cpp b/source/val/validate_mode_setting.cpp
@@ -311,17 +311,82 @@ spv_result_t ValidateEntryPoint(ValidationState_t& _, const Instruction* inst) {
               }
             }
           }
+          if (!ok && _.HasCapability(spv::Capability::TileShadingQCOM)) {
+            ok =
+                execution_modes &&
+                execution_modes->count(spv::ExecutionMode::TileShadingRateQCOM);
+          }
           if (!ok) {
             return _.diag(SPV_ERROR_INVALID_DATA, inst)
                    << _.VkErrorID(6426)
                    << "In the Vulkan environment, GLCompute execution model "
-                      "entry points require either the LocalSize or "
-                      "LocalSizeId execution mode or an object decorated with "
-                      "WorkgroupSize must be specified.";
+                      "entry points require either the "
+                   << (_.HasCapability(spv::Capability::TileShadingQCOM)
+                           ? "TileShadingRateQCOM, "
+                           : "")
+                   << "LocalSize or LocalSizeId execution mode or an object "
+                      "decorated with WorkgroupSize must be specified.";
+          }
+        }
+
+        if (_.HasCapability(spv::Capability::TileShadingQCOM)) {
+          if (execution_modes) {
+            if (execution_modes->count(
+                    spv::ExecutionMode::TileShadingRateQCOM) &&
+                (execution_modes->count(spv::ExecutionMode::LocalSize) ||
+                 execution_modes->count(spv::ExecutionMode::LocalSizeId))) {
+              return _.diag(SPV_ERROR_INVALID_DATA, inst)
+                     << "If the TileShadingRateQCOM execution mode is used, "
+                     << "LocalSize and LocalSizeId must not be specified.";
+            }
+            if (execution_modes->count(
+                    spv::ExecutionMode::NonCoherentTileAttachmentReadQCOM)) {
+              return _.diag(SPV_ERROR_INVALID_DATA, inst)
+                     << "The NonCoherentTileAttachmentQCOM execution mode must "
+                        "not be used in any stage other than fragment.";
+            }
+          }
+        } else {
+          if (execution_modes &&
+              execution_modes->count(spv::ExecutionMode::TileShadingRateQCOM)) {
+            return _.diag(SPV_ERROR_INVALID_DATA, inst)
+                   << "If the TileShadingRateQCOM execution mode is used, the "
+                      "TileShadingQCOM capability must be enabled.";
           }
         }
         break;
       default:
+        if (execution_modes &&
+            execution_modes->count(spv::ExecutionMode::TileShadingRateQCOM)) {
+          return _.diag(SPV_ERROR_INVALID_DATA, inst)
+                 << "The TileShadingRateQCOM execution mode must not be used "
+                    "in any stage other than compute.";
+        }
+        if (execution_model != spv::ExecutionModel::Fragment) {
+          if (execution_modes &&
+              execution_modes->count(
+                  spv::ExecutionMode::NonCoherentTileAttachmentReadQCOM)) {
+            return _.diag(SPV_ERROR_INVALID_DATA, inst)
+                   << "The NonCoherentTileAttachmentQCOM execution mode must "
+                      "not be used in any stage other than fragment.";
+          }
+          if (_.HasCapability(spv::Capability::TileShadingQCOM)) {
+            return _.diag(SPV_ERROR_INVALID_CAPABILITY, inst)
+                   << "The TileShadingQCOM capability must not be enabled in "
+                      "any stage other than compute or fragment.";
+          }
+        } else {
+          if (execution_modes &&
+              execution_modes->count(
+                  spv::ExecutionMode::NonCoherentTileAttachmentReadQCOM)) {
+            if (!_.HasCapability(spv::Capability::TileShadingQCOM)) {
+              return _.diag(SPV_ERROR_INVALID_DATA, inst)
+                     << "If the NonCoherentTileAttachmentReadQCOM execution "
+                        "mode is used, the TileShadingQCOM capability must be "
+                        "enabled.";
+            }
+          }
+        }
         break;
     }
   }
@@ -758,6 +823,14 @@ spv_result_t ValidateExecutionMode(ValidationState_t& _,
              << "In the Vulkan environment, the PixelCenterInteger execution "
                 "mode must not be used.";
     }
+    if (mode == spv::ExecutionMode::TileShadingRateQCOM) {
+      const auto rateX = inst->GetOperandAs<int>(2);
+      const auto rateY = inst->GetOperandAs<int>(3);
+      if ((rateX & (rateX - 1)) != 0 || (rateY & (rateY - 1)) != 0)
+        return _.diag(SPV_ERROR_INVALID_DATA, inst)
+               << "The TileShadingRateQCOM execution mode's x and y values "
+                  "must be powers of 2.";
+    }
   }
 
   return SPV_SUCCESS;
@@ -927,7 +1000,7 @@ spv_result_t ValidateDuplicateExecutionModes(ValidationState_t& _) {
   std::set<PerOperandKey> seen_per_operand;
 
   const auto lookupMode = [](spv::ExecutionMode mode) -> std::string {
-    const spvtools::OperandDesc* desc = nullptr;
+    spvtools::OperandDesc* desc = nullptr;
     if (spvtools::LookupOperand(SPV_OPERAND_TYPE_EXECUTION_MODE,
                                 static_cast<uint32_t>(mode),
                                 &desc) == SPV_SUCCESS) {
diff --git a/source/val/validation_state.cpp b/source/val/validation_state.cpp
@@ -368,7 +368,7 @@ void ValidationState_t::RegisterCapability(spv::Capability cap) {
   if (module_capabilities_.contains(cap)) return;
 
   module_capabilities_.insert(cap);
-  const spvtools::OperandDesc* desc = nullptr;
+  spvtools::OperandDesc* desc = nullptr;
   if (SPV_SUCCESS == spvtools::LookupOperand(SPV_OPERAND_TYPE_CAPABILITY,
                                              uint32_t(cap), &desc)) {
     for (auto capability : CapabilitySet(desc->capabilities_range.count(),
@@ -1883,6 +1883,7 @@ bool ValidationState_t::IsValidStorageClass(
       case spv::StorageClass::HitObjectAttributeNV:
       case spv::StorageClass::TileImageEXT:
       case spv::StorageClass::NodePayloadAMDX:
+      case spv::StorageClass::TileAttachmentQCOM:
         return true;
       default:
         return false;
diff --git a/test/val/val_capability_test.cpp b/test/val/val_capability_test.cpp
@@ -2375,7 +2375,7 @@ spv_result_t spvCoreOperandTableNameLookup(spv_target_env env,
                                            const size_t nameLength) {
   if (!name) return SPV_ERROR_INVALID_POINTER;
 
-  const spvtools::OperandDesc* entry = nullptr;
+  spvtools::OperandDesc* entry = nullptr;
   if (SPV_SUCCESS == spvtools::LookupOperand(type, name, nameLength, &entry)) {
     // Check for min version only.
     if (spvVersionForTargetEnv(env) >= entry->minVersion) {
@@ -3214,7 +3214,8 @@ std::string MinimalShaderModuleWithCapability(std::string cap) {
                               : "";
   return std::string("OpCapability ") + cap + extra_cap + R"(
 OpCapability Shader
-OpMemoryModel Logical )" + mem_model + R"(
+OpMemoryModel Logical )" +
+         mem_model + R"(
 OpEntryPoint Vertex %main "main"
 %void = OpTypeVoid
 %void_fn = OpTypeFunction %void
@@ -3383,6 +3384,23 @@ OpMemoryModel Logical GLSL450
           "the VulkanMemoryModel capability must also be declared"));
 }
 
+TEST_F(ValidateCapability, TileShadingQCOM) {
+  const auto spirv = R"(
+OpCapability Shader
+OpCapability TileShadingQCOM
+OpExtension "SPV_QCOM_tile_shading"
+OpMemoryModel Logical GLSL450
+OpEntryPoint Vertex %func "main"
+)" + std::string(kVoidFVoid);
+
+  spv_target_env env = SPV_ENV_VULKAN_1_4;
+  CompileSuccessfully(spirv, env);
+  EXPECT_THAT(SPV_ERROR_INVALID_CAPABILITY, ValidateInstructions(env));
+  EXPECT_THAT(getDiagnosticString(),
+              HasSubstr("The TileShadingQCOM capability must not be enabled "
+                        "in any stage other than compute or fragment"));
+}
+
 }  // namespace
 }  // namespace val
 }  // namespace spvtools
diff --git a/test/val/val_modes_test.cpp b/test/val/val_modes_test.cpp
diff --git a/test/val/val_storage_test.cpp b/test/val/val_storage_test.cpp
