Add support for QCOM tile shading

wooyoungqcom · wooyoungqcom · commit b383693fb97e · 2025-05-04T21:46:49.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);
@@ -2031,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
@@ -939,34 +939,46 @@ 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::OpTypeImage) {
-      spv::Dim dim = static_cast<spv::Dim>(inst->word(3));
-      if (dim != spv::Dim::Dim2D) {
-        return _.diag(SPV_ERROR_INVALID_DATA, inst)
-               << "Any OpTpeImage variable in the TileAttachmentQCOM Storage Class must "
-                  "have 2D as its dimension";
-      }
-      unsigned sampled = inst->word(7);
-      if (sampled != 1 && sampled != 2) {
-        return _.diag(SPV_ERROR_INVALID_DATA, inst)
-               << "Any OpTpeImage variable in the TileAttachmentQCOM Storage Class must "
-                  "have 1 or 2 as Image 'Sampled' parameter";
-      }
-      for (const auto& pair : inst->uses()) {
-        const auto* use_inst = pair.first;
-        switch (use_inst->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 (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;
+              }
+            }
+          }
         }
       }
     }
diff --git a/source/val/validate_mode_setting.cpp b/source/val/validate_mode_setting.cpp
@@ -286,15 +286,11 @@ spv_result_t ValidateEntryPoint(ValidationState_t& _, const Instruction* inst) {
   }
 
   if (spvIsVulkanEnv(_.context()->target_env)) {
-    bool ok = false;
-    bool foundLocalSizeId = false;
     switch (execution_model) {
       case spv::ExecutionModel::GLCompute:
-        if (_.HasCapability(spv::Capability::TileShadingQCOM)) {
-          ok = (execution_modes && execution_modes->count(spv::ExecutionMode::TileShadingRateQCOM));
-        }
-        if (!ok && (!execution_modes ||
-            !execution_modes->count(spv::ExecutionMode::LocalSize))) {
+        if (!execution_modes ||
+            !execution_modes->count(spv::ExecutionMode::LocalSize)) {
+          bool ok = false;
           for (auto& i : _.ordered_instructions()) {
             if (i.opcode() == spv::Op::OpDecorate) {
               if (i.operands().size() > 2) {
@@ -311,34 +307,86 @@ spv_result_t ValidateEntryPoint(ValidationState_t& _, const Instruction* inst) {
               const auto mode = i.GetOperandAs<spv::ExecutionMode>(1);
               if (mode == spv::ExecutionMode::LocalSizeId) {
                 ok = true;
-                foundLocalSizeId = true;
                 break;
               }
             }
           }
+          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 "
-                   << (_.HasCapability(spv::Capability::TileShadingQCOM) ? "TileShadingRateQCOM, " : "")
+                   << (_.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) || foundLocalSizeId)) {
+            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, "
+                     << "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;
     }
   }
@@ -775,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;
diff --git a/source/val/validation_state.cpp b/source/val/validation_state.cpp
@@ -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
@@ -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
