Author: Helena Kotas Date: 2024-08-29T21:42:20-07:00 New Revision: e00e9a3f8294c9b96cb0328bf136fab72aeec749
URL: https://github.com/llvm/llvm-project/commit/e00e9a3f8294c9b96cb0328bf136fab72aeec749 DIFF: https://github.com/llvm/llvm-project/commit/e00e9a3f8294c9b96cb0328bf136fab72aeec749.diff LOG: [HLSL] Add HLSLAttributedResourceType (#106181) Introducing `HLSLAttributedResourceType` - a new type that is similar to `AttributedType` but with additional data specific to HLSL resources. `AttributeType` currently only stores an attribute kind and no additional data from the type attribute parameters. This does not really work for HLSL resources since its type attributes contain non-boolean values that need to be retained as well. For example: ``` template <typename T> class RWBuffer { __hlsl_resource_t [[hlsl::resource_class(uav)]] [[hlsl::is_rov]] handle; }; ``` The data `HLSLAttributedResourceType` needs to eventually store are: - resource class (SRV, UAV, CBuffer, Sampler) - texture dimension(1-3) - flags is_rov, is_array, is_feedback and is_multisample - contained type All of these values except contained type will be stored in `HLSLAttributedResourceType::Attributes` struct and accessed individually via the fields. There is also `Data` alias that covers all of these values as a `unsigned` which is used for hashing and the AST type serialization. During type attribute processing all HLSL type attributes will be validated and collected by SemaHLSL (by `SemaHLSL::handleResourceTypeAttr`) and in the end combined into a single `HLSLAttributedResourceType` instance (in `SemaHLSL::ProcessResourceTypeAttributes`). `SemaHLSL` will also need to short-term store the `TypeLoc` information for the new type that will be grabbed by `TypeSpecLocFiller` soon after the type is created. Part 1/2 of #104861 Added: Modified: clang/include/clang-c/Index.h clang/include/clang/AST/ASTContext.h clang/include/clang/AST/ASTNodeTraverser.h clang/include/clang/AST/RecursiveASTVisitor.h clang/include/clang/AST/Type.h clang/include/clang/AST/TypeLoc.h clang/include/clang/AST/TypeProperties.td clang/include/clang/Basic/TypeNodes.td clang/include/clang/Sema/SemaHLSL.h clang/include/clang/Serialization/TypeBitCodes.def clang/lib/AST/ASTContext.cpp clang/lib/AST/ASTImporter.cpp clang/lib/AST/ASTStructuralEquivalence.cpp clang/lib/AST/ItaniumMangle.cpp clang/lib/AST/TypeLoc.cpp clang/lib/AST/TypePrinter.cpp clang/lib/CodeGen/CGDebugInfo.cpp clang/lib/CodeGen/CodeGenFunction.cpp clang/lib/Sema/SemaExpr.cpp clang/lib/Sema/SemaHLSL.cpp clang/lib/Sema/SemaType.cpp clang/lib/Sema/TreeTransform.h clang/lib/Serialization/ASTReader.cpp clang/lib/Serialization/ASTWriter.cpp clang/tools/libclang/CIndex.cpp clang/tools/libclang/CXType.cpp Removed: ################################################################################ diff --git a/clang/include/clang-c/Index.h b/clang/include/clang-c/Index.h index f78f4f1b2e6c9f..4f99bf4ebe309b 100644 --- a/clang/include/clang-c/Index.h +++ b/clang/include/clang-c/Index.h @@ -2980,8 +2980,9 @@ enum CXTypeKind { CXType_Atomic = 177, CXType_BTFTagAttributed = 178, - // HLSL Intangible Types - CXType_HLSLResource = 179 + // HLSL Types + CXType_HLSLResource = 179, + CXType_HLSLAttributedResource = 180 }; /** diff --git a/clang/include/clang/AST/ASTContext.h b/clang/include/clang/AST/ASTContext.h index 58a820508da42b..8156d283f8fe21 100644 --- a/clang/include/clang/AST/ASTContext.h +++ b/clang/include/clang/AST/ASTContext.h @@ -254,6 +254,7 @@ class ASTContext : public RefCountedBase<ASTContext> { mutable llvm::ContextualFoldingSet<DependentBitIntType, ASTContext &> DependentBitIntTypes; llvm::FoldingSet<BTFTagAttributedType> BTFTagAttributedTypes; + llvm::FoldingSet<HLSLAttributedResourceType> HLSLAttributedResourceTypes; mutable llvm::FoldingSet<CountAttributedType> CountAttributedTypes; @@ -1671,6 +1672,10 @@ class ASTContext : public RefCountedBase<ASTContext> { QualType getBTFTagAttributedType(const BTFTypeTagAttr *BTFAttr, QualType Wrapped); + QualType getHLSLAttributedResourceType( + QualType Wrapped, QualType Contained, + const HLSLAttributedResourceType::Attributes &Attrs); + QualType getSubstTemplateTypeParmType(QualType Replacement, Decl *AssociatedDecl, unsigned Index, diff --git a/clang/include/clang/AST/ASTNodeTraverser.h b/clang/include/clang/AST/ASTNodeTraverser.h index 0546c19ce81195..a443a88bab1f2d 100644 --- a/clang/include/clang/AST/ASTNodeTraverser.h +++ b/clang/include/clang/AST/ASTNodeTraverser.h @@ -439,6 +439,11 @@ class ASTNodeTraverser void VisitBTFTagAttributedType(const BTFTagAttributedType *T) { Visit(T->getWrappedType()); } + void VisitHLSLAttributedResourceType(const HLSLAttributedResourceType *T) { + QualType Contained = T->getContainedType(); + if (!Contained.isNull()) + Visit(Contained); + } void VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *) {} void VisitSubstTemplateTypeParmPackType(const SubstTemplateTypeParmPackType *T) { diff --git a/clang/include/clang/AST/RecursiveASTVisitor.h b/clang/include/clang/AST/RecursiveASTVisitor.h index 2b35997bd539ac..e51b04cce39eb9 100644 --- a/clang/include/clang/AST/RecursiveASTVisitor.h +++ b/clang/include/clang/AST/RecursiveASTVisitor.h @@ -1146,6 +1146,9 @@ DEF_TRAVERSE_TYPE(CountAttributedType, { DEF_TRAVERSE_TYPE(BTFTagAttributedType, { TRY_TO(TraverseType(T->getWrappedType())); }) +DEF_TRAVERSE_TYPE(HLSLAttributedResourceType, + { TRY_TO(TraverseType(T->getWrappedType())); }) + DEF_TRAVERSE_TYPE(ParenType, { TRY_TO(TraverseType(T->getInnerType())); }) DEF_TRAVERSE_TYPE(MacroQualifiedType, @@ -1445,6 +1448,9 @@ DEF_TRAVERSE_TYPELOC(CountAttributedType, DEF_TRAVERSE_TYPELOC(BTFTagAttributedType, { TRY_TO(TraverseTypeLoc(TL.getWrappedLoc())); }) +DEF_TRAVERSE_TYPELOC(HLSLAttributedResourceType, + { TRY_TO(TraverseTypeLoc(TL.getWrappedLoc())); }) + DEF_TRAVERSE_TYPELOC(ElaboratedType, { if (TL.getQualifierLoc()) { TRY_TO(TraverseNestedNameSpecifierLoc(TL.getQualifierLoc())); diff --git a/clang/include/clang/AST/Type.h b/clang/include/clang/AST/Type.h index 50041915204a1f..08f7638d7d8f96 100644 --- a/clang/include/clang/AST/Type.h +++ b/clang/include/clang/AST/Type.h @@ -44,6 +44,7 @@ #include "llvm/ADT/iterator_range.h" #include "llvm/Support/Casting.h" #include "llvm/Support/Compiler.h" +#include "llvm/Support/DXILABI.h" #include "llvm/Support/ErrorHandling.h" #include "llvm/Support/PointerLikeTypeTraits.h" #include "llvm/Support/TrailingObjects.h" @@ -6156,6 +6157,54 @@ class BTFTagAttributedType : public Type, public llvm::FoldingSetNode { } }; +class HLSLAttributedResourceType : public Type, public llvm::FoldingSetNode { +public: + struct Attributes { + // Data gathered from HLSL resource attributes + llvm::dxil::ResourceClass ResourceClass; + uint8_t IsROV : 1; + Attributes(llvm::dxil::ResourceClass ResourceClass, bool IsROV) + : ResourceClass(ResourceClass), IsROV(IsROV) {} + Attributes() : ResourceClass(llvm::dxil::ResourceClass::UAV), IsROV(0) {} + }; + +private: + friend class ASTContext; // ASTContext creates these + + QualType WrappedType; + QualType ContainedType; + const Attributes Attrs; + + HLSLAttributedResourceType(QualType Canon, QualType Wrapped, + QualType Contained, const Attributes &Attrs) + : Type(HLSLAttributedResource, Canon, Wrapped->getDependence()), + WrappedType(Wrapped), ContainedType(Contained), Attrs(Attrs) {} + +public: + QualType getWrappedType() const { return WrappedType; } + QualType getContainedType() const { return ContainedType; } + const Attributes &getAttrs() const { return Attrs; } + + bool isSugared() const { return true; } + QualType desugar() const { return getWrappedType(); } + + void Profile(llvm::FoldingSetNodeID &ID) { + Profile(ID, WrappedType, ContainedType, Attrs); + } + + static void Profile(llvm::FoldingSetNodeID &ID, QualType Wrapped, + QualType Contained, const Attributes &Attrs) { + ID.AddPointer(Wrapped.getAsOpaquePtr()); + ID.AddPointer(Contained.getAsOpaquePtr()); + ID.AddInteger(static_cast<uint32_t>(Attrs.ResourceClass)); + ID.AddBoolean(Attrs.IsROV); + } + + static bool classof(const Type *T) { + return T->getTypeClass() == HLSLAttributedResource; + } +}; + class TemplateTypeParmType : public Type, public llvm::FoldingSetNode { friend class ASTContext; // ASTContext creates these @@ -8579,6 +8628,8 @@ template <typename T> const T *Type::getAsAdjusted() const { Ty = A->getModifiedType().getTypePtr(); else if (const auto *A = dyn_cast<BTFTagAttributedType>(Ty)) Ty = A->getWrappedType().getTypePtr(); + else if (const auto *A = dyn_cast<HLSLAttributedResourceType>(Ty)) + Ty = A->getWrappedType().getTypePtr(); else if (const auto *E = dyn_cast<ElaboratedType>(Ty)) Ty = E->desugar().getTypePtr(); else if (const auto *P = dyn_cast<ParenType>(Ty)) diff --git a/clang/include/clang/AST/TypeLoc.h b/clang/include/clang/AST/TypeLoc.h index 9f2dff7a782cb3..5db39eb3aefa74 100644 --- a/clang/include/clang/AST/TypeLoc.h +++ b/clang/include/clang/AST/TypeLoc.h @@ -940,6 +940,25 @@ class BTFTagAttributedTypeLoc QualType getInnerType() const { return getTypePtr()->getWrappedType(); } }; +struct HLSLAttributedResourceLocInfo { + SourceRange Range; +}; + +/// Type source information for HLSL attributed resource type. +class HLSLAttributedResourceTypeLoc + : public ConcreteTypeLoc<UnqualTypeLoc, HLSLAttributedResourceTypeLoc, + HLSLAttributedResourceType, + HLSLAttributedResourceLocInfo> { +public: + TypeLoc getWrappedLoc() const { return getInnerTypeLoc(); } + void setSourceRange(const SourceRange &R) { getLocalData()->Range = R; } + SourceRange getLocalSourceRange() const { return getLocalData()->Range; } + void initializeLocal(ASTContext &Context, SourceLocation loc) { + setSourceRange(SourceRange()); + } + QualType getInnerType() const { return getTypePtr()->getWrappedType(); } +}; + struct ObjCObjectTypeLocInfo { SourceLocation TypeArgsLAngleLoc; SourceLocation TypeArgsRAngleLoc; @@ -2690,6 +2709,8 @@ inline T TypeLoc::getAsAdjusted() const { Cur = ATL.getModifiedLoc(); else if (auto ATL = Cur.getAs<BTFTagAttributedTypeLoc>()) Cur = ATL.getWrappedLoc(); + else if (auto ATL = Cur.getAs<HLSLAttributedResourceTypeLoc>()) + Cur = ATL.getWrappedLoc(); else if (auto ETL = Cur.getAs<ElaboratedTypeLoc>()) Cur = ETL.getNamedTypeLoc(); else if (auto ATL = Cur.getAs<AdjustedTypeLoc>()) diff --git a/clang/include/clang/AST/TypeProperties.td b/clang/include/clang/AST/TypeProperties.td index 33398ecf5b849b..3df19315fd573f 100644 --- a/clang/include/clang/AST/TypeProperties.td +++ b/clang/include/clang/AST/TypeProperties.td @@ -687,6 +687,25 @@ let Class = BTFTagAttributedType in { }]>; } +let Class = HLSLAttributedResourceType in { + def : Property<"resClass", UInt32> { + let Read = [{ static_cast<uint32_t>(node->getAttrs().ResourceClass) }]; + } + def : Property<"isROV", Bool> { + let Read = [{ node->getAttrs().IsROV }]; + } + def : Property<"wrappedTy", QualType> { + let Read = [{ node->getWrappedType() }]; + } + def : Property<"containedTy", QualType> { + let Read = [{ node->getContainedType() }]; + } + def : Creator<[{ + HLSLAttributedResourceType::Attributes attrs(static_cast<llvm::dxil::ResourceClass>(resClass), isROV); + return ctx.getHLSLAttributedResourceType(wrappedTy, containedTy, attrs); + }]>; +} + let Class = DependentAddressSpaceType in { def : Property<"pointeeType", QualType> { let Read = [{ node->getPointeeType() }]; diff --git a/clang/include/clang/Basic/TypeNodes.td b/clang/include/clang/Basic/TypeNodes.td index fee49cf4326dfc..8cca392cddc174 100644 --- a/clang/include/clang/Basic/TypeNodes.td +++ b/clang/include/clang/Basic/TypeNodes.td @@ -93,6 +93,7 @@ def EnumType : TypeNode<TagType>, LeafType; def ElaboratedType : TypeNode<Type>, NeverCanonical; def AttributedType : TypeNode<Type>, NeverCanonical; def BTFTagAttributedType : TypeNode<Type>, NeverCanonical; +def HLSLAttributedResourceType : TypeNode<Type>, NeverCanonical; def TemplateTypeParmType : TypeNode<Type>, AlwaysDependent, LeafType; def SubstTemplateTypeParmType : TypeNode<Type>, NeverCanonical; def SubstTemplateTypeParmPackType : TypeNode<Type>, AlwaysDependent; diff --git a/clang/include/clang/Sema/SemaHLSL.h b/clang/include/clang/Sema/SemaHLSL.h index 5277fb57a23343..363a3ee6b4c1f2 100644 --- a/clang/include/clang/Sema/SemaHLSL.h +++ b/clang/include/clang/Sema/SemaHLSL.h @@ -59,8 +59,11 @@ class SemaHLSL : public SemaBase { void handleResourceClassAttr(Decl *D, const ParsedAttr &AL); void handleResourceBindingAttr(Decl *D, const ParsedAttr &AL); void handleParamModifierAttr(Decl *D, const ParsedAttr &AL); + bool handleResourceTypeAttr(const ParsedAttr &AL); bool CheckBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall); + QualType ProcessResourceTypeAttributes(QualType Wrapped); + SourceLocation TakeLocForHLSLAttribute(const HLSLAttributedResourceType *RT); // HLSL Type trait implementations bool IsScalarizedLayoutCompatible(QualType T1, QualType T2) const; diff --git a/clang/include/clang/Serialization/TypeBitCodes.def b/clang/include/clang/Serialization/TypeBitCodes.def index 82b053d4caca63..3c78b878050101 100644 --- a/clang/include/clang/Serialization/TypeBitCodes.def +++ b/clang/include/clang/Serialization/TypeBitCodes.def @@ -67,5 +67,6 @@ TYPE_BIT_CODE(BTFTagAttributed, BTFTAG_ATTRIBUTED, 55) TYPE_BIT_CODE(PackIndexing, PACK_INDEXING, 56) TYPE_BIT_CODE(CountAttributed, COUNT_ATTRIBUTED, 57) TYPE_BIT_CODE(ArrayParameter, ARRAY_PARAMETER, 58) +TYPE_BIT_CODE(HLSLAttributedResource, HLSLRESOURCE_ATTRIBUTED, 59) #undef TYPE_BIT_CODE diff --git a/clang/lib/AST/ASTContext.cpp b/clang/lib/AST/ASTContext.cpp index b201d201e1ea6a..f108952d7bbf73 100644 --- a/clang/lib/AST/ASTContext.cpp +++ b/clang/lib/AST/ASTContext.cpp @@ -2406,6 +2406,10 @@ TypeInfo ASTContext::getTypeInfoImpl(const Type *T) const { return getTypeInfo( cast<BTFTagAttributedType>(T)->getWrappedType().getTypePtr()); + case Type::HLSLAttributedResource: + return getTypeInfo( + cast<HLSLAttributedResourceType>(T)->getWrappedType().getTypePtr()); + case Type::Atomic: { // Start with the base type information. TypeInfo Info = getTypeInfo(cast<AtomicType>(T)->getValueType()); @@ -5219,6 +5223,28 @@ QualType ASTContext::getBTFTagAttributedType(const BTFTypeTagAttr *BTFAttr, return QualType(Ty, 0); } +QualType ASTContext::getHLSLAttributedResourceType( + QualType Wrapped, QualType Contained, + const HLSLAttributedResourceType::Attributes &Attrs) { + + llvm::FoldingSetNodeID ID; + HLSLAttributedResourceType::Profile(ID, Wrapped, Contained, Attrs); + + void *InsertPos = nullptr; + HLSLAttributedResourceType *Ty = + HLSLAttributedResourceTypes.FindNodeOrInsertPos(ID, InsertPos); + if (Ty) + return QualType(Ty, 0); + + QualType Canon = getCanonicalType(Wrapped); + Ty = new (*this, alignof(HLSLAttributedResourceType)) + HLSLAttributedResourceType(Canon, Wrapped, Contained, Attrs); + + Types.push_back(Ty); + HLSLAttributedResourceTypes.InsertNode(Ty, InsertPos); + + return QualType(Ty, 0); +} /// Retrieve a substitution-result type. QualType ASTContext::getSubstTemplateTypeParmType( QualType Replacement, Decl *AssociatedDecl, unsigned Index, @@ -13584,6 +13610,7 @@ static QualType getCommonSugarTypeNode(ASTContext &Ctx, const Type *X, CANONICAL_TYPE(FunctionNoProto) CANONICAL_TYPE(FunctionProto) CANONICAL_TYPE(IncompleteArray) + CANONICAL_TYPE(HLSLAttributedResource) CANONICAL_TYPE(LValueReference) CANONICAL_TYPE(MemberPointer) CANONICAL_TYPE(ObjCInterface) diff --git a/clang/lib/AST/ASTImporter.cpp b/clang/lib/AST/ASTImporter.cpp index 3bc0a647ebf94f..fa850409ba1210 100644 --- a/clang/lib/AST/ASTImporter.cpp +++ b/clang/lib/AST/ASTImporter.cpp @@ -1832,6 +1832,19 @@ ExpectedType clang::ASTNodeImporter::VisitBTFTagAttributedType( ToWrappedType); } +ExpectedType clang::ASTNodeImporter::VisitHLSLAttributedResourceType( + const clang::HLSLAttributedResourceType *T) { + Error Err = Error::success(); + const HLSLAttributedResourceType::Attributes &ToAttrs = T->getAttrs(); + QualType ToWrappedType = importChecked(Err, T->getWrappedType()); + QualType ToContainedType = importChecked(Err, T->getContainedType()); + if (Err) + return std::move(Err); + + return Importer.getToContext().getHLSLAttributedResourceType( + ToWrappedType, ToContainedType, ToAttrs); +} + ExpectedType clang::ASTNodeImporter::VisitConstantMatrixType( const clang::ConstantMatrixType *T) { ExpectedType ToElementTypeOrErr = import(T->getElementType()); diff --git a/clang/lib/AST/ASTStructuralEquivalence.cpp b/clang/lib/AST/ASTStructuralEquivalence.cpp index 37555c324282fe..0b791700aa48dd 100644 --- a/clang/lib/AST/ASTStructuralEquivalence.cpp +++ b/clang/lib/AST/ASTStructuralEquivalence.cpp @@ -799,6 +799,16 @@ static bool IsEquivalentExceptionSpec(StructuralEquivalenceContext &Context, return true; } +// Determine structural equivalence of two instances of +// HLSLAttributedResourceType::Attributes +static bool +IsStructurallyEquivalent(StructuralEquivalenceContext &Context, + const HLSLAttributedResourceType::Attributes &Attrs1, + const HLSLAttributedResourceType::Attributes &Attrs2) { + return std::tie(Attrs1.ResourceClass, Attrs1.IsROV) == + std::tie(Attrs2.ResourceClass, Attrs2.IsROV); +} + /// Determine structural equivalence of two types. static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, QualType T1, QualType T2) { @@ -1093,6 +1103,21 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, return false; break; + case Type::HLSLAttributedResource: + if (!IsStructurallyEquivalent( + Context, cast<HLSLAttributedResourceType>(T1)->getWrappedType(), + cast<HLSLAttributedResourceType>(T2)->getWrappedType())) + return false; + if (!IsStructurallyEquivalent( + Context, cast<HLSLAttributedResourceType>(T1)->getContainedType(), + cast<HLSLAttributedResourceType>(T2)->getContainedType())) + return false; + if (!IsStructurallyEquivalent( + Context, cast<HLSLAttributedResourceType>(T1)->getAttrs(), + cast<HLSLAttributedResourceType>(T2)->getAttrs())) + return false; + break; + case Type::Paren: if (!IsStructurallyEquivalent(Context, cast<ParenType>(T1)->getInnerType(), cast<ParenType>(T2)->getInnerType())) diff --git a/clang/lib/AST/ItaniumMangle.cpp b/clang/lib/AST/ItaniumMangle.cpp index 1ce51f65dabd75..1ad8cf5a1c911f 100644 --- a/clang/lib/AST/ItaniumMangle.cpp +++ b/clang/lib/AST/ItaniumMangle.cpp @@ -2419,6 +2419,7 @@ bool CXXNameMangler::mangleUnresolvedTypeOrSimpleId(QualType Ty, case Type::Paren: case Type::Attributed: case Type::BTFTagAttributed: + case Type::HLSLAttributedResource: case Type::Auto: case Type::DeducedTemplateSpecialization: case Type::PackExpansion: diff --git a/clang/lib/AST/TypeLoc.cpp b/clang/lib/AST/TypeLoc.cpp index 0d653d6faaa829..8aada7e603407e 100644 --- a/clang/lib/AST/TypeLoc.cpp +++ b/clang/lib/AST/TypeLoc.cpp @@ -726,6 +726,11 @@ namespace { return Visit(T.getWrappedLoc()); } + TypeLoc + VisitHLSLAttributedResourceTypeLoc(HLSLAttributedResourceTypeLoc T) { + return Visit(T.getWrappedLoc()); + } + TypeLoc VisitMacroQualifiedTypeLoc(MacroQualifiedTypeLoc T) { return Visit(T.getInnerLoc()); } diff --git a/clang/lib/AST/TypePrinter.cpp b/clang/lib/AST/TypePrinter.cpp index f9bf63aa86e731..92812bebeb5b47 100644 --- a/clang/lib/AST/TypePrinter.cpp +++ b/clang/lib/AST/TypePrinter.cpp @@ -247,6 +247,7 @@ bool TypePrinter::canPrefixQualifiers(const Type *T, case Type::BitInt: case Type::DependentBitInt: case Type::BTFTagAttributed: + case Type::HLSLAttributedResource: CanPrefixQualifiers = true; break; @@ -2048,6 +2049,23 @@ void TypePrinter::printBTFTagAttributedAfter(const BTFTagAttributedType *T, printAfter(T->getWrappedType(), OS); } +void TypePrinter::printHLSLAttributedResourceBefore( + const HLSLAttributedResourceType *T, raw_ostream &OS) { + printBefore(T->getWrappedType(), OS); + + const HLSLAttributedResourceType::Attributes &Attrs = T->getAttrs(); + OS << " [[hlsl::resource_class(" + << HLSLResourceClassAttr::ConvertResourceClassToStr(Attrs.ResourceClass) + << ")]]"; + if (Attrs.IsROV) + OS << " [[hlsl::is_rov()]]"; +} + +void TypePrinter::printHLSLAttributedResourceAfter( + const HLSLAttributedResourceType *T, raw_ostream &OS) { + printAfter(T->getWrappedType(), OS); +} + void TypePrinter::printObjCInterfaceBefore(const ObjCInterfaceType *T, raw_ostream &OS) { OS << T->getDecl()->getName(); diff --git a/clang/lib/CodeGen/CGDebugInfo.cpp b/clang/lib/CodeGen/CGDebugInfo.cpp index dc83d596e3cb06..1cd80a4bf5e3fa 100644 --- a/clang/lib/CodeGen/CGDebugInfo.cpp +++ b/clang/lib/CodeGen/CGDebugInfo.cpp @@ -3851,6 +3851,7 @@ llvm::DIType *CGDebugInfo::CreateTypeNode(QualType Ty, llvm::DIFile *Unit) { case Type::Auto: case Type::Attributed: case Type::BTFTagAttributed: + case Type::HLSLAttributedResource: case Type::Adjusted: case Type::Decayed: case Type::DeducedTemplateSpecialization: diff --git a/clang/lib/CodeGen/CodeGenFunction.cpp b/clang/lib/CodeGen/CodeGenFunction.cpp index a5747283e98058..fae26d11feca24 100644 --- a/clang/lib/CodeGen/CodeGenFunction.cpp +++ b/clang/lib/CodeGen/CodeGenFunction.cpp @@ -2493,6 +2493,7 @@ void CodeGenFunction::EmitVariablyModifiedType(QualType type) { case Type::UnaryTransform: case Type::Attributed: case Type::BTFTagAttributed: + case Type::HLSLAttributedResource: case Type::SubstTemplateTypeParm: case Type::MacroQualified: case Type::CountAttributed: diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp index dcb08790911e74..092d174a811c60 100644 --- a/clang/lib/Sema/SemaExpr.cpp +++ b/clang/lib/Sema/SemaExpr.cpp @@ -4467,6 +4467,7 @@ static void captureVariablyModifiedType(ASTContext &Context, QualType T, case Type::UnaryTransform: case Type::Attributed: case Type::BTFTagAttributed: + case Type::HLSLAttributedResource: case Type::SubstTemplateTypeParm: case Type::MacroQualified: case Type::CountAttributed: diff --git a/clang/lib/Sema/SemaHLSL.cpp b/clang/lib/Sema/SemaHLSL.cpp index 714e8f5cfa9926..65972987458d70 100644 --- a/clang/lib/Sema/SemaHLSL.cpp +++ b/clang/lib/Sema/SemaHLSL.cpp @@ -14,6 +14,7 @@ #include "clang/AST/RecursiveASTVisitor.h" #include "clang/Basic/DiagnosticSema.h" #include "clang/Basic/LLVM.h" +#include "clang/Basic/SourceLocation.h" #include "clang/Basic/TargetInfo.h" #include "clang/Sema/ParsedAttr.h" #include "clang/Sema/Sema.h" @@ -467,6 +468,27 @@ void SemaHLSL::handleResourceClassAttr(Decl *D, const ParsedAttr &AL) { D->addAttr(HLSLResourceClassAttr::Create(getASTContext(), RC, ArgLoc)); } +// Validates HLSL resource type attribute and adds it to the list to be +// processed into a single HLSLAttributedResourceType later on. +// Returns false if the attribute is invalid. +bool SemaHLSL::handleResourceTypeAttr(const ParsedAttr &AL) { + // FIXME: placeholder - not yet implemented + return true; +} + +// Combines all resource type attributes and create HLSLAttributedResourceType. +QualType SemaHLSL::ProcessResourceTypeAttributes(QualType CurrentType) { + // FIXME: placeholder - not yet implemented + return CurrentType; +} + +// Returns source location for the HLSLAttributedResourceType +SourceLocation +SemaHLSL::TakeLocForHLSLAttribute(const HLSLAttributedResourceType *RT) { + // FIXME: placeholder - not yet implemented + return SourceLocation(); +} + struct RegisterBindingFlags { bool Resource = false; bool UDT = false; diff --git a/clang/lib/Sema/SemaType.cpp b/clang/lib/Sema/SemaType.cpp index 4b1bb05464f7dc..56c4031ada0d1f 100644 --- a/clang/lib/Sema/SemaType.cpp +++ b/clang/lib/Sema/SemaType.cpp @@ -25,6 +25,7 @@ #include "clang/AST/Type.h" #include "clang/AST/TypeLoc.h" #include "clang/AST/TypeLocVisitor.h" +#include "clang/Basic/LangOptions.h" #include "clang/Basic/PartialDiagnostic.h" #include "clang/Basic/SourceLocation.h" #include "clang/Basic/Specifiers.h" @@ -37,6 +38,7 @@ #include "clang/Sema/ParsedTemplate.h" #include "clang/Sema/ScopeInfo.h" #include "clang/Sema/SemaCUDA.h" +#include "clang/Sema/SemaHLSL.h" #include "clang/Sema/SemaInternal.h" #include "clang/Sema/SemaObjC.h" #include "clang/Sema/SemaOpenMP.h" @@ -1546,6 +1548,9 @@ static QualType ConvertDeclSpecToType(TypeProcessingState &state) { Result = Qualified; } + if (S.getLangOpts().HLSL) + Result = S.HLSL().ProcessResourceTypeAttributes(Result); + assert(!Result.isNull() && "This function should not return a null type"); return Result; } @@ -5783,6 +5788,12 @@ static void fillAttributedTypeLoc(AttributedTypeLoc TL, TL.setAttr(State.takeAttrForAttributedType(TL.getTypePtr())); } +static void fillHLSLAttributedResourceTypeLoc(HLSLAttributedResourceTypeLoc TL, + TypeProcessingState &State) { + TL.setSourceRange( + State.getSema().HLSL().TakeLocForHLSLAttribute(TL.getTypePtr())); +} + static void fillMatrixTypeLoc(MatrixTypeLoc MTL, const ParsedAttributesView &Attrs) { for (const ParsedAttr &AL : Attrs) { @@ -5817,6 +5828,10 @@ namespace { void VisitBTFTagAttributedTypeLoc(BTFTagAttributedTypeLoc TL) { Visit(TL.getWrappedLoc()); } + void VisitHLSLAttributedResourceTypeLoc(HLSLAttributedResourceTypeLoc TL) { + Visit(TL.getWrappedLoc()); + fillHLSLAttributedResourceTypeLoc(TL, State); + } void VisitMacroQualifiedTypeLoc(MacroQualifiedTypeLoc TL) { Visit(TL.getInnerLoc()); TL.setExpansionLoc( @@ -8803,6 +8818,12 @@ static void processTypeAttrs(TypeProcessingState &state, QualType &type, attr.setUsedAsTypeAttr(); break; } + case ParsedAttr::AT_HLSLResourceClass: + case ParsedAttr::AT_HLSLROV: { + if (state.getSema().HLSL().handleResourceTypeAttr(attr)) + attr.setUsedAsTypeAttr(); + break; + } } // Handle attributes that are defined in a macro. We do not want this to be diff --git a/clang/lib/Sema/TreeTransform.h b/clang/lib/Sema/TreeTransform.h index b3854cd8f82220..a4d5d71bd11274 100644 --- a/clang/lib/Sema/TreeTransform.h +++ b/clang/lib/Sema/TreeTransform.h @@ -7459,6 +7459,13 @@ QualType TreeTransform<Derived>::TransformBTFTagAttributedType( llvm_unreachable("Unexpected TreeTransform for BTFTagAttributedType"); } +template <typename Derived> +QualType TreeTransform<Derived>::TransformHLSLAttributedResourceType( + TypeLocBuilder &TLB, HLSLAttributedResourceTypeLoc TL) { + llvm_unreachable( + "Unexpected TreeTransform for HLSLAttributedResourceTypeLoc"); +} + template<typename Derived> QualType TreeTransform<Derived>::TransformParenType(TypeLocBuilder &TLB, diff --git a/clang/lib/Serialization/ASTReader.cpp b/clang/lib/Serialization/ASTReader.cpp index a0abd4a2bd0f5b..bb4db089a765ce 100644 --- a/clang/lib/Serialization/ASTReader.cpp +++ b/clang/lib/Serialization/ASTReader.cpp @@ -7049,6 +7049,11 @@ void TypeLocReader::VisitBTFTagAttributedTypeLoc(BTFTagAttributedTypeLoc TL) { // Nothing to do. } +void TypeLocReader::VisitHLSLAttributedResourceTypeLoc( + HLSLAttributedResourceTypeLoc TL) { + // Nothing to do. +} + void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { TL.setNameLoc(readSourceLocation()); } diff --git a/clang/lib/Serialization/ASTWriter.cpp b/clang/lib/Serialization/ASTWriter.cpp index 3e60f1425f88ea..c6289493fce1de 100644 --- a/clang/lib/Serialization/ASTWriter.cpp +++ b/clang/lib/Serialization/ASTWriter.cpp @@ -34,6 +34,7 @@ #include "clang/AST/RawCommentList.h" #include "clang/AST/TemplateName.h" #include "clang/AST/Type.h" +#include "clang/AST/TypeLoc.h" #include "clang/AST/TypeLocVisitor.h" #include "clang/Basic/Diagnostic.h" #include "clang/Basic/DiagnosticOptions.h" @@ -559,6 +560,11 @@ void TypeLocWriter::VisitBTFTagAttributedTypeLoc(BTFTagAttributedTypeLoc TL) { // Nothing to do. } +void TypeLocWriter::VisitHLSLAttributedResourceTypeLoc( + HLSLAttributedResourceTypeLoc TL) { + // Nothing to do. +} + void TypeLocWriter::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { addSourceLocation(TL.getNameLoc()); } diff --git a/clang/tools/libclang/CIndex.cpp b/clang/tools/libclang/CIndex.cpp index 66636f2c665feb..08562e05ab658d 100644 --- a/clang/tools/libclang/CIndex.cpp +++ b/clang/tools/libclang/CIndex.cpp @@ -1787,6 +1787,11 @@ bool CursorVisitor::VisitBTFTagAttributedTypeLoc(BTFTagAttributedTypeLoc TL) { return Visit(TL.getWrappedLoc()); } +bool CursorVisitor::VisitHLSLAttributedResourceTypeLoc( + HLSLAttributedResourceTypeLoc TL) { + return Visit(TL.getWrappedLoc()); +} + bool CursorVisitor::VisitFunctionTypeLoc(FunctionTypeLoc TL, bool SkipResultType) { if (!SkipResultType && Visit(TL.getReturnLoc())) diff --git a/clang/tools/libclang/CXType.cpp b/clang/tools/libclang/CXType.cpp index f5d1fbf30c7dc4..b4df12405cf356 100644 --- a/clang/tools/libclang/CXType.cpp +++ b/clang/tools/libclang/CXType.cpp @@ -620,6 +620,7 @@ CXString clang_getTypeKindSpelling(enum CXTypeKind K) { TKIND(Pipe); TKIND(Attributed); TKIND(BTFTagAttributed); + TKIND(HLSLAttributedResource); TKIND(BFloat16); #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) TKIND(Id); #include "clang/Basic/OpenCLImageTypes.def" _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
