clang/lib/AST/AttrImpl.cpp - llvm-project - Git at Google

 //===--- AttrImpl.cpp - Classes for representing attributes -----*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file contains out-of-line methods for Attr classes.
 //
 //===----------------------------------------------------------------------===//

 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTStructuralEquivalence.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/Type.h"
 #include <optional>
 #include <type_traits>
 using namespace clang;

 void LoopHintAttr::printPrettyPragma(raw_ostream &OS,
                                      const PrintingPolicy &Policy) const {
   unsigned SpellingIndex = getAttributeSpellingListIndex();
   // For "#pragma unroll" and "#pragma nounroll" the string "unroll" or
   // "nounroll" is already emitted as the pragma name.
   if (SpellingIndex == Pragma_nounroll ||
       SpellingIndex == Pragma_nounroll_and_jam)
     return;
   else if (SpellingIndex == Pragma_unroll ||
            SpellingIndex == Pragma_unroll_and_jam) {
     OS << ' ' << getValueString(Policy);
     return;
   }

   assert(SpellingIndex == Pragma_clang_loop && "Unexpected spelling");
   OS << ' ' << getOptionName(option) << getValueString(Policy);
 }

 // Return a string containing the loop hint argument including the
 // enclosing parentheses.
 std::string LoopHintAttr::getValueString(const PrintingPolicy &Policy) const {
   std::string ValueName;
   llvm::raw_string_ostream OS(ValueName);
   OS << "(";
   if (state == Numeric)
     value->printPretty(OS, nullptr, Policy);
   else if (state == FixedWidth || state == ScalableWidth) {
     if (value) {
       value->printPretty(OS, nullptr, Policy);
       if (state == ScalableWidth)
         OS << ", scalable";
     } else if (state == ScalableWidth)
       OS << "scalable";
     else
       OS << "fixed";
   } else if (state == Enable)
     OS << "enable";
   else if (state == Full)
     OS << "full";
   else if (state == AssumeSafety)
     OS << "assume_safety";
   else
     OS << "disable";
   OS << ")";
   return ValueName;
 }

 // Return a string suitable for identifying this attribute in diagnostics.
 std::string
 LoopHintAttr::getDiagnosticName(const PrintingPolicy &Policy) const {
   unsigned SpellingIndex = getAttributeSpellingListIndex();
   if (SpellingIndex == Pragma_nounroll)
     return "#pragma nounroll";
   else if (SpellingIndex == Pragma_unroll)
     return "#pragma unroll" +
            (option == UnrollCount ? getValueString(Policy) : "");
   else if (SpellingIndex == Pragma_nounroll_and_jam)
     return "#pragma nounroll_and_jam";
   else if (SpellingIndex == Pragma_unroll_and_jam)
     return "#pragma unroll_and_jam" +
            (option == UnrollAndJamCount ? getValueString(Policy) : "");

   assert(SpellingIndex == Pragma_clang_loop && "Unexpected spelling");
   return getOptionName(option) + getValueString(Policy);
 }

 void OMPDeclareSimdDeclAttr::printPrettyPragma(
     raw_ostream &OS, const PrintingPolicy &Policy) const {
   if (getBranchState() != BS_Undefined)
     OS << ' ' << ConvertBranchStateTyToStr(getBranchState());
   if (auto *E = getSimdlen()) {
     OS << " simdlen(";
     E->printPretty(OS, nullptr, Policy);
     OS << ")";
   }
   if (uniforms_size() > 0) {
     OS << " uniform";
     StringRef Sep = "(";
     for (auto *E : uniforms()) {
       OS << Sep;
       E->printPretty(OS, nullptr, Policy);
       Sep = ", ";
     }
     OS << ")";
   }
   alignments_iterator NI = alignments_begin();
   for (auto *E : aligneds()) {
     OS << " aligned(";
     E->printPretty(OS, nullptr, Policy);
     if (*NI) {
       OS << ": ";
       (*NI)->printPretty(OS, nullptr, Policy);
     }
     OS << ")";
     ++NI;
   }
   steps_iterator I = steps_begin();
   modifiers_iterator MI = modifiers_begin();
   for (auto *E : linears()) {
     OS << " linear(";
     if (*MI != OMPC_LINEAR_unknown)
       OS << getOpenMPSimpleClauseTypeName(llvm::omp::Clause::OMPC_linear, *MI)
          << "(";
     E->printPretty(OS, nullptr, Policy);
     if (*MI != OMPC_LINEAR_unknown)
       OS << ")";
     if (*I) {
       OS << ": ";
       (*I)->printPretty(OS, nullptr, Policy);
     }
     OS << ")";
     ++I;
     ++MI;
   }
 }

 void OMPDeclareTargetDeclAttr::printPrettyPragma(
     raw_ostream &OS, const PrintingPolicy &Policy) const {
   // Use fake syntax because it is for testing and debugging purpose only.
   if (getDevType() != DT_Any)
     OS << " device_type(" << ConvertDevTypeTyToStr(getDevType()) << ")";
   if (getMapType() != MT_To && getMapType() != MT_Enter)
     OS << ' ' << ConvertMapTypeTyToStr(getMapType());
   if (Expr *E = getIndirectExpr()) {
     OS << " indirect(";
     E->printPretty(OS, nullptr, Policy);
     OS << ")";
   } else if (getIndirect()) {
     OS << " indirect";
   }
 }

 std::optional<OMPDeclareTargetDeclAttr *>
 OMPDeclareTargetDeclAttr::getActiveAttr(const ValueDecl *VD) {
   if (llvm::all_of(VD->redecls(), [](const Decl *D) { return !D->hasAttrs(); }))
     return std::nullopt;
   unsigned Level = 0;
   OMPDeclareTargetDeclAttr *FoundAttr = nullptr;
   for (const Decl *D : VD->redecls()) {
     for (auto *Attr : D->specific_attrs<OMPDeclareTargetDeclAttr>()) {
       if (Level <= Attr->getLevel()) {
         Level = Attr->getLevel();
         FoundAttr = Attr;
       }
     }
   }
   if (FoundAttr)
     return FoundAttr;
   return std::nullopt;
 }

 std::optional<OMPDeclareTargetDeclAttr::MapTypeTy>
 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(const ValueDecl *VD) {
   std::optional<OMPDeclareTargetDeclAttr *> ActiveAttr = getActiveAttr(VD);
   if (ActiveAttr)
     return (*ActiveAttr)->getMapType();
   return std::nullopt;
 }

 std::optional<OMPDeclareTargetDeclAttr::DevTypeTy>
 OMPDeclareTargetDeclAttr::getDeviceType(const ValueDecl *VD) {
   std::optional<OMPDeclareTargetDeclAttr *> ActiveAttr = getActiveAttr(VD);
   if (ActiveAttr)
     return (*ActiveAttr)->getDevType();
   return std::nullopt;
 }

 std::optional<SourceLocation>
 OMPDeclareTargetDeclAttr::getLocation(const ValueDecl *VD) {
   std::optional<OMPDeclareTargetDeclAttr *> ActiveAttr = getActiveAttr(VD);
   if (ActiveAttr)
     return (*ActiveAttr)->getRange().getBegin();
   return std::nullopt;
 }

 namespace clang {
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const OMPTraitInfo &TI);
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const OMPTraitInfo *TI);
 }

 void OMPDeclareVariantAttr::printPrettyPragma(
     raw_ostream &OS, const PrintingPolicy &Policy) const {
   if (const Expr *E = getVariantFuncRef()) {
     OS << "(";
     E->printPretty(OS, nullptr, Policy);
     OS << ")";
   }
   OS << " match(" << traitInfos << ")";

   auto PrintExprs = [&OS, &Policy](Expr **Begin, Expr **End) {
     for (Expr **I = Begin; I != End; ++I) {
       assert(*I && "Expected non-null Stmt");
       if (I != Begin)
         OS << ",";
       (*I)->printPretty(OS, nullptr, Policy);
     }
   };
   if (adjustArgsNothing_size()) {
     OS << " adjust_args(nothing:";
     PrintExprs(adjustArgsNothing_begin(), adjustArgsNothing_end());
     OS << ")";
   }
   if (adjustArgsNeedDevicePtr_size()) {
     OS << " adjust_args(need_device_ptr:";
     PrintExprs(adjustArgsNeedDevicePtr_begin(), adjustArgsNeedDevicePtr_end());
     OS << ")";
   }
   if (adjustArgsNeedDeviceAddr_size()) {
     OS << " adjust_args(need_device_addr:";
     PrintExprs(adjustArgsNeedDeviceAddr_begin(),
                adjustArgsNeedDeviceAddr_end());
     OS << ")";
   }

   auto PrintInteropInfo = [&OS, &Policy](OMPInteropInfo *Begin,
                                          OMPInteropInfo *End) {
     for (OMPInteropInfo *I = Begin; I != End; ++I) {
       if (I != Begin)
         OS << ", ";
       OS << "interop(";
       if (!I->Prefs.empty()) {
         OS << "prefer_type(";
         if (I->HasPreferAttrs) {
           StringRef Sep = "";
           for (const auto &P : I->Prefs) {
             OS << Sep << "{";
             if (P.Fr) {
               OS << "fr(";
               P.Fr->printPretty(OS, nullptr, Policy);
               OS << ")";
             }
             bool NeedSep = P.Fr != nullptr;
             for (Expr *A : P.Attrs) {
               if (NeedSep)
                 OS << ",";
               OS << "attr(";
               A->printPretty(OS, nullptr, Policy);
               OS << ")";
               NeedSep = true;
             }
             OS << "}";
             Sep = ",";
           }
         } else {
           StringRef Sep = "";
           for (const auto &P : I->Prefs) {
             OS << Sep;
             if (P.Fr)
               P.Fr->printPretty(OS, nullptr, Policy);
             Sep = ",";
           }
         }
         OS << "),";
       }
       OS << getInteropTypeString(I);
       OS << ")";
     }
   };
   if (appendArgs_size()) {
     OS << " append_args(";
     PrintInteropInfo(appendArgs_begin(), appendArgs_end());
     OS << ")";
   }
 }

 unsigned AlignedAttr::getAlignment(ASTContext &Ctx) const {
   assert(!isAlignmentDependent());
   if (getCachedAlignmentValue())
     return *getCachedAlignmentValue();

   // Handle alignmentType case.
   if (!isAlignmentExpr()) {
     QualType T = getAlignmentType()->getType();

     // C++ [expr.alignof]p3:
     //     When alignof is applied to a reference type, the result is the
     //     alignment of the referenced type.
     T = T.getNonReferenceType();

     if (T.getQualifiers().hasUnaligned())
       return Ctx.getCharWidth();

     return Ctx.getTypeAlignInChars(T.getTypePtr()).getQuantity() *
            Ctx.getCharWidth();
   }

   // Handle alignmentExpr case.
   if (alignmentExpr)
     return alignmentExpr->EvaluateKnownConstInt(Ctx).getZExtValue() *
            Ctx.getCharWidth();

   return Ctx.getTargetDefaultAlignForAttributeAligned();
 }

 StringLiteral *FormatMatchesAttr::getFormatString() const {
   return cast<StringLiteral>(getExpectedFormat());
 }

 namespace {
 // Arguments whose types fail this test never compare equal unless there's a
 // specialization of equalAttrArgs for the type. Specilization for the following
 // arguments haven't been implemented yet:
 //  - DeclArgument
 //  - OMPTraitInfoArgument
 //  - VariadicOMPInteropInfoArgument
 #define USE_DEFAULT_EQUALITY                                                   \
   (std::is_same_v<T, StringRef> || std::is_same_v<T, VersionTuple> ||          \
    std::is_same_v<T, IdentifierInfo *> || std::is_same_v<T, char *> ||         \
    std::is_enum_v<T> || std::is_integral_v<T>)

 template <class T>
 typename std::enable_if_t<!USE_DEFAULT_EQUALITY, bool>
 equalAttrArgs(T A, T B, StructuralEquivalenceContext &Context) {
   return false;
 }

 template <class T>
 typename std::enable_if_t<USE_DEFAULT_EQUALITY, bool>
 equalAttrArgs(T A1, T A2, StructuralEquivalenceContext &Context) {
   return A1 == A2;
 }

 template <>
 bool equalAttrArgs<ParamIdx>(ParamIdx P1, ParamIdx P2,
                              StructuralEquivalenceContext &) {
   // ParamIdx can be invalid when representing an optional parameter that was
   // not specified (e.g. the second argument of alloc_size(N)).
   // ParamIdx::operator== asserts both sides are valid, so guard against the
   // invalid case before delegating to it.
   if (P1.isValid() != P2.isValid())
     return false;
   if (!P1.isValid())
     return true;
   return P1 == P2;
 }

 template <class T>
 bool equalAttrArgs(T *A1_B, T *A1_E, T *A2_B, T *A2_E,
                    StructuralEquivalenceContext &Context) {
   if (A1_E - A1_B != A2_E - A2_B)
     return false;

   for (; A1_B != A1_E; ++A1_B, ++A2_B)
     if (!equalAttrArgs(*A1_B, *A2_B, Context))
       return false;

   return true;
 }

 template <>
 bool equalAttrArgs<Attr *>(Attr *A1, Attr *A2,
                            StructuralEquivalenceContext &Context) {
   if (!A1 || !A2)
     return A1 == A2;
   return A1->isEquivalent(*A2, Context);
 }

 template <>
 bool equalAttrArgs<Expr *>(Expr *A1, Expr *A2,
                            StructuralEquivalenceContext &Context) {
   return ASTStructuralEquivalence::isEquivalent(Context, A1, A2);
 }

 template <>
 bool equalAttrArgs<QualType>(QualType T1, QualType T2,
                              StructuralEquivalenceContext &Context) {
   return ASTStructuralEquivalence::isEquivalent(Context, T1, T2);
 }

 template <>
 bool equalAttrArgs<const IdentifierInfo *>(
     const IdentifierInfo *Name1, const IdentifierInfo *Name2,
     StructuralEquivalenceContext &Context) {
   return ASTStructuralEquivalence::isEquivalent(Name1, Name2);
 }

 bool areAlignedAttrsEqual(const AlignedAttr &A1, const AlignedAttr &A2,
                           StructuralEquivalenceContext &Context) {
   if (A1.getSpelling() != A2.getSpelling())
     return false;

   if (A1.isAlignmentExpr() != A2.isAlignmentExpr())
     return false;

   if (A1.isAlignmentExpr())
     return equalAttrArgs(A1.getAlignmentExpr(), A2.getAlignmentExpr(), Context);

   return equalAttrArgs(A1.getAlignmentType()->getType(),
                        A2.getAlignmentType()->getType(), Context);
 }
 } // namespace

 namespace {
 // Machinery to unique attributes based on the arguments.
 // The construction mirrors the equivalent testing code above.
 // The content of the arguments are added to the FoldingSetNodeID instance,
 // which allows the AttributedTypes to unique the attributes based on
 // the value of the arguments.

 #define USE_DEFAULT_PROFILE                                                    \
   (std::is_same_v<T, StringRef> || std::is_same_v<T, VersionTuple> ||          \
    std::is_same_v<T, IdentifierInfo *> ||                                      \
    std::is_same_v<T, const IdentifierInfo *> || std::is_enum_v<T> ||           \
    std::is_integral_v<T>)

 template <class T>
 typename std::enable_if_t<!USE_DEFAULT_PROFILE>
 profileAttrArg(llvm::FoldingSetNodeID &, const ASTContext &, T) {
   llvm_unreachable("profile not implemented for this type");
 }

 template <class T>
 typename std::enable_if_t<USE_DEFAULT_PROFILE>
 profileAttrArg(llvm::FoldingSetNodeID &ID, const ASTContext &, T V) {
   if constexpr (std::is_same_v<T, StringRef>)
     ID.AddString(V);
   else if constexpr (std::is_same_v<T, VersionTuple>) {
     ID.AddInteger(V.getMajor());
     ID.AddInteger(V.getMinor().value_or(0));
     ID.AddInteger(V.getSubminor().value_or(0));
     ID.AddInteger(V.getBuild().value_or(0));
   } else if constexpr (std::is_same_v<T, IdentifierInfo *> ||
                        std::is_same_v<T, const IdentifierInfo *>)
     ID.AddPointer(V);
   else
     ID.AddInteger(static_cast<long long>(V));
 }

 template <>
 inline void profileAttrArg<ParamIdx>(llvm::FoldingSetNodeID &ID,
                                      const ASTContext &, ParamIdx P) {
   ID.AddBoolean(P.isValid());
   if (P.isValid())
     ID.AddInteger(P.getASTIndex());
 }

 template <class T>
 inline void profileAttrArg(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx,
                            T *Begin, T *End) {
   ID.AddInteger(End - Begin);
   for (; Begin != End; ++Begin)
     profileAttrArg(ID, Ctx, *Begin);
 }

 template <>
 inline void profileAttrArg<Attr *>(llvm::FoldingSetNodeID &ID,
                                    const ASTContext &Ctx, Attr *A) {
   if (!A) {
     ID.AddPointer(nullptr);
     return;
   }
   ID.AddInteger(A->getKind());
   A->Profile(ID, Ctx);
 }

 template <>
 inline void profileAttrArg<Expr *>(llvm::FoldingSetNodeID &ID,
                                    const ASTContext &Ctx, Expr *E) {
   E->Profile(ID, Ctx, /*Canonical=*/true);
 }

 template <>
 inline void profileAttrArg<QualType>(llvm::FoldingSetNodeID &ID,
                                      const ASTContext &, QualType T) {
   ID.AddPointer(T.getCanonicalType().getAsOpaquePtr());
 }

 void profileAlignedAttr(const AlignedAttr &A, llvm::FoldingSetNodeID &ID,
                         const ASTContext &Ctx) {
   ID.AddInteger(A.getSpellingListIndex());
   ID.AddBoolean(A.isAlignmentExpr());
   if (A.isAlignmentExpr())
     profileAttrArg(ID, Ctx, A.getAlignmentExpr());
   else
     profileAttrArg(ID, Ctx, A.getAlignmentType()->getType());
 }
 } // namespace

 #include "clang/AST/AttrImpl.inc"
	//===--- AttrImpl.cpp - Classes for representing attributes ------ C++ --===//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//
	//
	// This file contains out-of-line methods for Attr classes.
	//
	//===----------------------------------------------------------------------===//

	#include "clang/AST/ASTContext.h"
	#include "clang/AST/ASTStructuralEquivalence.h"
	#include "clang/AST/Attr.h"
	#include "clang/AST/Expr.h"
	#include "clang/AST/Type.h"
	#include <optional>
	#include <type_traits>
	using namespace clang;

	void LoopHintAttr::printPrettyPragma(raw_ostream &OS,
	const PrintingPolicy &Policy) const {
	unsigned SpellingIndex = getAttributeSpellingListIndex();
	// For "#pragma unroll" and "#pragma nounroll" the string "unroll" or
	// "nounroll" is already emitted as the pragma name.
	if (SpellingIndex == Pragma_nounroll \|\|
	SpellingIndex == Pragma_nounroll_and_jam)
	return;
	else if (SpellingIndex == Pragma_unroll \|\|
	SpellingIndex == Pragma_unroll_and_jam) {
	OS << ' ' << getValueString(Policy);
	return;
	}

	assert(SpellingIndex == Pragma_clang_loop && "Unexpected spelling");
	OS << ' ' << getOptionName(option) << getValueString(Policy);
	}

	// Return a string containing the loop hint argument including the
	// enclosing parentheses.
	std::string LoopHintAttr::getValueString(const PrintingPolicy &Policy) const {
	std::string ValueName;
	llvm::raw_string_ostream OS(ValueName);
	OS << "(";
	if (state == Numeric)
	value->printPretty(OS, nullptr, Policy);
	else if (state == FixedWidth \|\| state == ScalableWidth) {
	if (value) {
	value->printPretty(OS, nullptr, Policy);
	if (state == ScalableWidth)
	OS << ", scalable";
	} else if (state == ScalableWidth)
	OS << "scalable";
	else
	OS << "fixed";
	} else if (state == Enable)
	OS << "enable";
	else if (state == Full)
	OS << "full";
	else if (state == AssumeSafety)
	OS << "assume_safety";
	else
	OS << "disable";
	OS << ")";
	return ValueName;
	}

	// Return a string suitable for identifying this attribute in diagnostics.
	std::string
	LoopHintAttr::getDiagnosticName(const PrintingPolicy &Policy) const {
	unsigned SpellingIndex = getAttributeSpellingListIndex();
	if (SpellingIndex == Pragma_nounroll)
	return "#pragma nounroll";
	else if (SpellingIndex == Pragma_unroll)
	return "#pragma unroll" +
	(option == UnrollCount ? getValueString(Policy) : "");
	else if (SpellingIndex == Pragma_nounroll_and_jam)
	return "#pragma nounroll_and_jam";
	else if (SpellingIndex == Pragma_unroll_and_jam)
	return "#pragma unroll_and_jam" +
	(option == UnrollAndJamCount ? getValueString(Policy) : "");

	assert(SpellingIndex == Pragma_clang_loop && "Unexpected spelling");
	return getOptionName(option) + getValueString(Policy);
	}

	void OMPDeclareSimdDeclAttr::printPrettyPragma(
	raw_ostream &OS, const PrintingPolicy &Policy) const {
	if (getBranchState() != BS_Undefined)
	OS << ' ' << ConvertBranchStateTyToStr(getBranchState());
	if (auto *E = getSimdlen()) {
	OS << " simdlen(";
	E->printPretty(OS, nullptr, Policy);
	OS << ")";
	}
	if (uniforms_size() > 0) {
	OS << " uniform";
	StringRef Sep = "(";
	for (auto *E : uniforms()) {
	OS << Sep;
	E->printPretty(OS, nullptr, Policy);
	Sep = ", ";
	}
	OS << ")";
	}
	alignments_iterator NI = alignments_begin();
	for (auto *E : aligneds()) {
	OS << " aligned(";
	E->printPretty(OS, nullptr, Policy);
	if (*NI) {
	OS << ": ";
	(*NI)->printPretty(OS, nullptr, Policy);
	}
	OS << ")";
	++NI;
	}
	steps_iterator I = steps_begin();
	modifiers_iterator MI = modifiers_begin();
	for (auto *E : linears()) {
	OS << " linear(";
	if (*MI != OMPC_LINEAR_unknown)
	OS << getOpenMPSimpleClauseTypeName(llvm::omp::Clause::OMPC_linear, *MI)
	<< "(";
	E->printPretty(OS, nullptr, Policy);
	if (*MI != OMPC_LINEAR_unknown)
	OS << ")";
	if (*I) {
	OS << ": ";
	(*I)->printPretty(OS, nullptr, Policy);
	}
	OS << ")";
	++I;
	++MI;
	}
	}

	void OMPDeclareTargetDeclAttr::printPrettyPragma(
	raw_ostream &OS, const PrintingPolicy &Policy) const {
	// Use fake syntax because it is for testing and debugging purpose only.
	if (getDevType() != DT_Any)
	OS << " device_type(" << ConvertDevTypeTyToStr(getDevType()) << ")";
	if (getMapType() != MT_To && getMapType() != MT_Enter)
	OS << ' ' << ConvertMapTypeTyToStr(getMapType());
	if (Expr *E = getIndirectExpr()) {
	OS << " indirect(";
	E->printPretty(OS, nullptr, Policy);
	OS << ")";
	} else if (getIndirect()) {
	OS << " indirect";
	}
	}

	std::optional<OMPDeclareTargetDeclAttr *>
	OMPDeclareTargetDeclAttr::getActiveAttr(const ValueDecl *VD) {
	if (llvm::all_of(VD->redecls(), [](const Decl *D) { return !D->hasAttrs(); }))
	return std::nullopt;
	unsigned Level = 0;
	OMPDeclareTargetDeclAttr *FoundAttr = nullptr;
	for (const Decl *D : VD->redecls()) {
	for (auto *Attr : D->specific_attrs<OMPDeclareTargetDeclAttr>()) {
	if (Level <= Attr->getLevel()) {
	Level = Attr->getLevel();
	FoundAttr = Attr;
	}
	}
	}
	if (FoundAttr)
	return FoundAttr;
	return std::nullopt;
	}

	std::optional<OMPDeclareTargetDeclAttr::MapTypeTy>
	OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(const ValueDecl *VD) {
	std::optional<OMPDeclareTargetDeclAttr *> ActiveAttr = getActiveAttr(VD);
	if (ActiveAttr)
	return (*ActiveAttr)->getMapType();
	return std::nullopt;
	}

	std::optional<OMPDeclareTargetDeclAttr::DevTypeTy>
	OMPDeclareTargetDeclAttr::getDeviceType(const ValueDecl *VD) {
	std::optional<OMPDeclareTargetDeclAttr *> ActiveAttr = getActiveAttr(VD);
	if (ActiveAttr)
	return (*ActiveAttr)->getDevType();
	return std::nullopt;
	}

	std::optional<SourceLocation>
	OMPDeclareTargetDeclAttr::getLocation(const ValueDecl *VD) {
	std::optional<OMPDeclareTargetDeclAttr *> ActiveAttr = getActiveAttr(VD);
	if (ActiveAttr)
	return (*ActiveAttr)->getRange().getBegin();
	return std::nullopt;
	}

	namespace clang {
	llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const OMPTraitInfo &TI);
	llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const OMPTraitInfo *TI);
	}

	void OMPDeclareVariantAttr::printPrettyPragma(
	raw_ostream &OS, const PrintingPolicy &Policy) const {
	if (const Expr *E = getVariantFuncRef()) {
	OS << "(";
	E->printPretty(OS, nullptr, Policy);
	OS << ")";
	}
	OS << " match(" << traitInfos << ")";

	auto PrintExprs = [&OS, &Policy](Expr Begin, Expr End) {
	for (Expr **I = Begin; I != End; ++I) {
	assert(*I && "Expected non-null Stmt");
	if (I != Begin)
	OS << ",";
	(*I)->printPretty(OS, nullptr, Policy);
	}
	};
	if (adjustArgsNothing_size()) {
	OS << " adjust_args(nothing:";
	PrintExprs(adjustArgsNothing_begin(), adjustArgsNothing_end());
	OS << ")";
	}
	if (adjustArgsNeedDevicePtr_size()) {
	OS << " adjust_args(need_device_ptr:";
	PrintExprs(adjustArgsNeedDevicePtr_begin(), adjustArgsNeedDevicePtr_end());
	OS << ")";
	}
	if (adjustArgsNeedDeviceAddr_size()) {
	OS << " adjust_args(need_device_addr:";
	PrintExprs(adjustArgsNeedDeviceAddr_begin(),
	adjustArgsNeedDeviceAddr_end());
	OS << ")";
	}

	auto PrintInteropInfo = [&OS, &Policy](OMPInteropInfo *Begin,
	OMPInteropInfo *End) {
	for (OMPInteropInfo *I = Begin; I != End; ++I) {
	if (I != Begin)
	OS << ", ";
	OS << "interop(";
	if (!I->Prefs.empty()) {
	OS << "prefer_type(";
	if (I->HasPreferAttrs) {
	StringRef Sep = "";
	for (const auto &P : I->Prefs) {
	OS << Sep << "{";
	if (P.Fr) {
	OS << "fr(";
	P.Fr->printPretty(OS, nullptr, Policy);
	OS << ")";
	}
	bool NeedSep = P.Fr != nullptr;
	for (Expr *A : P.Attrs) {
	if (NeedSep)
	OS << ",";
	OS << "attr(";
	A->printPretty(OS, nullptr, Policy);
	OS << ")";
	NeedSep = true;
	}
	OS << "}";
	Sep = ",";
	}
	} else {
	StringRef Sep = "";
	for (const auto &P : I->Prefs) {
	OS << Sep;
	if (P.Fr)
	P.Fr->printPretty(OS, nullptr, Policy);
	Sep = ",";
	}
	}
	OS << "),";
	}
	OS << getInteropTypeString(I);
	OS << ")";
	}
	};
	if (appendArgs_size()) {
	OS << " append_args(";
	PrintInteropInfo(appendArgs_begin(), appendArgs_end());
	OS << ")";
	}
	}

	unsigned AlignedAttr::getAlignment(ASTContext &Ctx) const {
	assert(!isAlignmentDependent());
	if (getCachedAlignmentValue())
	return *getCachedAlignmentValue();

	// Handle alignmentType case.
	if (!isAlignmentExpr()) {
	QualType T = getAlignmentType()->getType();

	// C++ [expr.alignof]p3:
	// When alignof is applied to a reference type, the result is the
	// alignment of the referenced type.
	T = T.getNonReferenceType();

	if (T.getQualifiers().hasUnaligned())
	return Ctx.getCharWidth();

	return Ctx.getTypeAlignInChars(T.getTypePtr()).getQuantity() *
	Ctx.getCharWidth();
	}

	// Handle alignmentExpr case.
	if (alignmentExpr)
	return alignmentExpr->EvaluateKnownConstInt(Ctx).getZExtValue() *
	Ctx.getCharWidth();

	return Ctx.getTargetDefaultAlignForAttributeAligned();
	}

	StringLiteral *FormatMatchesAttr::getFormatString() const {
	return cast<StringLiteral>(getExpectedFormat());
	}

	namespace {
	// Arguments whose types fail this test never compare equal unless there's a
	// specialization of equalAttrArgs for the type. Specilization for the following
	// arguments haven't been implemented yet:
	// - DeclArgument
	// - OMPTraitInfoArgument
	// - VariadicOMPInteropInfoArgument
	#define USE_DEFAULT_EQUALITY \
	(std::is_same_v<T, StringRef> \|\| std::is_same_v<T, VersionTuple> \|\| \
	std::is_same_v<T, IdentifierInfo > \|\| std::is_same_v<T, char > \|\| \
	std::is_enum_v<T> \|\| std::is_integral_v<T>)

	template <class T>
	typename std::enable_if_t<!USE_DEFAULT_EQUALITY, bool>
	equalAttrArgs(T A, T B, StructuralEquivalenceContext &Context) {
	return false;
	}

	template <class T>
	typename std::enable_if_t<USE_DEFAULT_EQUALITY, bool>
	equalAttrArgs(T A1, T A2, StructuralEquivalenceContext &Context) {
	return A1 == A2;
	}

	template <>
	bool equalAttrArgs<ParamIdx>(ParamIdx P1, ParamIdx P2,
	StructuralEquivalenceContext &) {
	// ParamIdx can be invalid when representing an optional parameter that was
	// not specified (e.g. the second argument of alloc_size(N)).
	// ParamIdx::operator== asserts both sides are valid, so guard against the
	// invalid case before delegating to it.
	if (P1.isValid() != P2.isValid())
	return false;
	if (!P1.isValid())
	return true;
	return P1 == P2;
	}

	template <class T>
	bool equalAttrArgs(T A1_B, T A1_E, T A2_B, T A2_E,
	StructuralEquivalenceContext &Context) {
	if (A1_E - A1_B != A2_E - A2_B)
	return false;

	for (; A1_B != A1_E; ++A1_B, ++A2_B)
	if (!equalAttrArgs(A1_B, A2_B, Context))
	return false;

	return true;
	}

	template <>
	bool equalAttrArgs<Attr >(Attr A1, Attr *A2,
	StructuralEquivalenceContext &Context) {
	if (!A1 \|\| !A2)
	return A1 == A2;
	return A1->isEquivalent(*A2, Context);
	}

	template <>
	bool equalAttrArgs<Expr >(Expr A1, Expr *A2,
	StructuralEquivalenceContext &Context) {
	return ASTStructuralEquivalence::isEquivalent(Context, A1, A2);
	}

	template <>
	bool equalAttrArgs<QualType>(QualType T1, QualType T2,
	StructuralEquivalenceContext &Context) {
	return ASTStructuralEquivalence::isEquivalent(Context, T1, T2);
	}

	template <>
	bool equalAttrArgs<const IdentifierInfo *>(
	const IdentifierInfo Name1, const IdentifierInfo Name2,
	StructuralEquivalenceContext &Context) {
	return ASTStructuralEquivalence::isEquivalent(Name1, Name2);
	}

	bool areAlignedAttrsEqual(const AlignedAttr &A1, const AlignedAttr &A2,
	StructuralEquivalenceContext &Context) {
	if (A1.getSpelling() != A2.getSpelling())
	return false;

	if (A1.isAlignmentExpr() != A2.isAlignmentExpr())
	return false;

	if (A1.isAlignmentExpr())
	return equalAttrArgs(A1.getAlignmentExpr(), A2.getAlignmentExpr(), Context);

	return equalAttrArgs(A1.getAlignmentType()->getType(),
	A2.getAlignmentType()->getType(), Context);
	}
	} // namespace

	namespace {
	// Machinery to unique attributes based on the arguments.
	// The construction mirrors the equivalent testing code above.
	// The content of the arguments are added to the FoldingSetNodeID instance,
	// which allows the AttributedTypes to unique the attributes based on
	// the value of the arguments.

	#define USE_DEFAULT_PROFILE \
	(std::is_same_v<T, StringRef> \|\| std::is_same_v<T, VersionTuple> \|\| \
	std::is_same_v<T, IdentifierInfo *> \|\| \
	std::is_same_v<T, const IdentifierInfo *> \|\| std::is_enum_v<T> \|\| \
	std::is_integral_v<T>)

	template <class T>
	typename std::enable_if_t<!USE_DEFAULT_PROFILE>
	profileAttrArg(llvm::FoldingSetNodeID &, const ASTContext &, T) {
	llvm_unreachable("profile not implemented for this type");
	}

	template <class T>
	typename std::enable_if_t<USE_DEFAULT_PROFILE>
	profileAttrArg(llvm::FoldingSetNodeID &ID, const ASTContext &, T V) {
	if constexpr (std::is_same_v<T, StringRef>)
	ID.AddString(V);
	else if constexpr (std::is_same_v<T, VersionTuple>) {
	ID.AddInteger(V.getMajor());
	ID.AddInteger(V.getMinor().value_or(0));
	ID.AddInteger(V.getSubminor().value_or(0));
	ID.AddInteger(V.getBuild().value_or(0));
	} else if constexpr (std::is_same_v<T, IdentifierInfo *> \|\|
	std::is_same_v<T, const IdentifierInfo *>)
	ID.AddPointer(V);
	else
	ID.AddInteger(static_cast<long long>(V));
	}

	template <>
	inline void profileAttrArg<ParamIdx>(llvm::FoldingSetNodeID &ID,
	const ASTContext &, ParamIdx P) {
	ID.AddBoolean(P.isValid());
	if (P.isValid())
	ID.AddInteger(P.getASTIndex());
	}

	template <class T>
	inline void profileAttrArg(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx,
	T Begin, T End) {
	ID.AddInteger(End - Begin);
	for (; Begin != End; ++Begin)
	profileAttrArg(ID, Ctx, *Begin);
	}

	template <>
	inline void profileAttrArg<Attr *>(llvm::FoldingSetNodeID &ID,
	const ASTContext &Ctx, Attr *A) {
	if (!A) {
	ID.AddPointer(nullptr);
	return;
	}
	ID.AddInteger(A->getKind());
	A->Profile(ID, Ctx);
	}

	template <>
	inline void profileAttrArg<Expr *>(llvm::FoldingSetNodeID &ID,
	const ASTContext &Ctx, Expr *E) {
	E->Profile(ID, Ctx, /Canonical=/true);
	}

	template <>
	inline void profileAttrArg<QualType>(llvm::FoldingSetNodeID &ID,
	const ASTContext &, QualType T) {
	ID.AddPointer(T.getCanonicalType().getAsOpaquePtr());
	}

	void profileAlignedAttr(const AlignedAttr &A, llvm::FoldingSetNodeID &ID,
	const ASTContext &Ctx) {
	ID.AddInteger(A.getSpellingListIndex());
	ID.AddBoolean(A.isAlignmentExpr());
	if (A.isAlignmentExpr())
	profileAttrArg(ID, Ctx, A.getAlignmentExpr());
	else
	profileAttrArg(ID, Ctx, A.getAlignmentType()->getType());
	}
	} // namespace

	#include "clang/AST/AttrImpl.inc"