address comments

Author: V-FEXrt

include/dxc/DXIL/DxilConstants.h

@@ -155,6 +155,9 @@ const unsigned kMinWaveSize = 4;
 const unsigned kMaxWaveSize = 128;
 const unsigned kDefaultMaxVectorLength = 4;
 const unsigned kSM69MaxVectorLength = 1024;
+const unsigned kLinAlgThreadGroupMatrixMaxK = 1024;
+const unsigned kLinAlgWaveThreadMatrixMaxK = 128;
+const unsigned kLinAlgMatrixMinK = 4;
 
 const float kMaxMipLodBias = 15.99f;
 const float kMinMipLodBias = -16.0f;

lib/DxilValidation/DxilValidation.cpp

@@ -984,25 +984,25 @@ static void ValidateLinAlgOpParameters(CallInst *CI,
     if (isa<UndefValue>(Arg))
       ValCtx.EmitInstrError(CI, ValidationRule::InstrNoReadingUninitialized);
 
-    // If we have a LinAlg Matrix validate it
+    // If we have a LinAlg Matrix, validate that we have correct metadata.
     if (!dxilutil::IsHLSLLinAlgMatrixType(Ty))
       continue;
-
-    // Metadata is malformed if we don't have metadata
-    if (ValCtx.TargetTypeMap.find(Ty) == ValCtx.TargetTypeMap.end()) {
+    if (ValCtx.LinAlgTargetTypeMap.find(Ty) ==
+        ValCtx.LinAlgTargetTypeMap.end()) {
       ValCtx.EmitInstrError(CI, ValidationRule::MetaWellFormed);
       continue;
     }
   }
 }
 
-static void ValidateLinAlgOpReturn(CallInst *CI, ValidationContext &ValCtx) {
+static void ValidateLinAlgOpReturnMatrix(CallInst *CI,
+                                         ValidationContext &ValCtx) {
   Type *Ty = CI->getType();
   assert(dxilutil::IsHLSLLinAlgMatrixType(Ty) && "CI must return a matrix");
 
   // Metadata is malformed if we don't have metadata
-  auto it = ValCtx.TargetTypeMap.find(Ty);
-  if (it == ValCtx.TargetTypeMap.end()) {
+  auto it = ValCtx.LinAlgTargetTypeMap.find(Ty);
+  if (it == ValCtx.LinAlgTargetTypeMap.end()) {
     ValCtx.EmitInstrError(CI, ValidationRule::MetaWellFormed);
     return;
   }
@@ -1012,9 +1012,11 @@ static void ValidateLinAlgOpReturn(CallInst *CI, ValidationContext &ValCtx) {
   // Validate the K dim is in bounds. Which dim is K depends on use.
   // This validation isn't applied to an accumulator matrix
   if (LATT.Use != DXIL::MatrixUse::Accumulator) {
-    unsigned MinK = 4;
+    unsigned MinK = DXIL::kLinAlgMatrixMinK;
     unsigned K = (LATT.Use == DXIL::MatrixUse::A) ? LATT.N : LATT.M;
-    unsigned MaxK = (LATT.Scope == DXIL::MatrixScope::ThreadGroup) ? 1024 : 128;
+    unsigned MaxK = (LATT.Scope == DXIL::MatrixScope::ThreadGroup)
+                        ? DXIL::kLinAlgThreadGroupMatrixMaxK
+                        : DXIL::kLinAlgWaveThreadMatrixMaxK;
     if (K < MinK || K > MaxK)
       ValCtx.EmitInstrFormatError(
           CI, ValidationRule::InstrLinAlgIllegalKDim,
@@ -2250,7 +2252,7 @@ static void ValidateDxilOperationCallInProfile(CallInst *CI,
   case DXIL::OpCode::LinAlgMatrixAccumulate:
   case DXIL::OpCode::LinAlgMatrixMultiplyAccumulate:
   case DXIL::OpCode::LinAlgMatrixOuterProduct: {
-    ValidateLinAlgOpReturn(CI, ValCtx);
+    ValidateLinAlgOpReturnMatrix(CI, ValCtx);
     ValidateLinAlgOpParameters(CI, ValCtx);
     break;
   }

lib/DxilValidation/DxilValidationUtils.cpp

@@ -41,38 +41,35 @@ EntryStatus::EntryStatus(DxilEntryProps &entryProps)
       entryProps.sig.PatchConstOrPrimSignature.GetElements().size(), 0);
 }
 
-static std::optional<std::tuple<Type *, LinAlgTargetType>>
-TryMakeLinAlgTargetType(MDTuple *MDT) {
+static void
+TryAddLinAlgTargetType(MDTuple *MDT,
+                       std::unordered_map<Type *, LinAlgTargetType> &Map) {
   if (!MDT || MDT->getNumOperands() != 6)
-    return std::nullopt;
+    return;
 
   ConstantAsMetadata *ConstMD0 =
       dyn_cast<ConstantAsMetadata>(MDT->getOperand(0).get());
   if (!ConstMD0)
-    return std::nullopt;
+    return;
 
   Type *Ty = ConstMD0->getValue()->getType();
-  ConstantInt *Ints[5];
+  uint64_t Ints[5];
 
   for (size_t I = 0; I < 5; ++I) {
     ConstantAsMetadata *ConstMDI =
         dyn_cast<ConstantAsMetadata>(MDT->getOperand(I + 1).get());
     if (!ConstMDI)
-      return std::nullopt;
+      return;
     ConstantInt *CI = dyn_cast<ConstantInt>(ConstMDI->getValue());
     if (!CI)
-      return std::nullopt;
-    Ints[I] = CI;
+      return;
+    Ints[I] = CI->getLimitedValue();
   }
 
-  LinAlgTargetType LATT;
-  LATT.Type = static_cast<DXIL::ComponentType>(Ints[0]->getLimitedValue());
-  LATT.M = Ints[1]->getLimitedValue();
-  LATT.N = Ints[2]->getLimitedValue();
-  LATT.Use = static_cast<DXIL::MatrixUse>(Ints[3]->getLimitedValue());
-  LATT.Scope = static_cast<DXIL::MatrixScope>(Ints[4]->getLimitedValue());
-
-  return {{Ty, LATT}};
+  Map.try_emplace(
+      Ty, LinAlgTargetType{static_cast<DXIL::ComponentType>(Ints[0]), Ints[1],
+                           Ints[2], static_cast<DXIL::MatrixUse>(Ints[3]),
+                           static_cast<DXIL::MatrixScope>(Ints[4])});
 }
 
 ValidationContext::ValidationContext(Module &llvmModule, Module *DebugModule,
@@ -132,11 +129,7 @@ ValidationContext::ValidationContext(Module &llvmModule, Module *DebugModule,
   if (NMD) {
     for (llvm::MDNode *MDN : NMD->operands()) {
       MDTuple *MDT = dyn_cast<MDTuple>(MDN);
-      std::optional<std::tuple<Type *, LinAlgTargetType>> LATTOpt =
-          TryMakeLinAlgTargetType(MDT);
-      if (!LATTOpt)
-        continue;
-      TargetTypeMap.try_emplace(std::get<0>(*LATTOpt), std::get<1>(*LATTOpt));
+      TryAddLinAlgTargetType(MDT, LinAlgTargetTypeMap);
     }
   }
 }

lib/DxilValidation/DxilValidationUtils.h

@@ -36,7 +36,6 @@ class Value;
 class GlobalVariable;
 class Instruction;
 class Type;
-class MDTuple;
 } // namespace llvm
 
 namespace hlsl {
@@ -89,7 +88,7 @@ struct ValidationContext {
   std::unordered_map<Value *, DxilResourceProperties> ResPropMap;
   std::unordered_map<Function *, std::vector<Function *>> PatchConstantFuncMap;
   std::unordered_map<Function *, std::unique_ptr<EntryStatus>> entryStatusMap;
-  std::unordered_map<Type *, LinAlgTargetType> TargetTypeMap;
+  std::unordered_map<Type *, LinAlgTargetType> LinAlgTargetTypeMap;
   bool isLibProfile;
   const unsigned kDxilControlFlowHintMDKind;
   const unsigned kDxilPreciseMDKind;