Respond to feedback

Add setting for max vec size.

Determine long vector presence using DefinitionData bit?
OR
Rename testing for long vecs function?

Add attribute for geometry streams, produce and test errors for long vectors there.

Add and test errors for > 1024 element vectors.

Add vector size to error messages

good test changes

include/dxc/DXIL/DxilConstants.h

@@ -147,6 +147,8 @@ const unsigned kMaxMSTotalSigRows = 32;
 const unsigned kMaxMSSMSize = 1024 * 28;
 const unsigned kMinWaveSize = 4;
 const unsigned kMaxWaveSize = 128;
+const unsigned kDefaultMaxVectorLength = 4;
+const unsigned kSM69MaxVectorLength = 1024;
 
 const float kMaxMipLodBias = 15.99f;
 const float kMinMipLodBias = -16.0f;

tools/clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -7519,8 +7519,8 @@ def err_hlsl_half_load_store: Error<
   "LoadHalf and StoreHalf are not supported for min precision mode">;
 def err_hlsl_interfaces_cannot_inherit: Error<
   "interfaces cannot inherit from other types">;
-def err_hlsl_invalid_range_1_4: Error<
-  "invalid value, valid range is between 1 and 4 inclusive">;
+def err_hlsl_invalid_range_1_plus: Error<
+  "invalid value, valid range is between 1 and %0 inclusive">;
 def err_hlsl_matrix_member_bad_format: Error<
   "invalid format for matrix subscript '%0'">;
 def err_hlsl_matrix_member_empty: Error<
@@ -7852,7 +7852,9 @@ def err_hlsl_load_from_mesh_out_arrays: Error<
 def err_hlsl_out_indices_array_incorrect_access: Error<
    "a vector in out indices array must be accessed as a whole">;
 def err_hlsl_unsupported_long_vector: Error<
-   "Vectors of over 4 elements in %0 are not supported">;
+   "Vectors of over %0 elements in %1 are not supported">;
+def err_hlsl_vector_too_long: Error<
+   "Vectors of over %0 elements in are not supported">;
 def err_hlsl_logical_binop_scalar : Error<
    "operands for short-circuiting logical binary operator must be scalar, for non-scalar types use '%select{and|or}0'">;
 def err_hlsl_ternary_scalar : Error<

tools/clang/include/clang/Basic/LangOptions.h

@@ -15,7 +15,7 @@
 #ifndef LLVM_CLANG_BASIC_LANGOPTIONS_H
 #define LLVM_CLANG_BASIC_LANGOPTIONS_H
 
-#include "dxc/DXIL/DxilConstants.h" // For DXIL::DefaultLinkage
+#include "dxc/DXIL/DxilConstants.h" // For DXIL:: default values.
 #include "dxc/Support/HLSLVersion.h"
 #include "clang/Basic/CommentOptions.h"
 #include "clang/Basic/LLVM.h"
@@ -168,6 +168,7 @@ class LangOptions : public LangOptionsBase {
       hlsl::DXIL::DefaultLinkage::Default;
   /// Whether use row major as default matrix major.
   bool HLSLDefaultRowMajor = false;
+  unsigned MaxHLSLVectorLength = hlsl::DXIL::kDefaultMaxVectorLength;
   // HLSL Change Ends
 
   bool SPIRV = false;  // SPIRV Change

tools/clang/include/clang/Sema/SemaHLSL.h

@@ -128,7 +128,7 @@ unsigned CaculateInitListArraySizeForHLSL(clang::Sema *sema,
                                           const clang::InitListExpr *InitList,
                                           const clang::QualType EltTy);
 
-bool HasLongVecs(const clang::QualType &qt);
+bool ContainsVectorLongerThan(const clang::QualType &qt, unsigned length);
 
 bool IsConversionToLessOrEqualElements(clang::Sema *self,
                                        const clang::ExprResult &sourceExpr,

tools/clang/lib/Sema/SemaDXR.cpp

@@ -810,9 +810,10 @@ void DiagnoseTraceCall(Sema &S, const VarDecl *Payload,
     return;
   }
 
-  if (hlsl::HasLongVecs(Payload->getType())) {
+  if (hlsl::ContainsVectorLongerThan(Payload->getType(),
+                                     DXIL::kDefaultMaxVectorLength)) {
     S.Diag(Payload->getLocation(), diag::err_hlsl_unsupported_long_vector)
-        << "payload parameters";
+        << DXIL::kDefaultMaxVectorLength << "payload parameters";
     return;
   }
 

tools/clang/lib/Sema/SemaHLSL.cpp

@@ -5207,12 +5207,13 @@ class HLSLExternalSource : public ExternalSemaSource {
                                                 SourceLocation Loc);
 
   bool CheckRangedTemplateArgument(SourceLocation diagLoc,
-                                   llvm::APSInt &sintValue) {
-    const auto *SM =
-        hlsl::ShaderModel::GetByName(m_sema->getLangOpts().HLSLProfile.c_str());
+                                   llvm::APSInt &sintValue, bool IsVector) {
+    unsigned MaxLength = DXIL::kDefaultMaxVectorLength;
+    if (IsVector)
+      MaxLength = m_sema->getLangOpts().MaxHLSLVectorLength;
     if (!sintValue.isStrictlyPositive() ||
-        (sintValue.getLimitedValue() > 4 && !SM->IsSM69Plus())) {
-      m_sema->Diag(diagLoc, diag::err_hlsl_invalid_range_1_4);
+        sintValue.getLimitedValue() > MaxLength) {
+      m_sema->Diag(diagLoc, diag::err_hlsl_invalid_range_1_plus) << MaxLength;
       return true;
     }
 
@@ -5252,9 +5253,9 @@ class HLSLExternalSource : public ExternalSemaSource {
               << argType;
           return true;
         }
-        if (HasLongVecs(argType)) {
+        if (ContainsVectorLongerThan(argType, DXIL::kDefaultMaxVectorLength)) {
           m_sema->Diag(argSrcLoc, diag::err_hlsl_unsupported_long_vector)
-              << "cbuffers";
+              << DXIL::kDefaultMaxVectorLength << "cbuffers";
           return true;
         }
 
@@ -5349,10 +5350,10 @@ class HLSLExternalSource : public ExternalSemaSource {
       DXASSERT(arg.getKind() == TemplateArgument::ArgKind::Type,
                "Tessellation patch requires type template arg 0");
       QualType argType = arg.getAsType();
-      if (HasLongVecs(argType)) {
+      if (ContainsVectorLongerThan(argType, DXIL::kDefaultMaxVectorLength)) {
         m_sema->Diag(argLoc.getLocation(),
                      diag::err_hlsl_unsupported_long_vector)
-            << "tessellation patches";
+          << DXIL::kDefaultMaxVectorLength << "tessellation patches";
         return true;
       }
     } else if (Template->getTemplatedDecl()->hasAttr<HLSLStreamOutputAttr>()) {
@@ -5363,10 +5364,10 @@ class HLSLExternalSource : public ExternalSemaSource {
       DXASSERT(arg.getKind() == TemplateArgument::ArgKind::Type,
                "Geometry stream requires type template arg 0");
       QualType argType = arg.getAsType();
-      if (HasLongVecs(argType)) {
+      if (ContainsVectorLongerThan(argType, DXIL::kDefaultMaxVectorLength)) {
         m_sema->Diag(argLoc.getLocation(),
                      diag::err_hlsl_unsupported_long_vector)
-          << "geometry streams";
+          << DXIL::kDefaultMaxVectorLength << "geometry streams";
         return true;
       }
     }
@@ -5419,17 +5420,16 @@ class HLSLExternalSource : public ExternalSemaSource {
           llvm::APSInt constantResult;
           if (expr != nullptr &&
               expr->isIntegerConstantExpr(constantResult, *m_context)) {
-            if (CheckRangedTemplateArgument(argSrcLoc, constantResult)) {
+            if (CheckRangedTemplateArgument(argSrcLoc, constantResult,
+                                            isVector))
               return true;
-            }
           }
         }
       } else if (arg.getKind() == TemplateArgument::ArgKind::Integral) {
         if (isMatrix || isVector) {
           llvm::APSInt Val = arg.getAsIntegral();
-          if (CheckRangedTemplateArgument(argSrcLoc, Val)) {
+          if (CheckRangedTemplateArgument(argSrcLoc, Val, isVector))
             return true;
-          }
         }
       }
     }
@@ -11633,9 +11633,9 @@ bool hlsl::DiagnoseNodeStructArgument(Sema *self, TemplateArgumentLoc ArgLoc,
   ArTypeObjectKind shapeKind = source->GetTypeObjectKind(ArgTy);
   switch (shapeKind) {
   case AR_TOBJ_VECTOR:
-    if (GetHLSLVecSize(ArgTy) > 4) {
+    if (GetHLSLVecSize(ArgTy) > DXIL::kDefaultMaxVectorLength) {
       self->Diag(ArgLoc.getLocation(), diag::err_hlsl_unsupported_long_vector)
-          << "node records";
+          << DXIL::kDefaultMaxVectorLength << "node records";
       Empty = false;
       return false;
     }
@@ -12104,17 +12104,16 @@ bool hlsl::ShouldSkipNRVO(clang::Sema &sema, clang::QualType returnType,
   return false;
 }
 
-bool hlsl::HasLongVecs(const QualType &qt) {
-  if (qt.isNull()) {
+bool hlsl::ContainsVectorLongerThan(const QualType &qt, unsigned length) {
+  if (qt.isNull())
     return false;
-  }
 
   if (IsHLSLVecType(qt)) {
-    if (GetHLSLVecSize(qt) > 4)
+    if (GetHLSLVecSize(qt) > length)
       return true;
   } else if (qt->isArrayType()) {
     const ArrayType *arrayType = qt->getAsArrayTypeUnsafe();
-    return HasLongVecs(arrayType->getElementType());
+    return ContainsVectorLongerThan(arrayType->getElementType(), length);
   } else if (qt->isStructureOrClassType()) {
     const RecordType *recordType = qt->getAs<RecordType>();
     const RecordDecl *recordDecl = recordType->getDecl();
@@ -12124,7 +12123,7 @@ bool hlsl::HasLongVecs(const QualType &qt) {
     RecordDecl::field_iterator end = recordDecl->field_end();
     for (; begin != end; begin++) {
       const FieldDecl *fieldDecl = *begin;
-      if (HasLongVecs(fieldDecl->getType()))
+      if (ContainsVectorLongerThan(fieldDecl->getType(), length))
         return true;
     }
   }
@@ -14760,8 +14759,10 @@ bool Sema::DiagnoseHLSLDecl(Declarator &D, DeclContext *DC, Expr *BitWidth,
   }
 
   // Disallow long vecs from cbuffers.
-  if (isGlobal && !isStatic && !isGroupShared && HasLongVecs(qt)) {
-    Diag(D.getLocStart(), diag::err_hlsl_unsupported_long_vector) << "cbuffers";
+  if (isGlobal && !isStatic && !isGroupShared &&
+      ContainsVectorLongerThan(qt, DXIL::kDefaultMaxVectorLength)) {
+    Diag(D.getLocStart(), diag::err_hlsl_unsupported_long_vector)
+        << DXIL::kDefaultMaxVectorLength << "cbuffers";
     result = false;
   }
 
@@ -15655,9 +15656,9 @@ static bool isRelatedDeclMarkedNointerpolation(Expr *E) {
 
 // Verify that user-defined intrinsic struct args contain no long vectors
 static bool CheckUDTIntrinsicArg(Sema *S, Expr *Arg) {
-  if (HasLongVecs(Arg->getType())) {
+  if (ContainsVectorLongerThan(Arg->getType(), DXIL::kDefaultMaxVectorLength)) {
     S->Diag(Arg->getExprLoc(), diag::err_hlsl_unsupported_long_vector)
-        << "user-defined struct parameter";
+        << DXIL::kDefaultMaxVectorLength << "user-defined struct parameter";
     return true;
   }
   return false;
@@ -16396,13 +16397,15 @@ void DiagnoseEntry(Sema &S, FunctionDecl *FD) {
   // Check general parameter characteristics
   // Would be nice to check for resources here as they crash the compiler now.
   for (const auto *param : FD->params())
-    if (HasLongVecs(param->getType()))
+    if (ContainsVectorLongerThan(param->getType(),
+                                 DXIL::kDefaultMaxVectorLength))
       S.Diag(param->getLocation(), diag::err_hlsl_unsupported_long_vector)
-          << "entry function parameters";
+          << DXIL::kDefaultMaxVectorLength << "entry function parameters";
 
-  if (HasLongVecs(FD->getReturnType()))
+  if (ContainsVectorLongerThan(FD->getReturnType(),
+                               DXIL::kDefaultMaxVectorLength))
     S.Diag(FD->getLocation(), diag::err_hlsl_unsupported_long_vector)
-        << "entry function return type";
+        << DXIL::kDefaultMaxVectorLength << "entry function return type";
 
   DXIL::ShaderKind Stage =
       ShaderModel::KindFromFullName(shaderAttr->getStage());

tools/clang/lib/Sema/SemaHLSLDiagnoseTU.cpp

@@ -521,14 +521,17 @@ void hlsl::DiagnoseTranslationUnit(clang::Sema *self) {
         }
       }
       for (const auto *param : pPatchFnDecl->params())
-        if (HasLongVecs(param->getType()))
+        if (ContainsVectorLongerThan(param->getType(),
+                                     DXIL::kDefaultMaxVectorLength))
           self->Diag(param->getLocation(),
                      diag::err_hlsl_unsupported_long_vector)
+              << DXIL::kDefaultMaxVectorLength
               << "patch constant function parameters";
 
-      if (HasLongVecs(pPatchFnDecl->getReturnType()))
+      if (ContainsVectorLongerThan(pPatchFnDecl->getReturnType(), 4))
         self->Diag(pPatchFnDecl->getLocation(),
                    diag::err_hlsl_unsupported_long_vector)
+            << DXIL::kDefaultMaxVectorLength
             << "patch constant function return type";
     }
 

tools/clang/tools/dxcompiler/dxcompilerobj.cpp

@@ -1440,6 +1440,13 @@ class DxcCompiler : public IDxcCompiler3,
         Opts.EnablePayloadQualifiers;
     compiler.getLangOpts().HLSLProfile = compiler.getCodeGenOpts().HLSLProfile =
         Opts.TargetProfile;
+    const ShaderModel *SM = hlsl::ShaderModel::GetByName(
+        compiler.getLangOpts().HLSLProfile.c_str());
+    if (SM->IsSM69Plus())
+      compiler.getLangOpts().MaxHLSLVectorLength = DXIL::kSM69MaxVectorLength;
+    else
+      compiler.getLangOpts().MaxHLSLVectorLength =
+          DXIL::kDefaultMaxVectorLength;
 
     // Enable dumping implicit top level decls either if it was specifically
     // requested or if we are not dumping the ast from the command line. That