[HLSL] support ConstantBuffer

[python3kgae]

Summary

Support ConstantBuffer by define it like

template<typename T>
using ConstantBuffer = T;

Added new internal attribute HLSLConstantBufferView to mark CBV with AttributedType.

The document for ConstantBuffer in hlsl is at https://learn.microsoft.com/en-us/windows/win32/direct3d12/resource-binding-in-hlsl#constant-buffers

[python3kgae]

Fix windows test fail caused by dead ptr.

[python3kgae]

Rebase

[python3kgae]

Change CBV implementation to
template<typename T>
using ConstantBuffer = T;

Added new internal attribute HLSLConstantBufferView to mark CBV with AttributedType.

clang/include/clang/Basic/Attr.td

let Args = [EnumArgument<"ResourceType", "ResourceClass",
                             "StructuredBuffer", "CBufferKind", "SamplerKind",
                             "TBuffer", "RTAccelerationStructure", "FeedbackTexture2D",
                             "FeedbackTexture2DArray"]
                             >
               ];
   let Documentation = [InternalOnly];
 }
 
+def HLSLConstantBufferView : InheritableAttr {
+  let Spellings = [];
+  let Subjects = SubjectList<[Struct]>;
+  let LangOpts = [HLSL];
+  let Documentation = [InternalOnly];
+}
+
 def HLSLGroupSharedAddressSpace : TypeAttr {
   let Spellings = [Keyword<"groupshared">];
   let Subjects = SubjectList<[Var]>;
   let Documentation = [HLSLGroupSharedAddressSpaceDocs];
 }
 
 def RandomizeLayout : InheritableAttr {
   let Spellings = [GCC<"randomize_layout">];

clang/include/clang/Basic/DiagnosticSemaKinds.td

def err_std_source_location_impl_malformed : Error<
   "'std::source_location::__impl' must be standard-layout and have only two 'const char *' fields '_M_file_name' and '_M_function_name', and two integral fields '_M_line' and '_M_column'">;
 
 // HLSL Diagnostics
 def err_hlsl_attr_unsupported_in_stage : Error<"attribute %0 is unsupported in %select{Pixel|Vertex|Geometry|Hull|Domain|Compute|Library|RayGeneration|Intersection|AnyHit|ClosestHit|Miss|Callable|Mesh|Amplification|Invalid}1 shaders, requires %2">;
 def err_hlsl_attr_invalid_type : Error<
    "attribute %0 only applies to a field or parameter of type '%1'">;
 def err_hlsl_attr_invalid_ast_node : Error<
    "attribute %0 only applies to %1">;
+def err_hlsl_typeintemplateargument_requires_struct : Error<
+  "%0 cannot be used as a type parameter where a struct is required">;
 def err_hlsl_numthreads_argument_oor : Error<"argument '%select{X|Y|Z}0' to numthreads attribute cannot exceed %1">;
 def err_hlsl_numthreads_invalid : Error<"total number of threads cannot exceed %0">;
 def err_hlsl_missing_numthreads : Error<"missing numthreads attribute for %0 shader entry">;
 def err_hlsl_attribute_param_mismatch : Error<"%0 attribute parameters do not match the previous declaration">;
 def err_hlsl_missing_semantic_annotation : Error<
   "semantic annotations must be present for all parameters of an entry "
   "function or patch constant function">;
 def err_hlsl_init_priority_unsupported : Error<

clang/include/clang/Sema/HLSLExternalSemaSource.h

class HLSLExternalSemaSource : public ExternalSemaSource {
   NamespaceDecl *HLSLNamespace = nullptr;
   CXXRecordDecl *ResourceDecl;
 
   using CompletionFunction = std::function<void(CXXRecordDecl *)>;
   llvm::DenseMap<CXXRecordDecl *, CompletionFunction> Completions;
 
   void defineHLSLVectorAlias();
   void defineTrivialHLSLTypes();
+  void defineConstantBufferView();
   void forwardDeclareHLSLTypes();
 
   void completeBufferType(CXXRecordDecl *Record);
 
 public:
   ~HLSLExternalSemaSource() override;
 
   /// Initialize the semantic source with the Sema instance

clang/include/clang/Sema/Sema.h

private:
   bool CheckPPCBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
                                    CallExpr *TheCall);
   bool CheckAMDGCNBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
   bool CheckRISCVLMUL(CallExpr *TheCall, unsigned ArgNum);
   bool CheckRISCVBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID,
                                      CallExpr *TheCall);
   bool CheckLoongArchBuiltinFunctionCall(const TargetInfo &TI,
                                          unsigned BuiltinID, CallExpr *TheCall);
+  bool CheckHLSLConstantBufferView(TypeAliasDecl *Pattern,
+                                   TemplateArgumentListInfo &TemplateArgs,
+                                   SourceLocation TemplateLoc);
 
   bool SemaBuiltinVAStart(unsigned BuiltinID, CallExpr *TheCall);
   bool SemaBuiltinVAStartARMMicrosoft(CallExpr *Call);
   bool SemaBuiltinUnorderedCompare(CallExpr *TheCall);
   bool SemaBuiltinFPClassification(CallExpr *TheCall, unsigned NumArgs);
   bool SemaBuiltinComplex(CallExpr *TheCall);
   bool SemaBuiltinVSX(CallExpr *TheCall);
   bool SemaBuiltinOSLogFormat(CallExpr *TheCall);

clang/lib/AST/TypePrinter.cpp

if (T->getAttrKind() == attr::NSReturnsRetained &&
                              ->getExtInfo().getProducesResult())
     return;
 
   if (T->getAttrKind() == attr::LifetimeBound) {
     OS << " [[clang::lifetimebound]]";
     return;
   }
 
+  if (T->getAttrKind() == attr::HLSLConstantBufferView) {
+    OS << " [[hlsl::ConstantBufferView]]";
+    return;
+  }
+
   // The printing of the address_space attribute is handled by the qualifier
   // since it is still stored in the qualifier. Return early to prevent printing
   // this twice.
   if (T->getAttrKind() == attr::AddressSpace)
     return;
 
   if (T->getAttrKind() == attr::AnnotateType) {
     // FIXME: Print the attribute arguments once we have a way to retrieve these

clang/lib/Sema/HLSLExternalSemaSource.cpp

auto *Template =
                                     Record->getIdentifier(), ParamList, Record);
 
   Record->setDescribedAliasTemplate(Template);
   Template->setImplicit(true);
   Template->setLexicalDeclContext(Record->getDeclContext());
   HLSLNamespace->addDecl(Template);
 }
 
+void HLSLExternalSemaSource::defineConstantBufferView() {
+  // Add CBV as
+  // template<typename T>
+  // using ConstantBuffer = T;
+
+  // TypeAliasTemplateDecl ConstantBuf
+  //| |-TemplateTypeParmDecl  referenced typename depth 0 index 0 T
+  //| `- TypeAliasDecl ConstantBuf 'T'
+  //|   `- TemplateTypeParmType 0x273ef3655f0 'T' dependent depth 0 index 0
+  //|     `- TemplateTypeParm 0x273ef365568 'T'
+  ASTContext &AST = SemaPtr->getASTContext();
+
+  llvm::SmallVector<NamedDecl *> TemplateParams;
+
+  auto *TypeParam = TemplateTypeParmDecl::Create(
+      AST, HLSLNamespace, SourceLocation(), SourceLocation(), 0, 0,
+      &AST.Idents.get("element", tok::TokenKind::identifier), false, false);
+
+  TemplateParams.emplace_back(TypeParam);
+
+  auto *ParamList =
+      TemplateParameterList::Create(AST, SourceLocation(), SourceLocation(),
+                                    TemplateParams, SourceLocation(), nullptr);
+
+  IdentifierInfo &II = AST.Idents.get("ConstantBuffer", tok::TokenKind::identifier);
+
+  QualType AliasType = AST.getTemplateTypeParmType(0, 0, false, TypeParam);
+  // Use AttributedType to mark ConstantBufferView.
+  AliasType =
+      AST.getAttributedType(attr::HLSLConstantBufferView, AliasType, AliasType);
+
+  auto *Record = TypeAliasDecl::Create(AST, HLSLNamespace, SourceLocation(),
+                                       SourceLocation(), &II,
+                                       AST.getTrivialTypeSourceInfo(AliasType));
+
+  Record->setImplicit(true);
+
+  auto *Template =
+      TypeAliasTemplateDecl::Create(AST, HLSLNamespace, SourceLocation(),
+                                    Record->getIdentifier(), ParamList, Record);
+
+  Record->setDescribedAliasTemplate(Template);
+  Template->setImplicit(true);
+  Template->setLexicalDeclContext(Record->getDeclContext());
+
+
+  HLSLNamespace->addDecl(Template);
+}
+
 void HLSLExternalSemaSource::defineTrivialHLSLTypes() {
   defineHLSLVectorAlias();
 
+  defineConstantBufferView();
+
   ResourceDecl = BuiltinTypeDeclBuilder(*SemaPtr, HLSLNamespace, "Resource")
                      .startDefinition()
                      .addHandleMember(AccessSpecifier::AS_public)
                      .completeDefinition()
                      .Record;
+
 }
 
 void HLSLExternalSemaSource::forwardDeclareHLSLTypes() {
   CXXRecordDecl *Decl;
   Decl = BuiltinTypeDeclBuilder(*SemaPtr, HLSLNamespace, "RWBuffer")
              .addTemplateArgumentList()
              .addTypeParameter("element_type", SemaPtr->getASTContext().FloatTy)
              .finalizeTemplateArgs()

clang/lib/Sema/SemaTemplate.cpp

std::string Description;
     PrintingPolicy Policy = getPrintingPolicy();
     Policy.PrintCanonicalTypes = true;
     FailedBooleanConditionPrinterHelper Helper(Policy);
     FailedCond->printPretty(Out, &Helper, Policy, 0, "\n", nullptr);
   }
   return { FailedCond, Description };
 }
 
+bool Sema::CheckHLSLConstantBufferView(TypeAliasDecl *Pattern,
+                                       TemplateArgumentListInfo &TemplateArgs,
+                                       SourceLocation TemplateLoc) {
+  if (TemplateArgs.size() != 1)
+    return true;
+  QualType PatType = Pattern->getUnderlyingType();
+  const auto *AttrTy = PatType->getAs<AttributedType>();
+  if (!AttrTy)
+    return true;
+
+  if (AttrTy->getAttrKind() != attr::HLSLConstantBufferView)
+    return true;
+  // Make sure ConstantBufferView element type is record.
+  const TemplateArgument &Arg = TemplateArgs.arguments()[0].getArgument();
+  if (Arg.getKind() == TemplateArgument::ArgKind::Type) {
+    const auto *RD = Arg.getAsType()->getAsCXXRecordDecl();
+    if (!RD) {
+      Diag(TemplateLoc, diag::err_hlsl_typeintemplateargument_requires_struct)
+          << Arg.getAsType();
+      return false;
+    }
+  }
+  return true;
+}
+
 QualType Sema::CheckTemplateIdType(TemplateName Name,
                                    SourceLocation TemplateLoc,
                                    TemplateArgumentListInfo &TemplateArgs) {
   DependentTemplateName *DTN
     = Name.getUnderlying().getAsDependentTemplateName();
   if (DTN && DTN->isIdentifier())
     // When building a template-id where the template-name is dependent,
     // assume the template is a type template. Either our assumption is
if (TypeAliasTemplateDecl *AliasTemplate =
     TemplateArgLists.addOuterRetainedLevels(
         AliasTemplate->getTemplateParameters()->getDepth());
 
     LocalInstantiationScope Scope(*this);
     InstantiatingTemplate Inst(*this, TemplateLoc, Template);
     if (Inst.isInvalid())
       return QualType();
 
+    if (getLangOpts().HLSL &&
+        !CheckHLSLConstantBufferView(Pattern, TemplateArgs, TemplateLoc))
+      return QualType();
+
     CanonType = SubstType(Pattern->getUnderlyingType(),
                           TemplateArgLists, AliasTemplate->getLocation(),
                           AliasTemplate->getDeclName());
     if (CanonType.isNull()) {
       // If this was enable_if and we failed to find the nested type
       // within enable_if in a SFINAE context, dig out the specific
       // enable_if condition that failed and present that instead.
       if (isEnableIfAliasTemplate(AliasTemplate)) {

clang/test/AST/HLSL/CBV.hlsl

+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.3-library -x hlsl -fsyntax-only -ast-dump %s | FileCheck %s
+
+// CHECK:TypeAliasTemplateDecl 0x{{[0-9a-f]+}} <<invalid sloc>> <invalid sloc> implicit ConstantBuffer
+// CHECK-NEXT:-TemplateTypeParmDecl 0x[[T:[0-9a-f]+]] <<invalid sloc>> <invalid sloc> class depth 0 index 0 element
+// CHECK-NEXT:-TypeAliasDecl 0x{{[0-9a-f]+}}  <<invalid sloc>> <invalid sloc> implicit ConstantBuffer 'element  {{(.{2})}}hlsl::ConstantBufferView{{(.{2})}}':'element'
+// CHECK-NEXT:-AttributedType 0x{{[0-9a-f]+}} 'element {{(.{2})}}hlsl::ConstantBufferView{{(.{2})}}' sugar dependent
+// CHECK-NEXT: -TemplateTypeParmType 0x{{[0-9a-f]+}} 'element' dependent depth 0 index 0
+// CHECK-NEXT: -TemplateTypeParm 0x[[T]] 'element'
+
+// CHECK:-CXXRecordDecl 0x{{[0-9a-f]+}} <col:1, col:8> col:8 implicit struct S
+// CHECK-NEXT:-FieldDecl 0x[[A:[0-9a-f]+]] <line:13:5, col:11> col:11 referenced a 'float'
+struct S {
+    float a;
+};
+
+// CHECK:VarDecl 0x[[CB:[0-9a-f]+]] <line:17:1, col:19> col:19 used CB 'ConstantBuffer<S>':'S'
+ConstantBuffer<S> CB;
+
+float foo() {
+// CHECK:ReturnStmt 0x{{[0-9a-f]+}} <line:24:5, col:15>
+// CHECK-NEXT:-ImplicitCastExpr 0x{{[0-9a-f]+}} <col:12, col:15> 'float' <LValueToRValue>
+// CHECK-NEXT:-MemberExpr 0x{{[0-9a-f]+}} <col:12, col:15> 'float' lvalue .a 0x[[A]]
+// CHECK-NEXT:-DeclRefExpr 0x{{[0-9a-f]+}} <col:12> 'ConstantBuffer<S>':'S' lvalue Var 0x[[CB]] 'CB' 'ConstantBuffer<S>'
+    return CB.a;
+}

clang/test/SemaHLSL/BuiltIns/CBV.hlsl

+// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.3-library -x hlsl -fsyntax-only -verify %s
+
+// expected-error@+2{{'float' cannot be used as a type parameter where a struct is required}}
+// expected-note@+1{{in instantiation of template type alias 'ConstantBuffer' requested here}}
+ConstantBuffer<float> CB;