Add the missing tests and fix formatting errors

Author: yavn

source/opt/type_manager.cpp

@@ -337,6 +337,17 @@ uint32_t TypeManager::GetTypeInstruction(const Type* type) {
           std::initializer_list<Operand>{{SPV_OPERAND_TYPE_ID, {subtype}}});
       break;
     }
+    case Type::kNodePayloadArrayAMDX: {
+      uint32_t subtype =
+          GetTypeInstruction(type->AsNodePayloadArrayAMDX()->element_type());
+      if (subtype == 0) {
+        return 0;
+      }
+      typeInst = MakeUnique<Instruction>(
+          context(), spv::Op::OpTypeNodePayloadArrayAMDX, 0, id,
+          std::initializer_list<Operand>{{SPV_OPERAND_TYPE_ID, {subtype}}});
+      break;
+    }
     case Type::kStruct: {
       std::vector<Operand> ops;
       const Struct* structTy = type->AsStruct();
@@ -603,6 +614,13 @@ Type* TypeManager::RebuildType(uint32_t type_id, const Type& type) {
           MakeUnique<RuntimeArray>(RebuildType(GetId(ele_ty), *ele_ty));
       break;
     }
+    case Type::kNodePayloadArrayAMDX: {
+      const NodePayloadArrayAMDX* array_ty = type.AsNodePayloadArrayAMDX();
+      const Type* ele_ty = array_ty->element_type();
+      rebuilt_ty =
+          MakeUnique<NodePayloadArrayAMDX>(RebuildType(GetId(ele_ty), *ele_ty));
+      break;
+    }
     case Type::kStruct: {
       const Struct* struct_ty = type.AsStruct();
       std::vector<const Type*> subtypes;
@@ -806,7 +824,7 @@ Type* TypeManager::RecordIfTypeDefinition(const Instruction& inst) {
       }
       break;
     case spv::Op::OpTypeNodePayloadArrayAMDX:
-      type = new NodePayloadArray(GetType(inst.GetSingleWordInOperand(0)));
+      type = new NodePayloadArrayAMDX(GetType(inst.GetSingleWordInOperand(0)));
       if (id_to_incomplete_type_.count(inst.GetSingleWordInOperand(0))) {
         incomplete_types_.emplace_back(inst.result_id(), type);
         id_to_incomplete_type_[inst.result_id()] = type;

source/opt/types.cpp

@@ -92,7 +92,7 @@ bool Type::IsUniqueType() const {
     case kStruct:
     case kArray:
     case kRuntimeArray:
-    case kNodePayloadArray:
+    case kNodePayloadArrayAMDX:
       return false;
     default:
       return true;
@@ -165,6 +165,7 @@ bool Type::operator==(const Type& other) const {
     DeclareKindCase(SampledImage);
     DeclareKindCase(Array);
     DeclareKindCase(RuntimeArray);
+    DeclareKindCase(NodePayloadArrayAMDX);
     DeclareKindCase(Struct);
     DeclareKindCase(Opaque);
     DeclareKindCase(Pointer);
@@ -221,7 +222,7 @@ size_t Type::ComputeHashValue(size_t hash, SeenTypes* seen) const {
     DeclareKindCase(SampledImage);
     DeclareKindCase(Array);
     DeclareKindCase(RuntimeArray);
-    DeclareKindCase(NodePayloadArray);
+    DeclareKindCase(NodePayloadArrayAMDX);
     DeclareKindCase(Struct);
     DeclareKindCase(Opaque);
     DeclareKindCase(Pointer);
@@ -489,29 +490,31 @@ void RuntimeArray::ReplaceElementType(const Type* type) {
   element_type_ = type;
 }
 
-NodePayloadArray::NodePayloadArray(const Type* type)
-    : Type(kNodePayloadArray), element_type_(type) {
+NodePayloadArrayAMDX::NodePayloadArrayAMDX(const Type* type)
+    : Type(kNodePayloadArrayAMDX), element_type_(type) {
   assert(!type->AsVoid());
 }
 
-bool NodePayloadArray::IsSameImpl(const Type* that, IsSameCache* seen) const {
-  const NodePayloadArray* rat = that->AsNodePayloadArray();
+bool NodePayloadArrayAMDX::IsSameImpl(const Type* that,
+                                      IsSameCache* seen) const {
+  const NodePayloadArrayAMDX* rat = that->AsNodePayloadArrayAMDX();
   if (!rat) return false;
   return element_type_->IsSameImpl(rat->element_type_, seen) &&
          HasSameDecorations(that);
 }
 
-std::string NodePayloadArray::str() const {
+std::string NodePayloadArrayAMDX::str() const {
   std::ostringstream oss;
   oss << "[" << element_type_->str() << "]";
   return oss.str();
 }
 
-size_t NodePayloadArray::ComputeExtraStateHash(size_t hash, SeenTypes* seen) const {
+size_t NodePayloadArrayAMDX::ComputeExtraStateHash(size_t hash,
+                                                   SeenTypes* seen) const {
   return element_type_->ComputeHashValue(hash, seen);
 }
 
-void NodePayloadArray::ReplaceElementType(const Type* type) {
+void NodePayloadArrayAMDX::ReplaceElementType(const Type* type) {
   element_type_ = type;
 }
 

source/opt/types.h

@@ -48,7 +48,7 @@ class Sampler;
 class SampledImage;
 class Array;
 class RuntimeArray;
-class NodePayloadArray;
+class NodePayloadArrayAMDX;
 class Struct;
 class Opaque;
 class Pointer;
@@ -90,7 +90,7 @@ class Type {
     kSampledImage,
     kArray,
     kRuntimeArray,
-    kNodePayloadArray,
+    kNodePayloadArrayAMDX,
     kStruct,
     kOpaque,
     kPointer,
@@ -193,7 +193,7 @@ class Type {
   DeclareCastMethod(SampledImage)
   DeclareCastMethod(Array)
   DeclareCastMethod(RuntimeArray)
-  DeclareCastMethod(NodePayloadArray)
+  DeclareCastMethod(NodePayloadArrayAMDX)
   DeclareCastMethod(Struct)
   DeclareCastMethod(Opaque)
   DeclareCastMethod(Pointer)
@@ -439,16 +439,18 @@ class RuntimeArray : public Type {
   const Type* element_type_;
 };
 
-class NodePayloadArray : public Type {
+class NodePayloadArrayAMDX : public Type {
  public:
-  NodePayloadArray(const Type* element_type);
-  NodePayloadArray(const NodePayloadArray&) = default;
+  NodePayloadArrayAMDX(const Type* element_type);
+  NodePayloadArrayAMDX(const NodePayloadArrayAMDX&) = default;
 
   std::string str() const override;
   const Type* element_type() const { return element_type_; }
 
-  NodePayloadArray* AsNodePayloadArray() override { return this; }
-  const NodePayloadArray* AsNodePayloadArray() const override { return this; }
+  NodePayloadArrayAMDX* AsNodePayloadArrayAMDX() override { return this; }
+  const NodePayloadArrayAMDX* AsNodePayloadArrayAMDX() const override {
+    return this;
+  }
 
   size_t ComputeExtraStateHash(size_t hash, SeenTypes* seen) const override;
 

test/opt/type_manager_test.cpp

@@ -1,4 +1,6 @@
 // Copyright (c) 2016 Google Inc.
+// Modifications Copyright (C) 2024 Advanced Micro Devices, Inc. All rights
+// reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -175,6 +177,10 @@ std::vector<std::unique_ptr<Type>> GenerateAllTypes() {
   types.emplace_back(new RayQueryKHR());
   types.emplace_back(new HitObjectNV());
 
+  // NodePayloadArrayAMDX (SPV_AMDX_shader_enqueue)
+  types.emplace_back(
+      new NodePayloadArrayAMDX(new Struct(std::vector<const Type*>{s32})));
+
   return types;
 }
 

test/val/val_id_test.cpp

@@ -1,4 +1,6 @@
 // Copyright (c) 2015-2016 The Khronos Group Inc.
+// Modifications Copyright (C) 2024 Advanced Micro Devices, Inc. All rights
+// reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -2469,7 +2471,8 @@ OpFunctionEnd
           "be used with non-externally visible shader Storage Classes: "
           "Workgroup, CrossWorkgroup, Private, Function, Input, Output, "
           "RayPayloadKHR, IncomingRayPayloadKHR, HitAttributeKHR, "
-          "CallableDataKHR, IncomingCallableDataKHR, or UniformConstant")));
+          "CallableDataKHR, IncomingCallableDataKHR, NodePayloadAMDX, or "
+          "UniformConstant")));
 }
 
 TEST_P(ValidateIdWithMessage, OpVariableContainsBoolPrivateGood) {