llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-debuginfo
@llvm/pr-subscribers-clang-codegen
@llvm/pr-subscribers-hlsl
@llvm/pr-subscribers-clang
Author: Helena Kotas (hekota)
<details>
<summary>Changes</summary>
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 attributes parameters. This does not work for the HLSL resource
type 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 potentially 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
---
Patch is 26.13 KiB, truncated to 20.00 KiB below, full version:
https://github.com/llvm/llvm-project/pull/106181.diff
26 Files Affected:
- (modified) clang/include/clang-c/Index.h (+3-2)
- (modified) clang/include/clang/AST/ASTContext.h (+5)
- (modified) clang/include/clang/AST/ASTNodeTraverser.h (+5)
- (modified) clang/include/clang/AST/RecursiveASTVisitor.h (+6)
- (modified) clang/include/clang/AST/Type.h (+59)
- (modified) clang/include/clang/AST/TypeLoc.h (+19)
- (modified) clang/include/clang/AST/TypeProperties.td (+16)
- (modified) clang/include/clang/Basic/TypeNodes.td (+1)
- (modified) clang/include/clang/Sema/SemaHLSL.h (+3)
- (modified) clang/include/clang/Serialization/TypeBitCodes.def (+1)
- (modified) clang/lib/AST/ASTContext.cpp (+27)
- (modified) clang/lib/AST/ASTImporter.cpp (+13)
- (modified) clang/lib/AST/ASTStructuralEquivalence.cpp (+14)
- (modified) clang/lib/AST/ItaniumMangle.cpp (+1)
- (modified) clang/lib/AST/TypeLoc.cpp (+5)
- (modified) clang/lib/AST/TypePrinter.cpp (+12)
- (modified) clang/lib/CodeGen/CGDebugInfo.cpp (+1)
- (modified) clang/lib/CodeGen/CodeGenFunction.cpp (+1)
- (modified) clang/lib/Sema/SemaExpr.cpp (+1)
- (modified) clang/lib/Sema/SemaHLSL.cpp (+22)
- (modified) clang/lib/Sema/SemaType.cpp (+22)
- (modified) clang/lib/Sema/TreeTransform.h (+7)
- (modified) clang/lib/Serialization/ASTReader.cpp (+5)
- (modified) clang/lib/Serialization/ASTWriter.cpp (+6)
- (modified) clang/tools/libclang/CIndex.cpp (+5)
- (modified) clang/tools/libclang/CXType.cpp (+1)
``````````diff
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 575f3c17a3f691..ca6b6832d5b02c 100644
--- a/clang/include/clang/AST/Type.h
+++ b/clang/include/clang/AST/Type.h
@@ -6155,6 +6155,63 @@ class BTFTagAttributedType : public Type, public
llvm::FoldingSetNode {
}
};
+class HLSLAttributedResourceType : public Type, public llvm::FoldingSetNode {
+public:
+ struct Attributes {
+ // This is where data gathered from HLSL resource attributes are stored,
+ // such as resource class, is_rov, dimension, is_array, is_feedback
+ // or is_multisample. The values will be accessed individually via fields
+ // on the embedded struct. The Data alias is used for the AST type
+ // serialization.
+ union {
+ struct {
+ uint8_t ResourceClass; // maps to llvm::dxil::ResourceClass
+ uint8_t IsROV : 1;
+ // FIXME: add additional resource properties here
+ };
+ unsigned Data;
+ };
+ Attributes() : Data() {}
+ Attributes(unsigned Data) : Data(Data) {}
+ };
+ static_assert(sizeof(Attributes) == sizeof(Attributes::Data));
+
+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(Attrs.Data);
+ }
+
+ static bool classof(const Type *T) {
+ return T->getTypeClass() == HLSLAttributedResource;
+ }
+};
+
class TemplateTypeParmType : public Type, public llvm::FoldingSetNode {
friend class ASTContext; // ASTContext creates these
@@ -8578,6 +8635,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..8e323f91050e21 100644
--- a/clang/include/clang/AST/TypeLoc.h
+++ b/clang/include/clang/AST/TypeLoc.h
@@ -940,6 +940,23 @@ 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 +2707,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..bb4961d83df239 100644
--- a/clang/include/clang/AST/TypeProperties.td
+++ b/clang/include/clang/AST/TypeProperties.td
@@ -687,6 +687,22 @@ let Class = BTFTagAttributedType in {
}]>;
}
+let Class = HLSLAttributedResourceType in {
+ def : Property<"attrsData", UInt32> {
+ let Read = [{ node->getAttrs().Data }];
+ }
+ def : Property<"wrappedTy", QualType> {
+ let Read = [{ node->getWrappedType() }];
+ }
+ def : Property<"containedTy", QualType> {
+ let Read = [{ node->getContainedType() }];
+ }
+ def : Creator<[{
+ return ctx.getHLSLAttributedResourceType(wrappedTy, containedTy,
+ HLSLAttributedResourceType::Attributes(attrsData));
+ }]>;
+}
+
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..e025920857d46a 100644
--- a/clang/lib/AST/ASTStructuralEquivalence.cpp
+++ b/clang/lib/AST/ASTStructuralEquivalence.cpp
@@ -1093,6 +1093,20 @@ 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 (cast<HLSLAttributedResourceType>(T1)->getAttrs().Data !=
+ cast<HLSLAttributedResourceType>(T2)->getAttrs().Data)
+ 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 976670d1efa561..1ca449427f60df 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..8ba7ef49c7b938 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,17 @@ void TypePrinter::printBTFTagAttributedAfter(const
BTFTagAttributedType *T,
printAfter(T->getWrappedType(), OS);
}
+void TypePrinter::printHLSLAttributedResourceBefore(
+ const HLSLAttributedResourceType *T, raw_ostream &OS) {
+ printBefore(T->getWrappedType(), OS);
+ // FIXME: print values of resource type attributes here
+}
+
+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 c89eaa0f4e3bfc..e5371e337a9320 100644
--- a/clang/lib/CodeGen/CodeGenFunction.cpp
+++ b/clang/lib/CodeGen/CodeGenFunction.cpp
@@ -2489,6 +2489,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 95f53dfefbcc52..90d45443d1f417 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...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/106181
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
