/build/llvm-toolchain-snapshot-13~++20210308111132+66e3a4abe99c/clang/lib/Sema/SemaDeclAttr.cpp

Bug Summary

File:	clang/lib/Sema/SemaDeclAttr.cpp
Warning:	line 5876, column 24 Called C++ object pointer is null
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name SemaDeclAttr.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=none -relaxed-aliasing -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-13~++20210308111132+66e3a4abe99c/build-llvm/tools/clang/lib/Sema -resource-dir /usr/lib/llvm-13/lib/clang/13.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-13~++20210308111132+66e3a4abe99c/build-llvm/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-13~++20210308111132+66e3a4abe99c/clang/lib/Sema -I /build/llvm-toolchain-snapshot-13~++20210308111132+66e3a4abe99c/clang/include -I /build/llvm-toolchain-snapshot-13~++20210308111132+66e3a4abe99c/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-13~++20210308111132+66e3a4abe99c/build-llvm/include -I /build/llvm-toolchain-snapshot-13~++20210308111132+66e3a4abe99c/llvm/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-13/lib/clang/13.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-13~++20210308111132+66e3a4abe99c/build-llvm/tools/clang/lib/Sema -fdebug-prefix-map=/build/llvm-toolchain-snapshot-13~++20210308111132+66e3a4abe99c=. -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -o /tmp/scan-build-2021-03-08-182450-10039-1 -x c++ /build/llvm-toolchain-snapshot-13~++20210308111132+66e3a4abe99c/clang/lib/Sema/SemaDeclAttr.cpp
1//===--- SemaDeclAttr.cpp - Declaration Attribute Handling ----------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9//  This file implements decl-related attribute processing.
10//
11//===----------------------------------------------------------------------===//

13#include "clang/AST/ASTConsumer.h"
14#include "clang/AST/ASTContext.h"
15#include "clang/AST/ASTMutationListener.h"
16#include "clang/AST/CXXInheritance.h"
17#include "clang/AST/DeclCXX.h"
18#include "clang/AST/DeclObjC.h"
19#include "clang/AST/DeclTemplate.h"
20#include "clang/AST/Expr.h"
21#include "clang/AST/ExprCXX.h"
22#include "clang/AST/Mangle.h"
23#include "clang/AST/RecursiveASTVisitor.h"
24#include "clang/AST/Type.h"
25#include "clang/Basic/CharInfo.h"
26#include "clang/Basic/SourceLocation.h"
27#include "clang/Basic/SourceManager.h"
28#include "clang/Basic/TargetBuiltins.h"
29#include "clang/Basic/TargetInfo.h"
30#include "clang/Lex/Preprocessor.h"
31#include "clang/Sema/DeclSpec.h"
32#include "clang/Sema/DelayedDiagnostic.h"
33#include "clang/Sema/Initialization.h"
34#include "clang/Sema/Lookup.h"
35#include "clang/Sema/ParsedAttr.h"
36#include "clang/Sema/Scope.h"
37#include "clang/Sema/ScopeInfo.h"
38#include "clang/Sema/SemaInternal.h"
39#include "llvm/ADT/Optional.h"
40#include "llvm/ADT/STLExtras.h"
41#include "llvm/ADT/StringExtras.h"
42#include "llvm/IR/Assumptions.h"
43#include "llvm/Support/Error.h"
44#include "llvm/Support/MathExtras.h"
45#include "llvm/Support/raw_ostream.h"

47using namespace clang;
48using namespace sema;

50namespace AttributeLangSupport {
enum LANG {
  C,
  Cpp,
  ObjC
};
56} // end namespace AttributeLangSupport

58//===----------------------------------------------------------------------===//
59//  Helper functions
60//===----------------------------------------------------------------------===//

62/// isFunctionOrMethod - Return true if the given decl has function
63/// type (function or function-typed variable) or an Objective-C
64/// method.
65static bool isFunctionOrMethod(const Decl *D) {
return (D->getFunctionType() != nullptr) || isa<ObjCMethodDecl>(D);
67}

69/// Return true if the given decl has function type (function or
70/// function-typed variable) or an Objective-C method or a block.
71static bool isFunctionOrMethodOrBlock(const Decl *D) {
return isFunctionOrMethod(D) || isa<BlockDecl>(D);
73}

75/// Return true if the given decl has a declarator that should have
76/// been processed by Sema::GetTypeForDeclarator.
77static bool hasDeclarator(const Decl *D) {
// In some sense, TypedefDecl really *ought* to be a DeclaratorDecl.
return isa<DeclaratorDecl>(D) || isa<BlockDecl>(D) || isa<TypedefNameDecl>(D) ||
       isa<ObjCPropertyDecl>(D);
81}

83/// hasFunctionProto - Return true if the given decl has a argument
84/// information. This decl should have already passed
85/// isFunctionOrMethod or isFunctionOrMethodOrBlock.
86static bool hasFunctionProto(const Decl *D) {
if (const FunctionType *FnTy = D->getFunctionType())
  return isa<FunctionProtoType>(FnTy);
return isa<ObjCMethodDecl>(D) || isa<BlockDecl>(D);
90}

92/// getFunctionOrMethodNumParams - Return number of function or method
93/// parameters. It is an error to call this on a K&R function (use
94/// hasFunctionProto first).
95static unsigned getFunctionOrMethodNumParams(const Decl *D) {
if (const FunctionType *FnTy = D->getFunctionType())
  return cast<FunctionProtoType>(FnTy)->getNumParams();
if (const auto *BD = dyn_cast<BlockDecl>(D))
  return BD->getNumParams();
return cast<ObjCMethodDecl>(D)->param_size();
101}

103static const ParmVarDecl *getFunctionOrMethodParam(const Decl *D,
                                                 unsigned Idx) {
if (const auto *FD = dyn_cast<FunctionDecl>(D))
  return FD->getParamDecl(Idx);
if (const auto *MD = dyn_cast<ObjCMethodDecl>(D))
  return MD->getParamDecl(Idx);
if (const auto *BD = dyn_cast<BlockDecl>(D))
  return BD->getParamDecl(Idx);
return nullptr;
112}

114static QualType getFunctionOrMethodParamType(const Decl *D, unsigned Idx) {
if (const FunctionType *FnTy = D->getFunctionType())
  return cast<FunctionProtoType>(FnTy)->getParamType(Idx);
if (const auto *BD = dyn_cast<BlockDecl>(D))
  return BD->getParamDecl(Idx)->getType();

return cast<ObjCMethodDecl>(D)->parameters()[Idx]->getType();
121}

123static SourceRange getFunctionOrMethodParamRange(const Decl *D, unsigned Idx) {
if (auto *PVD = getFunctionOrMethodParam(D, Idx))
  return PVD->getSourceRange();
return SourceRange();
127}

129static QualType getFunctionOrMethodResultType(const Decl *D) {
if (const FunctionType *FnTy = D->getFunctionType())
  return FnTy->getReturnType();
return cast<ObjCMethodDecl>(D)->getReturnType();
133}

135static SourceRange getFunctionOrMethodResultSourceRange(const Decl *D) {
if (const auto *FD = dyn_cast<FunctionDecl>(D))
  return FD->getReturnTypeSourceRange();
if (const auto *MD = dyn_cast<ObjCMethodDecl>(D))
  return MD->getReturnTypeSourceRange();
return SourceRange();
141}

143static bool isFunctionOrMethodVariadic(const Decl *D) {
if (const FunctionType *FnTy = D->getFunctionType())
  return cast<FunctionProtoType>(FnTy)->isVariadic();
if (const auto *BD = dyn_cast<BlockDecl>(D))
  return BD->isVariadic();
return cast<ObjCMethodDecl>(D)->isVariadic();
149}

151static bool isInstanceMethod(const Decl *D) {
if (const auto *MethodDecl = dyn_cast<CXXMethodDecl>(D))
  return MethodDecl->isInstance();
return false;
155}

157static inline bool isNSStringType(QualType T, ASTContext &Ctx) {
const auto *PT = T->getAs<ObjCObjectPointerType>();
if (!PT)
  return false;

ObjCInterfaceDecl *Cls = PT->getObjectType()->getInterface();
if (!Cls)
  return false;

IdentifierInfo* ClsName = Cls->getIdentifier();

// FIXME: Should we walk the chain of classes?
return ClsName == &Ctx.Idents.get("NSString") ||
       ClsName == &Ctx.Idents.get("NSMutableString");
171}

173static inline bool isCFStringType(QualType T, ASTContext &Ctx) {
const auto *PT = T->getAs<PointerType>();
if (!PT)
  return false;

const auto *RT = PT->getPointeeType()->getAs<RecordType>();
if (!RT)
  return false;

const RecordDecl *RD = RT->getDecl();
if (RD->getTagKind() != TTK_Struct)
  return false;

return RD->getIdentifier() == &Ctx.Idents.get("__CFString");
187}

189static unsigned getNumAttributeArgs(const ParsedAttr &AL) {
// FIXME: Include the type in the argument list.
return AL.getNumArgs() + AL.hasParsedType();
192}

194template <typename Compare>
195static bool checkAttributeNumArgsImpl(Sema &S, const ParsedAttr &AL,
                                    unsigned Num, unsigned Diag,
                                    Compare Comp) {
if (Comp(getNumAttributeArgs(AL), Num)) {
  S.Diag(AL.getLoc(), Diag) << AL << Num;
  return false;
}

return true;
204}

206/// Check if the attribute has exactly as many args as Num. May
207/// output an error.
208static bool checkAttributeNumArgs(Sema &S, const ParsedAttr &AL, unsigned Num) {
return checkAttributeNumArgsImpl(S, AL, Num,
                                 diag::err_attribute_wrong_number_arguments,
                                 std::not_equal_to<unsigned>());
212}

214/// Check if the attribute has at least as many args as Num. May
215/// output an error.
216static bool checkAttributeAtLeastNumArgs(Sema &S, const ParsedAttr &AL,
                                       unsigned Num) {
return checkAttributeNumArgsImpl(S, AL, Num,
                                 diag::err_attribute_too_few_arguments,
                                 std::less<unsigned>());
221}

223/// Check if the attribute has at most as many args as Num. May
224/// output an error.
225static bool checkAttributeAtMostNumArgs(Sema &S, const ParsedAttr &AL,
                                      unsigned Num) {
return checkAttributeNumArgsImpl(S, AL, Num,
                                 diag::err_attribute_too_many_arguments,
                                 std::greater<unsigned>());
230}

232/// A helper function to provide Attribute Location for the Attr types
233/// AND the ParsedAttr.
234template <typename AttrInfo>
235static std::enable_if_t<std::is_base_of<Attr, AttrInfo>::value, SourceLocation>
236getAttrLoc(const AttrInfo &AL) {
return AL.getLocation();
238}
239static SourceLocation getAttrLoc(const ParsedAttr &AL) { return AL.getLoc(); }

241/// If Expr is a valid integer constant, get the value of the integer
242/// expression and return success or failure. May output an error.
243///
244/// Negative argument is implicitly converted to unsigned, unless
245/// \p StrictlyUnsigned is true.
246template <typename AttrInfo>
247static bool checkUInt32Argument(Sema &S, const AttrInfo &AI, const Expr *Expr,
                              uint32_t &Val, unsigned Idx = UINT_MAX(2147483647 *2U +1U),
                              bool StrictlyUnsigned = false) {
Optional<llvm::APSInt> I = llvm::APSInt(32);
if (Expr->isTypeDependent() || Expr->isValueDependent() ||
    !(I = Expr->getIntegerConstantExpr(S.Context))) {
  if (Idx != UINT_MAX(2147483647 *2U +1U))
    S.Diag(getAttrLoc(AI), diag::err_attribute_argument_n_type)
        << &AI << Idx << AANT_ArgumentIntegerConstant
        << Expr->getSourceRange();
  else
    S.Diag(getAttrLoc(AI), diag::err_attribute_argument_type)
        << &AI << AANT_ArgumentIntegerConstant << Expr->getSourceRange();
  return false;
}

if (!I->isIntN(32)) {
  S.Diag(Expr->getExprLoc(), diag::err_ice_too_large)
      << I->toString(10, false) << 32 << /* Unsigned */ 1;
  return false;
}

if (StrictlyUnsigned && I->isSigned() && I->isNegative()) {
  S.Diag(getAttrLoc(AI), diag::err_attribute_requires_positive_integer)
      << &AI << /*non-negative*/ 1;
  return false;
}

Val = (uint32_t)I->getZExtValue();
return true;
277}

279/// Wrapper around checkUInt32Argument, with an extra check to be sure
280/// that the result will fit into a regular (signed) int. All args have the same
281/// purpose as they do in checkUInt32Argument.
282template <typename AttrInfo>
283static bool checkPositiveIntArgument(Sema &S, const AttrInfo &AI, const Expr *Expr,
                                   int &Val, unsigned Idx = UINT_MAX(2147483647 *2U +1U)) {
uint32_t UVal;
if (!checkUInt32Argument(S, AI, Expr, UVal, Idx))
  return false;

if (UVal > (uint32_t)std::numeric_limits<int>::max()) {
  llvm::APSInt I(32); // for toString
  I = UVal;
  S.Diag(Expr->getExprLoc(), diag::err_ice_too_large)
      << I.toString(10, false) << 32 << /* Unsigned */ 0;
  return false;
}

Val = UVal;
return true;
299}

301/// Diagnose mutually exclusive attributes when present on a given
302/// declaration. Returns true if diagnosed.
303template <typename AttrTy>
304static bool checkAttrMutualExclusion(Sema &S, Decl *D, const ParsedAttr &AL) {
if (const auto *A = D->getAttr<AttrTy>()) {
  S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A;
  S.Diag(A->getLocation(), diag::note_conflicting_attribute);
  return true;
}
return false;
311}

313template <typename AttrTy>
314static bool checkAttrMutualExclusion(Sema &S, Decl *D, const Attr &AL) {
if (const auto *A = D->getAttr<AttrTy>()) {
  S.Diag(AL.getLocation(), diag::err_attributes_are_not_compatible) << &AL
                                                                    << A;
  S.Diag(A->getLocation(), diag::note_conflicting_attribute);
  return true;
}
return false;
322}

324/// Check if IdxExpr is a valid parameter index for a function or
325/// instance method D.  May output an error.
326///
327/// \returns true if IdxExpr is a valid index.
328template <typename AttrInfo>
329static bool checkFunctionOrMethodParameterIndex(
  Sema &S, const Decl *D, const AttrInfo &AI, unsigned AttrArgNum,
  const Expr *IdxExpr, ParamIdx &Idx, bool CanIndexImplicitThis = false) {
assert(isFunctionOrMethodOrBlock(D))((isFunctionOrMethodOrBlock(D)) ? static_cast<void> (0)
 : __assert_fail ("isFunctionOrMethodOrBlock(D)", "/build/llvm-toolchain-snapshot-13~++20210308111132+66e3a4abe99c/clang/lib/Sema/SemaDeclAttr.cpp"
, 332, __PRETTY_FUNCTION__));

// In C++ the implicit 'this' function parameter also counts.
// Parameters are counted from one.
bool HP = hasFunctionProto(D);
bool HasImplicitThisParam = isInstanceMethod(D);
bool IV = HP && isFunctionOrMethodVariadic(D);
unsigned NumParams =
    (HP ? getFunctionOrMethodNumParams(D) : 0) + HasImplicitThisParam;

Optional<llvm::APSInt> IdxInt;
if (IdxExpr->isTypeDependent() || IdxExpr->isValueDependent() ||
    !(IdxInt = IdxExpr->getIntegerConstantExpr(S.Context))) {
  S.Diag(getAttrLoc(AI), diag::err_attribute_argument_n_type)
      << &AI << AttrArgNum << AANT_ArgumentIntegerConstant
      << IdxExpr->getSourceRange();
  return false;
}

unsigned IdxSource = IdxInt->getLimitedValue(UINT_MAX(2147483647 *2U +1U));
if (IdxSource < 1 || (!IV && IdxSource > NumParams)) {
  S.Diag(getAttrLoc(AI), diag::err_attribute_argument_out_of_bounds)
      << &AI << AttrArgNum << IdxExpr->getSourceRange();
  return false;
}
if (HasImplicitThisParam && !CanIndexImplicitThis) {
  if (IdxSource == 1) {
    S.Diag(getAttrLoc(AI), diag::err_attribute_invalid_implicit_this_argument)
        << &AI << IdxExpr->getSourceRange();
    return false;
  }
}

Idx = ParamIdx(IdxSource, D);
return true;
367}

369/// Check if the argument \p ArgNum of \p Attr is a ASCII string literal.
370/// If not emit an error and return false. If the argument is an identifier it
371/// will emit an error with a fixit hint and treat it as if it was a string
372/// literal.
373bool Sema::checkStringLiteralArgumentAttr(const ParsedAttr &AL, unsigned ArgNum,
                                        StringRef &Str,
                                        SourceLocation *ArgLocation) {
// Look for identifiers. If we have one emit a hint to fix it to a literal.
if (AL.isArgIdent(ArgNum)) {
  IdentifierLoc *Loc = AL.getArgAsIdent(ArgNum);
  Diag(Loc->Loc, diag::err_attribute_argument_type)
      << AL << AANT_ArgumentString
      << FixItHint::CreateInsertion(Loc->Loc, "\"")
      << FixItHint::CreateInsertion(getLocForEndOfToken(Loc->Loc), "\"");
  Str = Loc->Ident->getName();
  if (ArgLocation)
    *ArgLocation = Loc->Loc;
  return true;
}

// Now check for an actual string literal.
Expr *ArgExpr = AL.getArgAsExpr(ArgNum);
const auto *Literal = dyn_cast<StringLiteral>(ArgExpr->IgnoreParenCasts());
if (ArgLocation)
  *ArgLocation = ArgExpr->getBeginLoc();

if (!Literal || !Literal->isAscii()) {
  Diag(ArgExpr->getBeginLoc(), diag::err_attribute_argument_type)
      << AL << AANT_ArgumentString;
  return false;
}

Str = Literal->getString();
return true;
403}

405/// Applies the given attribute to the Decl without performing any
406/// additional semantic checking.
407template <typename AttrType>
408static void handleSimpleAttribute(Sema &S, Decl *D,
                                const AttributeCommonInfo &CI) {
D->addAttr(::new (S.Context) AttrType(S.Context, CI));
411}

413template <typename... DiagnosticArgs>
414static const Sema::SemaDiagnosticBuilder&
415appendDiagnostics(const Sema::SemaDiagnosticBuilder &Bldr) {
return Bldr;
417}

419template <typename T, typename... DiagnosticArgs>
420static const Sema::SemaDiagnosticBuilder&
421appendDiagnostics(const Sema::SemaDiagnosticBuilder &Bldr, T &&ExtraArg,
                DiagnosticArgs &&... ExtraArgs) {
return appendDiagnostics(Bldr << std::forward<T>(ExtraArg),
                         std::forward<DiagnosticArgs>(ExtraArgs)...);
425}

427/// Add an attribute {@code AttrType} to declaration {@code D}, provided that
428/// {@code PassesCheck} is true.
429/// Otherwise, emit diagnostic {@code DiagID}, passing in all parameters
430/// specified in {@code ExtraArgs}.
431template <typename AttrType, typename... DiagnosticArgs>
432static void handleSimpleAttributeOrDiagnose(Sema &S, Decl *D,
                                          const AttributeCommonInfo &CI,
                                          bool PassesCheck, unsigned DiagID,
                                          DiagnosticArgs &&... ExtraArgs) {
if (!PassesCheck) {
  Sema::SemaDiagnosticBuilder DB = S.Diag(D->getBeginLoc(), DiagID);
  appendDiagnostics(DB, std::forward<DiagnosticArgs>(ExtraArgs)...);
  return;
}
handleSimpleAttribute<AttrType>(S, D, CI);
442}

444template <typename AttrType>
445static void handleSimpleAttributeWithExclusions(Sema &S, Decl *D,
                                              const ParsedAttr &AL) {
handleSimpleAttribute<AttrType>(S, D, AL);
448}

450/// Applies the given attribute to the Decl so long as the Decl doesn't
451/// already have one of the given incompatible attributes.
452template <typename AttrType, typename IncompatibleAttrType,
        typename... IncompatibleAttrTypes>
454static void handleSimpleAttributeWithExclusions(Sema &S, Decl *D,
                                              const ParsedAttr &AL) {
if (checkAttrMutualExclusion<IncompatibleAttrType>(S, D, AL))
  return;
handleSimpleAttributeWithExclusions<AttrType, IncompatibleAttrTypes...>(S, D,
                                                                        AL);
460}

462/// Check if the passed-in expression is of type int or bool.
463static bool isIntOrBool(Expr *Exp) {
QualType QT = Exp->getType();
return QT->isBooleanType() || QT->isIntegerType();
466}


469// Check to see if the type is a smart pointer of some kind.  We assume
470// it's a smart pointer if it defines both operator-> and operator*.
471static bool threadSafetyCheckIsSmartPointer(Sema &S, const RecordType* RT) {
auto IsOverloadedOperatorPresent = [&S](const RecordDecl *Record,
                                        OverloadedOperatorKind Op) {
  DeclContextLookupResult Result =
      Record->lookup(S.Context.DeclarationNames.getCXXOperatorName(Op));
  return !Result.empty();
};

const RecordDecl *Record = RT->getDecl();
bool foundStarOperator = IsOverloadedOperatorPresent(Record, OO_Star);
bool foundArrowOperator = IsOverloadedOperatorPresent(Record, OO_Arrow);
if (foundStarOperator && foundArrowOperator)
  return true;

const CXXRecordDecl *CXXRecord = dyn_cast<CXXRecordDecl>(Record);
if (!CXXRecord)
  return false;

for (auto BaseSpecifier : CXXRecord->bases()) {
  if (!foundStarOperator)
    foundStarOperator = IsOverloadedOperatorPresent(
        BaseSpecifier.getType()->getAsRecordDecl(), OO_Star);
  if (!foundArrowOperator)
    foundArrowOperator = IsOverloadedOperatorPresent(
        BaseSpecifier.getType()->getAsRecordDecl(), OO_Arrow);
}

if (foundStarOperator && foundArrowOperator)
  return true;

return false;
502}

504/// Check if passed in Decl is a pointer type.
505/// Note that this function may produce an error message.
506/// \return true if the Decl is a pointer type; false otherwise
507static bool threadSafetyCheckIsPointer(Sema &S, const Decl *D,
                                     const ParsedAttr &AL) {
const auto *VD = cast<ValueDecl>(D);
QualType QT = VD->getType();
if (QT->isAnyPointerType())
  return true;

if (const auto *RT = QT->getAs<RecordType>()) {
  // If it's an incomplete type, it could be a smart pointer; skip it.
  // (We don't want to force template instantiation if we can avoid it,
  // since that would alter the order in which templates are instantiated.)
  if (RT->isIncompleteType())
    return true;

  if (threadSafetyCheckIsSmartPointer(S, RT))
    return true;
}

S.Diag(AL.getLoc(), diag::warn_thread_attribute_decl_not_pointer) << AL << QT;
return false;
527}

529/// Checks that the passed in QualType either is of RecordType or points
530/// to RecordType. Returns the relevant RecordType, null if it does not exit.
531static const RecordType *getRecordType(QualType QT) {
if (const auto *RT = QT->getAs<RecordType>())
  return RT;

// Now check if we point to record type.
if (const auto *PT = QT->getAs<PointerType>())
  return PT->getPointeeType()->getAs<RecordType>();

return nullptr;
540}

542template <typename AttrType>
543static bool checkRecordDeclForAttr(const RecordDecl *RD) {
// Check if the record itself has the attribute.
if (RD->hasAttr<AttrType>())
  return true;

// Else check if any base classes have the attribute.
if (const auto *CRD = dyn_cast<CXXRecordDecl>(RD)) {
  CXXBasePaths BPaths(false, false);
  if (CRD->lookupInBases(
          [](const CXXBaseSpecifier *BS, CXXBasePath &) {
            const auto &Ty = *BS->getType();
            // If it's type-dependent, we assume it could have the attribute.
            if (Ty.isDependentType())
              return true;
            return Ty.castAs<RecordType>()->getDecl()->hasAttr<AttrType>();
          },
          BPaths, true))
    return true;
}
return false;
563}

565static bool checkRecordTypeForCapability(Sema &S, QualType Ty) {
const RecordType *RT = getRecordType(Ty);

if (!RT)
  return false;

// Don't check for the capability if the class hasn't been defined yet.
if (RT->isIncompleteType())
  return true;

// Allow smart pointers to be used as capability objects.
// FIXME -- Check the type that the smart pointer points to.
if (threadSafetyCheckIsSmartPointer(S, RT))
  return true;

return checkRecordDeclForAttr<CapabilityAttr>(RT->getDecl());
581}

583static bool checkTypedefTypeForCapability(QualType Ty) {
const auto *TD = Ty->getAs<TypedefType>();
if (!TD)
  return false;

TypedefNameDecl *TN = TD->getDecl();
if (!TN)
  return false;

return TN->hasAttr<CapabilityAttr>();
593}

595static bool typeHasCapability(Sema &S, QualType Ty) {
if (checkTypedefTypeForCapability(Ty))
  return true;

if (checkRecordTypeForCapability(S, Ty))
  return true;

return false;
603}

605static bool isCapabilityExpr(Sema &S, const Expr *Ex) {
// Capability expressions are simple expressions involving the boolean logic
// operators &&, || or !, a simple DeclRefExpr, CastExpr or a ParenExpr. Once
// a DeclRefExpr is found, its type should be checked to determine whether it
// is a capability or not.

if (const auto *E = dyn_cast<CastExpr>(Ex))
  return isCapabilityExpr(S, E->getSubExpr());
else if (const auto *E = dyn_cast<ParenExpr>(Ex))
  return isCapabilityExpr(S, E->getSubExpr());
else if (const auto *E = dyn_cast<UnaryOperator>(Ex)) {
  if (E->getOpcode() == UO_LNot || E->getOpcode() == UO_AddrOf ||
      E->getOpcode() == UO_Deref)
    return isCapabilityExpr(S, E->getSubExpr());
  return false;
} else if (const auto *E = dyn_cast<BinaryOperator>(Ex)) {
  if (E->getOpcode() == BO_LAnd || E->getOpcode() == BO_LOr)
    return isCapabilityExpr(S, E->getLHS()) &&
           isCapabilityExpr(S, E->getRHS());
  return false;
}

return typeHasCapability(S, Ex->getType());
628}

630/// Checks that all attribute arguments, starting from Sidx, resolve to
631/// a capability object.
632/// \param Sidx The attribute argument index to start checking with.
633/// \param ParamIdxOk Whether an argument can be indexing into a function
634/// parameter list.
635static void checkAttrArgsAreCapabilityObjs(Sema &S, Decl *D,
                                         const ParsedAttr &AL,
                                         SmallVectorImpl<Expr *> &Args,
                                         unsigned Sidx = 0,
                                         bool ParamIdxOk = false) {
if (Sidx == AL.getNumArgs()) {
  // If we don't have any capability arguments, the attribute implicitly
  // refers to 'this'. So we need to make sure that 'this' exists, i.e. we're
  // a non-static method, and that the class is a (scoped) capability.
  const auto *MD = dyn_cast<const CXXMethodDecl>(D);
  if (MD && !MD->isStatic()) {
    const CXXRecordDecl *RD = MD->getParent();
    // FIXME -- need to check this again on template instantiation
    if (!checkRecordDeclForAttr<CapabilityAttr>(RD) &&
        !checkRecordDeclForAttr<ScopedLockableAttr>(RD))
      S.Diag(AL.getLoc(),
             diag::warn_thread_attribute_not_on_capability_member)
          << AL << MD->getParent();
  } else {
    S.Diag(AL.getLoc(), diag::warn_thread_attribute_not_on_non_static_member)
        << AL;
  }
}

for (unsigned Idx = Sidx; Idx < AL.getNumArgs(); ++Idx) {
  Expr *ArgExp = AL.getArgAsExpr(Idx);

  if (ArgExp->isTypeDependent()) {
    // FIXME -- need to check this again on template instantiation
    Args.push_back(ArgExp);
    continue;
  }

  if (const auto *StrLit = dyn_cast<StringLiteral>(ArgExp)) {
    if (StrLit->getLength() == 0 ||
        (StrLit->isAscii() && StrLit->getString() == StringRef("*"))) {
      // Pass empty strings to the analyzer without warnings.
      // Treat "*" as the universal lock.
      Args.push_back(ArgExp);
      continue;
    }

    // We allow constant strings to be used as a placeholder for expressions
    // that are not valid C++ syntax, but warn that they are ignored.
    S.Diag(AL.getLoc(), diag::warn_thread_attribute_ignored) << AL;
    Args.push_back(ArgExp);
    continue;
  }

  QualType ArgTy = ArgExp->getType();

  // A pointer to member expression of the form  &MyClass::mu is treated
  // specially -- we need to look at the type of the member.
  if (const auto *UOp = dyn_cast<UnaryOperator>(ArgExp))
    if (UOp->getOpcode() == UO_AddrOf)
      if (const auto *DRE = dyn_cast<DeclRefExpr>(UOp->getSubExpr()))
        if (DRE->getDecl()->isCXXInstanceMember())
          ArgTy = DRE->getDecl()->getType();

  // First see if we can just cast to record type, or pointer to record type.
  const RecordType *RT = getRecordType(ArgTy);

  // Now check if we index into a record type function param.
  if(!RT && ParamIdxOk) {
    const auto *FD = dyn_cast<FunctionDecl>(D);
    const auto *IL = dyn_cast<IntegerLiteral>(ArgExp);
    if(FD && IL) {
      unsigned int NumParams = FD->getNumParams();
      llvm::APInt ArgValue = IL->getValue();
      uint64_t ParamIdxFromOne = ArgValue.getZExtValue();
      uint64_t ParamIdxFromZero = ParamIdxFromOne - 1;
      if (!ArgValue.isStrictlyPositive() || ParamIdxFromOne > NumParams) {
        S.Diag(AL.getLoc(),
               diag::err_attribute_argument_out_of_bounds_extra_info)
            << AL << Idx + 1 << NumParams;
        continue;
      }
      ArgTy = FD->getParamDecl(ParamIdxFromZero)->getType();
    }
  }

  // If the type does not have a capability, see if the components of the
  // expression have capabilities. This allows for writing C code where the
  // capability may be on the type, and the expression is a capability
  // boolean logic expression. Eg) requires_capability(A || B && !C)
  if (!typeHasCapability(S, ArgTy) && !isCapabilityExpr(S, ArgExp))
    S.Diag(AL.getLoc(), diag::warn_thread_attribute_argument_not_lockable)
        << AL << ArgTy;

  Args.push_back(ArgExp);
}
726}

728//===----------------------------------------------------------------------===//
729// Attribute Implementations
730//===----------------------------------------------------------------------===//

732static void handlePtGuardedVarAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (!threadSafetyCheckIsPointer(S, D, AL))
  return;

D->addAttr(::new (S.Context) PtGuardedVarAttr(S.Context, AL));
737}

739static bool checkGuardedByAttrCommon(Sema &S, Decl *D, const ParsedAttr &AL,
                                   Expr *&Arg) {
SmallVector<Expr *, 1> Args;
// check that all arguments are lockable objects
checkAttrArgsAreCapabilityObjs(S, D, AL, Args);
unsigned Size = Args.size();
if (Size != 1)
  return false;

Arg = Args[0];

return true;
751}

753static void handleGuardedByAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
Expr *Arg = nullptr;
if (!checkGuardedByAttrCommon(S, D, AL, Arg))
  return;

D->addAttr(::new (S.Context) GuardedByAttr(S.Context, AL, Arg));
759}

761static void handlePtGuardedByAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
Expr *Arg = nullptr;
if (!checkGuardedByAttrCommon(S, D, AL, Arg))
  return;

if (!threadSafetyCheckIsPointer(S, D, AL))
  return;

D->addAttr(::new (S.Context) PtGuardedByAttr(S.Context, AL, Arg));
770}

772static bool checkAcquireOrderAttrCommon(Sema &S, Decl *D, const ParsedAttr &AL,
                                      SmallVectorImpl<Expr *> &Args) {
if (!checkAttributeAtLeastNumArgs(S, AL, 1))
  return false;

// Check that this attribute only applies to lockable types.
QualType QT = cast<ValueDecl>(D)->getType();
if (!QT->isDependentType() && !typeHasCapability(S, QT)) {
  S.Diag(AL.getLoc(), diag::warn_thread_attribute_decl_not_lockable) << AL;
  return false;
}

// Check that all arguments are lockable objects.
checkAttrArgsAreCapabilityObjs(S, D, AL, Args);
if (Args.empty())
  return false;

return true;
790}

792static void handleAcquiredAfterAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
SmallVector<Expr *, 1> Args;
if (!checkAcquireOrderAttrCommon(S, D, AL, Args))
  return;

Expr **StartArg = &Args[0];
D->addAttr(::new (S.Context)
               AcquiredAfterAttr(S.Context, AL, StartArg, Args.size()));
800}

802static void handleAcquiredBeforeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
SmallVector<Expr *, 1> Args;
if (!checkAcquireOrderAttrCommon(S, D, AL, Args))
  return;

Expr **StartArg = &Args[0];
D->addAttr(::new (S.Context)
               AcquiredBeforeAttr(S.Context, AL, StartArg, Args.size()));
810}

812static bool checkLockFunAttrCommon(Sema &S, Decl *D, const ParsedAttr &AL,
                                 SmallVectorImpl<Expr *> &Args) {
// zero or more arguments ok
// check that all arguments are lockable objects
checkAttrArgsAreCapabilityObjs(S, D, AL, Args, 0, /*ParamIdxOk=*/true);

return true;
819}

821static void handleAssertSharedLockAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
SmallVector<Expr *, 1> Args;
if (!checkLockFunAttrCommon(S, D, AL, Args))
  return;

unsigned Size = Args.size();
Expr **StartArg = Size == 0 ? nullptr : &Args[0];
D->addAttr(::new (S.Context)
               AssertSharedLockAttr(S.Context, AL, StartArg, Size));
830}

832static void handleAssertExclusiveLockAttr(Sema &S, Decl *D,
                                        const ParsedAttr &AL) {
SmallVector<Expr *, 1> Args;
if (!checkLockFunAttrCommon(S, D, AL, Args))
  return;

unsigned Size = Args.size();
Expr **StartArg = Size == 0 ? nullptr : &Args[0];
D->addAttr(::new (S.Context)
               AssertExclusiveLockAttr(S.Context, AL, StartArg, Size));
842}

844/// Checks to be sure that the given parameter number is in bounds, and
845/// is an integral type. Will emit appropriate diagnostics if this returns
846/// false.
847///
848/// AttrArgNo is used to actually retrieve the argument, so it's base-0.
849template <typename AttrInfo>
850static bool checkParamIsIntegerType(Sema &S, const FunctionDecl *FD,
                                  const AttrInfo &AI, unsigned AttrArgNo) {
assert(AI.isArgExpr(AttrArgNo) && "Expected expression argument")((AI.isArgExpr(AttrArgNo) && "Expected expression argument"
) ? static_cast<void> (0) : __assert_fail ("AI.isArgExpr(AttrArgNo) && \"Expected expression argument\""
, "/build/llvm-toolchain-snapshot-13~++20210308111132+66e3a4abe99c/clang/lib/Sema/SemaDeclAttr.cpp"
, 852, __PRETTY_FUNCTION__));
Expr *AttrArg = AI.getArgAsExpr(AttrArgNo);
ParamIdx Idx;
if (!checkFunctionOrMethodParameterIndex(S, FD, AI, AttrArgNo + 1, AttrArg,
                                         Idx))
  return false;

const ParmVarDecl *Param = FD->getParamDecl(Idx.getASTIndex());
if (!Param->getType()->isIntegerType() && !Param->getType()->isCharType()) {
  SourceLocation SrcLoc = AttrArg->getBeginLoc();
  S.Diag(SrcLoc, diag::err_attribute_integers_only)
      << AI << Param->getSourceRange();
  return false;
}
return true;
867}

869static void handleAllocSizeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (!checkAttributeAtLeastNumArgs(S, AL, 1) ||
    !checkAttributeAtMostNumArgs(S, AL, 2))
  return;

const auto *FD = cast<FunctionDecl>(D);
if (!FD->getReturnType()->isPointerType()) {
  S.Diag(AL.getLoc(), diag::warn_attribute_return_pointers_only) << AL;
  return;
}

const Expr *SizeExpr = AL.getArgAsExpr(0);
int SizeArgNoVal;
// Parameter indices are 1-indexed, hence Index=1
if (!checkPositiveIntArgument(S, AL, SizeExpr, SizeArgNoVal, /*Idx=*/1))
  return;
if (!checkParamIsIntegerType(S, FD, AL, /*AttrArgNo=*/0))
  return;
ParamIdx SizeArgNo(SizeArgNoVal, D);

ParamIdx NumberArgNo;
if (AL.getNumArgs() == 2) {
  const Expr *NumberExpr = AL.getArgAsExpr(1);
  int Val;
  // Parameter indices are 1-based, hence Index=2
  if (!checkPositiveIntArgument(S, AL, NumberExpr, Val, /*Idx=*/2))
    return;
  if (!checkParamIsIntegerType(S, FD, AL, /*AttrArgNo=*/1))
    return;
  NumberArgNo = ParamIdx(Val, D);
}

D->addAttr(::new (S.Context)
               AllocSizeAttr(S.Context, AL, SizeArgNo, NumberArgNo));
903}

905static bool checkTryLockFunAttrCommon(Sema &S, Decl *D, const ParsedAttr &AL,
                                    SmallVectorImpl<Expr *> &Args) {
if (!checkAttributeAtLeastNumArgs(S, AL, 1))
  return false;

if (!isIntOrBool(AL.getArgAsExpr(0))) {
  S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
      << AL << 1 << AANT_ArgumentIntOrBool;
  return false;
}

// check that all arguments are lockable objects
checkAttrArgsAreCapabilityObjs(S, D, AL, Args, 1);

return true;
920}

922static void handleSharedTrylockFunctionAttr(Sema &S, Decl *D,
                                          const ParsedAttr &AL) {
SmallVector<Expr*, 2> Args;
if (!checkTryLockFunAttrCommon(S, D, AL, Args))
  return;

D->addAttr(::new (S.Context) SharedTrylockFunctionAttr(
    S.Context, AL, AL.getArgAsExpr(0), Args.data(), Args.size()));
930}

932static void handleExclusiveTrylockFunctionAttr(Sema &S, Decl *D,
                                             const ParsedAttr &AL) {
SmallVector<Expr*, 2> Args;
if (!checkTryLockFunAttrCommon(S, D, AL, Args))
  return;

D->addAttr(::new (S.Context) ExclusiveTrylockFunctionAttr(
    S.Context, AL, AL.getArgAsExpr(0), Args.data(), Args.size()));
940}

942static void handleLockReturnedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
// check that the argument is lockable object
SmallVector<Expr*, 1> Args;
checkAttrArgsAreCapabilityObjs(S, D, AL, Args);
unsigned Size = Args.size();
if (Size == 0)
  return;

D->addAttr(::new (S.Context) LockReturnedAttr(S.Context, AL, Args[0]));
951}

953static void handleLocksExcludedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (!checkAttributeAtLeastNumArgs(S, AL, 1))
  return;

// check that all arguments are lockable objects
SmallVector<Expr*, 1> Args;
checkAttrArgsAreCapabilityObjs(S, D, AL, Args);
unsigned Size = Args.size();
if (Size == 0)
  return;
Expr **StartArg = &Args[0];

D->addAttr(::new (S.Context)
               LocksExcludedAttr(S.Context, AL, StartArg, Size));
967}

969static bool checkFunctionConditionAttr(Sema &S, Decl *D, const ParsedAttr &AL,
                                     Expr *&Cond, StringRef &Msg) {
Cond = AL.getArgAsExpr(0);
if (!Cond->isTypeDependent()) {
  ExprResult Converted = S.PerformContextuallyConvertToBool(Cond);
  if (Converted.isInvalid())
    return false;
  Cond = Converted.get();
}

if (!S.checkStringLiteralArgumentAttr(AL, 1, Msg))
  return false;

if (Msg.empty())
  Msg = "<no message provided>";

SmallVector<PartialDiagnosticAt, 8> Diags;
if (isa<FunctionDecl>(D) && !Cond->isValueDependent() &&
    !Expr::isPotentialConstantExprUnevaluated(Cond, cast<FunctionDecl>(D),
                                              Diags)) {
  S.Diag(AL.getLoc(), diag::err_attr_cond_never_constant_expr) << AL;
  for (const PartialDiagnosticAt &PDiag : Diags)
    S.Diag(PDiag.first, PDiag.second);
  return false;
}
return true;
995}

997static void handleEnableIfAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
S.Diag(AL.getLoc(), diag::ext_clang_enable_if);

Expr *Cond;
StringRef Msg;
if (checkFunctionConditionAttr(S, D, AL, Cond, Msg))
  D->addAttr(::new (S.Context) EnableIfAttr(S.Context, AL, Cond, Msg));
1004}

1006namespace {
1007/// Determines if a given Expr references any of the given function's
1008/// ParmVarDecls, or the function's implicit `this` parameter (if applicable).
1009class ArgumentDependenceChecker
  : public RecursiveASTVisitor<ArgumentDependenceChecker> {
1011#ifndef NDEBUG
const CXXRecordDecl *ClassType;
1013#endif
llvm::SmallPtrSet<const ParmVarDecl *, 16> Parms;
bool Result;

1017public:
ArgumentDependenceChecker(const FunctionDecl *FD) {
1019#ifndef NDEBUG
  if (const auto *MD = dyn_cast<CXXMethodDecl>(FD))
    ClassType = MD->getParent();
  else
    ClassType = nullptr;
1024#endif
  Parms.insert(FD->param_begin(), FD->param_end());
}

bool referencesArgs(Expr *E) {
  Result = false;
  TraverseStmt(E);
  return Result;
}

bool VisitCXXThisExpr(CXXThisExpr *E) {
  assert(E->getType()->getPointeeCXXRecordDecl() == ClassType &&((E->getType()->getPointeeCXXRecordDecl() == ClassType &&
 "`this` doesn't refer to the enclosing class?") ? static_cast
<void> (0) : __assert_fail ("E->getType()->getPointeeCXXRecordDecl() == ClassType && \"`this` doesn't refer to the enclosing class?\""
, "/build/llvm-toolchain-snapshot-13~++20210308111132+66e3a4abe99c/clang/lib/Sema/SemaDeclAttr.cpp"
, 1036, __PRETTY_FUNCTION__))
         "`this` doesn't refer to the enclosing class?")((E->getType()->getPointeeCXXRecordDecl() == ClassType &&
 "`this` doesn't refer to the enclosing class?") ? static_cast
<void> (0) : __assert_fail ("E->getType()->getPointeeCXXRecordDecl() == ClassType && \"`this` doesn't refer to the enclosing class?\""
, "/build/llvm-toolchain-snapshot-13~++20210308111132+66e3a4abe99c/clang/lib/Sema/SemaDeclAttr.cpp"
, 1036, __PRETTY_FUNCTION__));
  Result = true;
  return false;
}

bool VisitDeclRefExpr(DeclRefExpr *DRE) {
  if (const auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl()))
    if (Parms.count(PVD)) {
      Result = true;
      return false;
    }
  return true;
}
1049};
1050}

1052static void handleDiagnoseIfAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
S.Diag(AL.getLoc(), diag::ext_clang_diagnose_if);

Expr *Cond;
StringRef Msg;
if (!checkFunctionConditionAttr(S, D, AL, Cond, Msg))
  return;

StringRef DiagTypeStr;
if (!S.checkStringLiteralArgumentAttr(AL, 2, DiagTypeStr))
  return;

DiagnoseIfAttr::DiagnosticType DiagType;
if (!DiagnoseIfAttr::ConvertStrToDiagnosticType(DiagTypeStr, DiagType)) {
  S.Diag(AL.getArgAsExpr(2)->getBeginLoc(),
         diag::err_diagnose_if_invalid_diagnostic_type);
  return;
}

bool ArgDependent = false;
if (const auto *FD = dyn_cast<FunctionDecl>(D))
  ArgDependent = ArgumentDependenceChecker(FD).referencesArgs(Cond);
D->addAttr(::new (S.Context) DiagnoseIfAttr(
    S.Context, AL, Cond, Msg, DiagType, ArgDependent, cast<NamedDecl>(D)));
1076}

1078static void handleNoBuiltinAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
static constexpr const StringRef kWildcard = "*";

llvm::SmallVector<StringRef, 16> Names;
bool HasWildcard = false;

const auto AddBuiltinName = [&Names, &HasWildcard](StringRef Name) {
  if (Name == kWildcard)
    HasWildcard = true;
  Names.push_back(Name);
};

// Add previously defined attributes.
if (const auto *NBA = D->getAttr<NoBuiltinAttr>())
  for (StringRef BuiltinName : NBA->builtinNames())
    AddBuiltinName(BuiltinName);

// Add current attributes.
if (AL.getNumArgs() == 0)
  AddBuiltinName(kWildcard);
else
  for (unsigned I = 0, E = AL.getNumArgs(); I != E; ++I) {
    StringRef BuiltinName;
    SourceLocation LiteralLoc;
    if (!S.checkStringLiteralArgumentAttr(AL, I, BuiltinName, &LiteralLoc))
      return;

    if (Builtin::Context::isBuiltinFunc(BuiltinName))
      AddBuiltinName(BuiltinName);
    else
      S.Diag(LiteralLoc, diag::warn_attribute_no_builtin_invalid_builtin_name)
          << BuiltinName << AL;
  }

// Repeating the same attribute is fine.
llvm::sort(Names);
Names.erase(std::unique(Names.begin(), Names.end()), Names.end());

// Empty no_builtin must be on its own.
if (HasWildcard && Names.size() > 1)
  S.Diag(D->getLocation(),
         diag::err_attribute_no_builtin_wildcard_or_builtin_name)
      << AL;

if (D->hasAttr<NoBuiltinAttr>())
  D->dropAttr<NoBuiltinAttr>();
D->addAttr(::new (S.Context)
               NoBuiltinAttr(S.Context, AL, Names.data(), Names.size()));
1126}

1128static void handlePassObjectSizeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (D->hasAttr<PassObjectSizeAttr>()) {
  S.Diag(D->getBeginLoc(), diag::err_attribute_only_once_per_parameter) << AL;
  return;
}

Expr *E = AL.getArgAsExpr(0);
uint32_t Type;
if (!checkUInt32Argument(S, AL, E, Type, /*Idx=*/1))
  return;

// pass_object_size's argument is passed in as the second argument of
// __builtin_object_size. So, it has the same constraints as that second
// argument; namely, it must be in the range [0, 3].
if (Type > 3) {
  S.Diag(E->getBeginLoc(), diag::err_attribute_argument_out_of_range)
      << AL << 0 << 3 << E->getSourceRange();
  return;
}

// pass_object_size is only supported on constant pointer parameters; as a
// kindness to users, we allow the parameter to be non-const for declarations.
// At this point, we have no clue if `D` belongs to a function declaration or
// definition, so we defer the constness check until later.
if (!cast<ParmVarDecl>(D)->getType()->isPointerType()) {
  S.Diag(D->getBeginLoc(), diag::err_attribute_pointers_only) << AL << 1;
  return;
}

D->addAttr(::new (S.Context) PassObjectSizeAttr(S.Context, AL, (int)Type));
1158}

1160static void handleConsumableAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
ConsumableAttr::ConsumedState DefaultState;

if (AL.isArgIdent(0)) {
  IdentifierLoc *IL = AL.getArgAsIdent(0);
  if (!ConsumableAttr::ConvertStrToConsumedState(IL->Ident->getName(),
                                                 DefaultState)) {
    S.Diag(IL->Loc, diag::warn_attribute_type_not_supported) << AL
                                                             << IL->Ident;
    return;
  }
} else {
  S.Diag(AL.getLoc(), diag::err_attribute_argument_type)
      << AL << AANT_ArgumentIdentifier;
  return;
}

D->addAttr(::new (S.Context) ConsumableAttr(S.Context, AL, DefaultState));
1178}

1180static bool checkForConsumableClass(Sema &S, const CXXMethodDecl *MD,
                                  const ParsedAttr &AL) {
QualType ThisType = MD->getThisType()->getPointeeType();

if (const CXXRecordDecl *RD = ThisType->getAsCXXRecordDecl()) {
  if (!RD->hasAttr<ConsumableAttr>()) {
    S.Diag(AL.getLoc(), diag::warn_attr_on_unconsumable_class) << RD;

    return false;
  }
}

return true;
1193}

1195static void handleCallableWhenAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (!checkAttributeAtLeastNumArgs(S, AL, 1))
  return;

if (!checkForConsumableClass(S, cast<CXXMethodDecl>(D), AL))
  return;

SmallVector<CallableWhenAttr::ConsumedState, 3> States;
for (unsigned ArgIndex = 0; ArgIndex < AL.getNumArgs(); ++ArgIndex) {
  CallableWhenAttr::ConsumedState CallableState;

  StringRef StateString;
  SourceLocation Loc;
  if (AL.isArgIdent(ArgIndex)) {
    IdentifierLoc *Ident = AL.getArgAsIdent(ArgIndex);
    StateString = Ident->Ident->getName();
    Loc = Ident->Loc;
  } else {
    if (!S.checkStringLiteralArgumentAttr(AL, ArgIndex, StateString, &Loc))
      return;
  }

  if (!CallableWhenAttr::ConvertStrToConsumedState(StateString,
                                                   CallableState)) {
    S.Diag(Loc, diag::warn_attribute_type_not_supported) << AL << StateString;
    return;
  }

  States.push_back(CallableState);
}

D->addAttr(::new (S.Context)
               CallableWhenAttr(S.Context, AL, States.data(), States.size()));
1228}

1230static void handleParamTypestateAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
ParamTypestateAttr::ConsumedState ParamState;

if (AL.isArgIdent(0)) {
  IdentifierLoc *Ident = AL.getArgAsIdent(0);
  StringRef StateString = Ident->Ident->getName();

  if (!ParamTypestateAttr::ConvertStrToConsumedState(StateString,
                                                     ParamState)) {
    S.Diag(Ident->Loc, diag::warn_attribute_type_not_supported)
        << AL << StateString;
    return;
  }
} else {
  S.Diag(AL.getLoc(), diag::err_attribute_argument_type)
      << AL << AANT_ArgumentIdentifier;
  return;
}

// FIXME: This check is currently being done in the analysis.  It can be
//        enabled here only after the parser propagates attributes at
//        template specialization definition, not declaration.
//QualType ReturnType = cast<ParmVarDecl>(D)->getType();
//const CXXRecordDecl *RD = ReturnType->getAsCXXRecordDecl();
//
//if (!RD || !RD->hasAttr<ConsumableAttr>()) {
//    S.Diag(AL.getLoc(), diag::warn_return_state_for_unconsumable_type) <<
//      ReturnType.getAsString();
//    return;
//}

D->addAttr(::new (S.Context) ParamTypestateAttr(S.Context, AL, ParamState));
1262}

1264static void handleReturnTypestateAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
ReturnTypestateAttr::ConsumedState ReturnState;

if (AL.isArgIdent(0)) {
  IdentifierLoc *IL = AL.getArgAsIdent(0);
  if (!ReturnTypestateAttr::ConvertStrToConsumedState(IL->Ident->getName(),
                                                      ReturnState)) {
    S.Diag(IL->Loc, diag::warn_attribute_type_not_supported) << AL
                                                             << IL->Ident;
    return;
  }
} else {
  S.Diag(AL.getLoc(), diag::err_attribute_argument_type)
      << AL << AANT_ArgumentIdentifier;
  return;
}

// FIXME: This check is currently being done in the analysis.  It can be
//        enabled here only after the parser propagates attributes at
//        template specialization definition, not declaration.
//QualType ReturnType;
//
//if (const ParmVarDecl *Param = dyn_cast<ParmVarDecl>(D)) {
//  ReturnType = Param->getType();
//
//} else if (const CXXConstructorDecl *Constructor =
//             dyn_cast<CXXConstructorDecl>(D)) {
//  ReturnType = Constructor->getThisType()->getPointeeType();
//
//} else {
//
//  ReturnType = cast<FunctionDecl>(D)->getCallResultType();
//}
//
//const CXXRecordDecl *RD = ReturnType->getAsCXXRecordDecl();
//
//if (!RD || !RD->hasAttr<ConsumableAttr>()) {
//    S.Diag(Attr.getLoc(), diag::warn_return_state_for_unconsumable_type) <<
//      ReturnType.getAsString();
//    return;
//}

D->addAttr(::new (S.Context) ReturnTypestateAttr(S.Context, AL, ReturnState));
1307}

1309static void handleSetTypestateAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (!checkForConsumableClass(S, cast<CXXMethodDecl>(D), AL))
  return;

SetTypestateAttr::ConsumedState NewState;
if (AL.isArgIdent(0)) {
  IdentifierLoc *Ident = AL.getArgAsIdent(0);
  StringRef Param = Ident->Ident->getName();
  if (!SetTypestateAttr::ConvertStrToConsumedState(Param, NewState)) {
    S.Diag(Ident->Loc, diag::warn_attribute_type_not_supported) << AL
                                                                << Param;
    return;
  }
} else {
  S.Diag(AL.getLoc(), diag::err_attribute_argument_type)
      << AL << AANT_ArgumentIdentifier;
  return;
}

D->addAttr(::new (S.Context) SetTypestateAttr(S.Context, AL, NewState));
1329}

1331static void handleTestTypestateAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (!checkForConsumableClass(S, cast<CXXMethodDecl>(D), AL))
  return;

TestTypestateAttr::ConsumedState TestState;
if (AL.isArgIdent(0)) {
  IdentifierLoc *Ident = AL.getArgAsIdent(0);
  StringRef Param = Ident->Ident->getName();
  if (!TestTypestateAttr::ConvertStrToConsumedState(Param, TestState)) {
    S.Diag(Ident->Loc, diag::warn_attribute_type_not_supported) << AL
                                                                << Param;
    return;
  }
} else {
  S.Diag(AL.getLoc(), diag::err_attribute_argument_type)
      << AL << AANT_ArgumentIdentifier;
  return;
}

D->addAttr(::new (S.Context) TestTypestateAttr(S.Context, AL, TestState));
1351}

1353static void handleExtVectorTypeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
// Remember this typedef decl, we will need it later for diagnostics.
S.ExtVectorDecls.push_back(cast<TypedefNameDecl>(D));
1356}

1358static void handlePackedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (auto *TD = dyn_cast<TagDecl>(D))
  TD->addAttr(::new (S.Context) PackedAttr(S.Context, AL));
else if (auto *FD = dyn_cast<FieldDecl>(D)) {
  bool BitfieldByteAligned = (!FD->getType()->isDependentType() &&
                              !FD->getType()->isIncompleteType() &&
                              FD->isBitField() &&
                              S.Context.getTypeAlign(FD->getType()) <= 8);

  if (S.getASTContext().getTargetInfo().getTriple().isPS4()) {
    if (BitfieldByteAligned)
      // The PS4 target needs to maintain ABI backwards compatibility.
      S.Diag(AL.getLoc(), diag::warn_attribute_ignored_for_field_of_type)
          << AL << FD->getType();
    else
      FD->addAttr(::new (S.Context) PackedAttr(S.Context, AL));
  } else {
    // Report warning about changed offset in the newer compiler versions.
    if (BitfieldByteAligned)
      S.Diag(AL.getLoc(), diag::warn_attribute_packed_for_bitfield);

    FD->addAttr(::new (S.Context) PackedAttr(S.Context, AL));
  }

} else
  S.Diag(AL.getLoc(), diag::warn_attribute_ignored) << AL;
1384}

1386static void handlePreferredName(Sema &S, Decl *D, const ParsedAttr &AL) {
auto *RD = cast<CXXRecordDecl>(D);
ClassTemplateDecl *CTD = RD->getDescribedClassTemplate();
assert(CTD && "attribute does not appertain to this declaration")((CTD && "attribute does not appertain to this declaration"
) ? static_cast<void> (0) : __assert_fail ("CTD && \"attribute does not appertain to this declaration\""
, "/build/llvm-toolchain-snapshot-13~++20210308111132+66e3a4abe99c/clang/lib/Sema/SemaDeclAttr.cpp"
, 1389, __PRETTY_FUNCTION__));

ParsedType PT = AL.getTypeArg();
TypeSourceInfo *TSI = nullptr;
QualType T = S.GetTypeFromParser(PT, &TSI);
if (!TSI)
  TSI = S.Context.getTrivialTypeSourceInfo(T, AL.getLoc());

if (!T.hasQualifiers() && T->isTypedefNameType()) {
  // Find the template name, if this type names a template specialization.
  const TemplateDecl *Template = nullptr;
  if (const auto *CTSD = dyn_cast_or_null<ClassTemplateSpecializationDecl>(
          T->getAsCXXRecordDecl())) {
    Template = CTSD->getSpecializedTemplate();
  } else if (const auto *TST = T->getAs<TemplateSpecializationType>()) {
    while (TST && TST->isTypeAlias())
      TST = TST->getAliasedType()->getAs<TemplateSpecializationType>();
    if (TST)
      Template = TST->getTemplateName().getAsTemplateDecl();
  }

  if (Template && declaresSameEntity(Template, CTD)) {
    D->addAttr(::new (S.Context) PreferredNameAttr(S.Context, AL, TSI));
    return;
  }
}

S.Diag(AL.getLoc(), diag::err_attribute_preferred_name_arg_invalid)
    << T << CTD;
if (const auto *TT = T->getAs<TypedefType>())
  S.Diag(TT->getDecl()->getLocation(), diag::note_entity_declared_at)
      << TT->getDecl();
1421}

1423static bool checkIBOutletCommon(Sema &S, Decl *D, const ParsedAttr &AL) {
// The IBOutlet/IBOutletCollection attributes only apply to instance
// variables or properties of Objective-C classes.  The outlet must also
// have an object reference type.
if (const auto *VD = dyn_cast<ObjCIvarDecl>(D)) {
  if (!VD->getType()->getAs<ObjCObjectPointerType>()) {
    S.Diag(AL.getLoc(), diag::warn_iboutlet_object_type)
        << AL << VD->getType() << 0;
    return false;
  }
}
else if (const auto *PD = dyn_cast<ObjCPropertyDecl>(D)) {
  if (!PD->getType()->getAs<ObjCObjectPointerType>()) {
    S.Diag(AL.getLoc(), diag::warn_iboutlet_object_type)
        << AL << PD->getType() << 1;
    return false;
  }
}
else {
  S.Diag(AL.getLoc(), diag::warn_attribute_iboutlet) << AL;
  return false;
}

return true;
1447}

1449static void handleIBOutlet(Sema &S, Decl *D, const ParsedAttr &AL) {
if (!checkIBOutletCommon(S, D, AL))
  return;

D->addAttr(::new (S.Context) IBOutletAttr(S.Context, AL));
1454}

1456static void handleIBOutletCollection(Sema &S, Decl *D, const ParsedAttr &AL) {

// The iboutletcollection attribute can have zero or one arguments.
if (AL.getNumArgs() > 1) {
  S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) << AL << 1;
  return;
}

if (!checkIBOutletCommon(S, D, AL))
  return;

ParsedType PT;

if (AL.hasParsedType())
  PT = AL.getTypeArg();
else {
  PT = S.getTypeName(S.Context.Idents.get("NSObject"), AL.getLoc(),
                     S.getScopeForContext(D->getDeclContext()->getParent()));
  if (!PT) {
    S.Diag(AL.getLoc(), diag::err_iboutletcollection_type) << "NSObject";
    return;
  }
}

TypeSourceInfo *QTLoc = nullptr;
QualType QT = S.GetTypeFromParser(PT, &QTLoc);
if (!QTLoc)
  QTLoc = S.Context.getTrivialTypeSourceInfo(QT, AL.getLoc());

// Diagnose use of non-object type in iboutletcollection attribute.
// FIXME. Gnu attribute extension ignores use of builtin types in
// attributes. So, __attribute__((iboutletcollection(char))) will be
// treated as __attribute__((iboutletcollection())).
if (!QT->isObjCIdType() && !QT->isObjCObjectType()) {
  S.Diag(AL.getLoc(),
         QT->isBuiltinType() ? diag::err_iboutletcollection_builtintype
                             : diag::err_iboutletcollection_type) << QT;
  return;
}

D->addAttr(::new (S.Context) IBOutletCollectionAttr(S.Context, AL, QTLoc));
1497}

1499bool Sema::isValidPointerAttrType(QualType T, bool RefOkay) {
if (RefOkay) {
  if (T->isReferenceType())
    return true;
} else {
  T = T.getNonReferenceType();
}

// The nonnull attribute, and other similar attributes, can be applied to a
// transparent union that contains a pointer type.
if (const RecordType *UT = T->getAsUnionType()) {
  if (UT && UT->getDecl()->hasAttr<TransparentUnionAttr>()) {
    RecordDecl *UD = UT->getDecl();
    for (const auto *I : UD->fields()) {
      QualType QT = I->getType();
      if (QT->isAnyPointerType() || QT->isBlockPointerType())
        return true;
    }
  }
}

return T->isAnyPointerType() || T->isBlockPointerType();
1521}

1523static bool attrNonNullArgCheck(Sema &S, QualType T, const ParsedAttr &AL,
                              SourceRange AttrParmRange,
                              SourceRange TypeRange,
                              bool isReturnValue = false) {
if (!S.isValidPointerAttrType(T)) {
  if (isReturnValue)
    S.Diag(AL.getLoc(), diag::warn_attribute_return_pointers_only)
        << AL << AttrParmRange << TypeRange;
  else
    S.Diag(AL.getLoc(), diag::warn_attribute_pointers_only)
        << AL << AttrParmRange << TypeRange << 0;
  return false;
}
return true;
1537}

1539static void handleNonNullAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
SmallVector<ParamIdx, 8> NonNullArgs;
for (unsigned I = 0; I < AL.getNumArgs(); ++I) {
  Expr *Ex = AL.getArgAsExpr(I);
  ParamIdx Idx;
  if (!checkFunctionOrMethodParameterIndex(S, D, AL, I + 1, Ex, Idx))
    return;

  // Is the function argument a pointer type?
  if (Idx.getASTIndex() < getFunctionOrMethodNumParams(D) &&
      !attrNonNullArgCheck(
          S, getFunctionOrMethodParamType(D, Idx.getASTIndex()), AL,
          Ex->getSourceRange(),
          getFunctionOrMethodParamRange(D, Idx.getASTIndex())))
    continue;

  NonNullArgs.push_back(Idx);
}

// If no arguments were specified to __attribute__((nonnull)) then all pointer
// arguments have a nonnull attribute; warn if there aren't any. Skip this
// check if the attribute came from a macro expansion or a template
// instantiation.
if (NonNullArgs.empty() && AL.getLoc().isFileID() &&
    !S.inTemplateInstantiation()) {
  bool AnyPointers = isFunctionOrMethodVariadic(D);
  for (unsigned I = 0, E = getFunctionOrMethodNumParams(D);
       I != E && !AnyPointers; ++I) {
    QualType T = getFunctionOrMethodParamType(D, I);
    if (T->isDependentType() || S.isValidPointerAttrType(T))
      AnyPointers = true;
  }

  if (!AnyPointers)
    S.Diag(AL.getLoc(), diag::warn_attribute_nonnull_no_pointers);
}

ParamIdx *Start = NonNullArgs.data();
unsigned Size = NonNullArgs.size();
llvm::array_pod_sort(Start, Start + Size);
D->addAttr(::new (S.Context) NonNullAttr(S.Context, AL, Start, Size));
1580}

1582static void handleNonNullAttrParameter(Sema &S, ParmVarDecl *D,
                                     const ParsedAttr &AL) {
if (AL.getNumArgs() > 0) {
  if (D->getFunctionType()) {
    handleNonNullAttr(S, D, AL);
  } else {
    S.Diag(AL.getLoc(), diag::warn_attribute_nonnull_parm_no_args)
      << D->getSourceRange();
  }
  return;
}

// Is the argument a pointer type?
if (!attrNonNullArgCheck(S, D->getType(), AL, SourceRange(),
                         D->getSourceRange()))
  return;

D->addAttr(::new (S.Context) NonNullAttr(S.Context, AL, nullptr, 0));
1600}

1602static void handleReturnsNonNullAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
QualType ResultType = getFunctionOrMethodResultType(D);
SourceRange SR = getFunctionOrMethodResultSourceRange(D);
if (!attrNonNullArgCheck(S, ResultType, AL, SourceRange(), SR,
                         /* isReturnValue */ true))
  return;

D->addAttr(::new (S.Context) ReturnsNonNullAttr(S.Context, AL));
1610}

1612static void handleNoEscapeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (D->isInvalidDecl())
  return;

// noescape only applies to pointer types.
QualType T = cast<ParmVarDecl>(D)->getType();
if (!S.isValidPointerAttrType(T, /* RefOkay */ true)) {
  S.Diag(AL.getLoc(), diag::warn_attribute_pointers_only)
      << AL << AL.getRange() << 0;
  return;
}

D->addAttr(::new (S.Context) NoEscapeAttr(S.Context, AL));
1625}

1627static void handleAssumeAlignedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
Expr *E = AL.getArgAsExpr(0),
     *OE = AL.getNumArgs() > 1 ? AL.getArgAsExpr(1) : nullptr;
S.AddAssumeAlignedAttr(D, AL, E, OE);
1631}

1633static void handleAllocAlignAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
S.AddAllocAlignAttr(D, AL, AL.getArgAsExpr(0));
1635}

1637void Sema::AddAssumeAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E,
                              Expr *OE) {
QualType ResultType = getFunctionOrMethodResultType(D);
SourceRange SR = getFunctionOrMethodResultSourceRange(D);

AssumeAlignedAttr TmpAttr(Context, CI, E, OE);
SourceLocation AttrLoc = TmpAttr.getLocation();

if (!isValidPointerAttrType(ResultType, /* RefOkay */ true)) {
  Diag(AttrLoc, diag::warn_attribute_return_pointers_refs_only)
      << &TmpAttr << TmpAttr.getRange() << SR;
  return;
}

if (!E->isValueDependent()) {
  Optional<llvm::APSInt> I = llvm::APSInt(64);
  if (!(I = E->getIntegerConstantExpr(Context))) {
    if (OE)
      Diag(AttrLoc, diag::err_attribute_argument_n_type)
        << &TmpAttr << 1 << AANT_ArgumentIntegerConstant
        << E->getSourceRange();
    else
      Diag(AttrLoc, diag::err_attribute_argument_type)
        << &TmpAttr << AANT_ArgumentIntegerConstant
        << E->getSourceRange();
    return;
  }

  if (!I->isPowerOf2()) {
    Diag(AttrLoc, diag::err_alignment_not_power_of_two)
      << E->getSourceRange();
    return;
  }

  if (*I > Sema::MaximumAlignment)
    Diag(CI.getLoc(), diag::warn_assume_aligned_too_great)
        << CI.getRange() << Sema::MaximumAlignment;
}

if (OE && !OE->isValueDependent() && !OE->isIntegerConstantExpr(Context)) {
  Diag(AttrLoc, diag::err_attribute_argument_n_type)
      << &TmpAttr << 2 << AANT_ArgumentIntegerConstant
      << OE->getSourceRange();
  return;
}

D->addAttr(::new (Context) AssumeAlignedAttr(Context, CI, E, OE));
1684}

1686void Sema::AddAllocAlignAttr(Decl *D, const AttributeCommonInfo &CI,
                           Expr *ParamExpr) {
QualType ResultType = getFunctionOrMethodResultType(D);

AllocAlignAttr TmpAttr(Context, CI, ParamIdx());
SourceLocation AttrLoc = CI.getLoc();

if (!ResultType->isDependentType() &&
    !isValidPointerAttrType(ResultType, /* RefOkay */ true)) {
  Diag(AttrLoc, diag::warn_attribute_return_pointers_refs_only)
      << &TmpAttr << CI.getRange() << getFunctionOrMethodResultSourceRange(D);
  return;
}

ParamIdx Idx;
const auto *FuncDecl = cast<FunctionDecl>(D);
if (!checkFunctionOrMethodParameterIndex(*this, FuncDecl, TmpAttr,
                                         /*AttrArgNum=*/1, ParamExpr, Idx))
  return;

QualType Ty = getFunctionOrMethodParamType(D, Idx.getASTIndex());
if (!Ty->isDependentType() && !Ty->isIntegralType(Context) &&
    !Ty->isAlignValT()) {
  Diag(ParamExpr->getBeginLoc(), diag::err_attribute_integers_only)
      << &TmpAttr
      << FuncDecl->getParamDecl(Idx.getASTIndex())->getSourceRange();
  return;
}

D->addAttr(::new (Context) AllocAlignAttr(Context, CI, Idx));
1716}

1718/// Check if \p AssumptionStr is a known assumption and warn if not.
1719static void checkAssumptionAttr(Sema &S, SourceLocation Loc,
                              StringRef AssumptionStr) {
if (llvm::KnownAssumptionStrings.count(AssumptionStr))
  return;

unsigned BestEditDistance = 3;
StringRef Suggestion;
for (const auto &KnownAssumptionIt : llvm::KnownAssumptionStrings) {
  unsigned EditDistance =
      AssumptionStr.edit_distance(KnownAssumptionIt.getKey());
  if (EditDistance < BestEditDistance) {
    Suggestion = KnownAssumptionIt.getKey();
    BestEditDistance = EditDistance;
  }
}

if (!Suggestion.empty())
  S.Diag(Loc, diag::warn_assume_attribute_string_unknown_suggested)
      << AssumptionStr << Suggestion;
else
  S.Diag(Loc, diag::warn_assume_attribute_string_unknown) << AssumptionStr;
1740}

1742static void handleAssumumptionAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
// Handle the case where the attribute has a text message.
StringRef Str;
SourceLocation AttrStrLoc;
if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &AttrStrLoc))
  return;

checkAssumptionAttr(S, AttrStrLoc, Str);

D->addAttr(::new (S.Context) AssumptionAttr(S.Context, AL, Str));
1752}

1754/// Normalize the attribute, __foo__ becomes foo.
1755/// Returns true if normalization was applied.
1756static bool normalizeName(StringRef &AttrName) {
if (AttrName.size() > 4 && AttrName.startswith("__") &&
    AttrName.endswith("__")) {
  AttrName = AttrName.drop_front(2).drop_back(2);
  return true;
}
return false;
1763}

1765static void handleOwnershipAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
// This attribute must be applied to a function declaration. The first
// argument to the attribute must be an identifier, the name of the resource,
// for example: malloc. The following arguments must be argument indexes, the
// arguments must be of integer type for Returns, otherwise of pointer type.
// The difference between Holds and Takes is that a pointer may still be used
// after being held. free() should be __attribute((ownership_takes)), whereas
// a list append function may well be __attribute((ownership_holds)).

if (!AL.isArgIdent(0)) {
  S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
      << AL << 1 << AANT_ArgumentIdentifier;
  return;
}

// Figure out our Kind.
OwnershipAttr::OwnershipKind K =
    OwnershipAttr(S.Context, AL, nullptr, nullptr, 0).getOwnKind();

// Check arguments.
switch (K) {
case OwnershipAttr::Takes:
case OwnershipAttr::Holds:
  if (AL.getNumArgs() < 2) {
    S.Diag(AL.getLoc(), diag::err_attribute_too_few_arguments) << AL << 2;
    return;
  }
  break;
case OwnershipAttr::Returns:
  if (AL.getNumArgs() > 2) {
    S.Diag(AL.getLoc(), diag::err_attribute_too_many_arguments) << AL << 1;
    return;
  }
  break;
}

IdentifierInfo *Module = AL.getArgAsIdent(0)->Ident;

StringRef ModuleName = Module->getName();
if (normalizeName(ModuleName)) {
  Module = &S.PP.getIdentifierTable().get(ModuleName);
}

SmallVector<ParamIdx, 8> OwnershipArgs;
for (unsigned i = 1; i < AL.getNumArgs(); ++i) {
  Expr *Ex = AL.getArgAsExpr(i);
  ParamIdx Idx;
  if (!checkFunctionOrMethodParameterIndex(S, D, AL, i, Ex, Idx))
    return;

  // Is the function argument a pointer type?
  QualType T = getFunctionOrMethodParamType(D, Idx.getASTIndex());
  int Err = -1;  // No error
  switch (K) {
    case OwnershipAttr::Takes:
    case OwnershipAttr::Holds:
      if (!T->isAnyPointerType() && !T->isBlockPointerType())
        Err = 0;
      break;
    case OwnershipAttr::Returns:
      if (!T->isIntegerType())
        Err = 1;
      break;
  }
  if (-1 != Err) {
    S.Diag(AL.getLoc(), diag::err_ownership_type) << AL << Err
                                                  << Ex->getSourceRange();
    return;
  }

  // Check we don't have a conflict with another ownership attribute.
  for (const auto *I : D->specific_attrs<OwnershipAttr>()) {
    // Cannot have two ownership attributes of different kinds for the same
    // index.
    if (I->getOwnKind() != K && I->args_end() !=
        std::find(I->args_begin(), I->args_end(), Idx)) {
      S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << I;
      return;
    } else if (K == OwnershipAttr::Returns &&
               I->getOwnKind() == OwnershipAttr::Returns) {
      // A returns attribute conflicts with any other returns attribute using
      // a different index.
      if (std::find(I->args_begin(), I->args_end(), Idx) == I->args_end()) {
        S.Diag(I->getLocation(), diag::err_ownership_returns_index_mismatch)
            << I->args_begin()->getSourceIndex();
        if (I->args_size())
          S.Diag(AL.getLoc(), diag::note_ownership_returns_index_mismatch)
              << Idx.getSourceIndex() << Ex->getSourceRange();
        return;
      }
    }
  }
  OwnershipArgs.push_back(Idx);
}

ParamIdx *Start = OwnershipArgs.data();
unsigned Size = OwnershipArgs.size();
llvm::array_pod_sort(Start, Start + Size);
D->addAttr(::new (S.Context)
               OwnershipAttr(S.Context, AL, Module, Start, Size));
1865}

1867static void handleWeakRefAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
// Check the attribute arguments.
if (AL.getNumArgs() > 1) {
  S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) << AL << 1;
  return;
}

// gcc rejects
// class c {
//   static int a __attribute__((weakref ("v2")));
//   static int b() __attribute__((weakref ("f3")));
// };
// and ignores the attributes of
// void f(void) {
//   static int a __attribute__((weakref ("v2")));
// }
// we reject them
const DeclContext *Ctx = D->getDeclContext()->getRedeclContext();
if (!Ctx->isFileContext()) {
  S.Diag(AL.getLoc(), diag::err_attribute_weakref_not_global_context)
      << cast<NamedDecl>(D);
  return;
}

// The GCC manual says
//
// At present, a declaration to which `weakref' is attached can only
// be `static'.
//
// It also says
//
// Without a TARGET,
// given as an argument to `weakref' or to `alias', `weakref' is
// equivalent to `weak'.
//
// gcc 4.4.1 will accept
// int a7 __attribute__((weakref));
// as
// int a7 __attribute__((weak));
// This looks like a bug in gcc. We reject that for now. We should revisit
// it if this behaviour is actually used.

// GCC rejects
// static ((alias ("y"), weakref)).
// Should we? How to check that weakref is before or after alias?

// FIXME: it would be good for us to keep the WeakRefAttr as-written instead
// of transforming it into an AliasAttr.  The WeakRefAttr never uses the
// StringRef parameter it was given anyway.
StringRef Str;
if (AL.getNumArgs() && S.checkStringLiteralArgumentAttr(AL, 0, Str))
  // GCC will accept anything as the argument of weakref. Should we
  // check for an existing decl?
  D->addAttr(::new (S.Context) AliasAttr(S.Context, AL, Str));

D->addAttr(::new (S.Context) WeakRefAttr(S.Context, AL));
1923}

1925static void handleIFuncAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
StringRef Str;
if (!S.checkStringLiteralArgumentAttr(AL, 0, Str))
  return;

// Aliases should be on declarations, not definitions.
const auto *FD = cast<FunctionDecl>(D);
if (FD->isThisDeclarationADefinition()) {
  S.Diag(AL.getLoc(), diag::err_alias_is_definition) << FD << 1;
  return;
}

D->addAttr(::new (S.Context) IFuncAttr(S.Context, AL, Str));
1938}

1940static void handleAliasAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
StringRef Str;
if (!S.checkStringLiteralArgumentAttr(AL, 0, Str))
  return;

if (S.Context.getTargetInfo().getTriple().isOSDarwin()) {
  S.Diag(AL.getLoc(), diag::err_alias_not_supported_on_darwin);
  return;
}
if (S.Context.getTargetInfo().getTriple().isNVPTX()) {
  S.Diag(AL.getLoc(), diag::err_alias_not_supported_on_nvptx);
}

// Aliases should be on declarations, not definitions.
if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
  if (FD->isThisDeclarationADefinition()) {
    S.Diag(AL.getLoc(), diag::err_alias_is_definition) << FD << 0;
    return;
  }
} else {
  const auto *VD = cast<VarDecl>(D);
  if (VD->isThisDeclarationADefinition() && VD->isExternallyVisible()) {
    S.Diag(AL.getLoc(), diag::err_alias_is_definition) << VD << 0;
    return;
  }
}

// Mark target used to prevent unneeded-internal-declaration warnings.
if (!S.LangOpts.CPlusPlus) {
  // FIXME: demangle Str for C++, as the attribute refers to the mangled
  // linkage name, not the pre-mangled identifier.
  const DeclarationNameInfo target(&S.Context.Idents.get(Str), AL.getLoc());
  LookupResult LR(S, target, Sema::LookupOrdinaryName);
  if (S.LookupQualifiedName(LR, S.getCurLexicalContext()))
    for (NamedDecl *ND : LR)
      ND->markUsed(S.Context);
}

D->addAttr(::new (S.Context) AliasAttr(S.Context, AL, Str));
1979}

1981static void handleTLSModelAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
StringRef Model;
SourceLocation LiteralLoc;
// Check that it is a string.
if (!S.checkStringLiteralArgumentAttr(AL, 0, Model, &LiteralLoc))
  return;

// Check that the value.
if (Model != "global-dynamic" && Model != "local-dynamic"
    && Model != "initial-exec" && Model != "local-exec") {
  S.Diag(LiteralLoc, diag::err_attr_tlsmodel_arg);
  return;
}

D->addAttr(::new (S.Context) TLSModelAttr(S.Context, AL, Model));
1996}

1998static void handleRestrictAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
QualType ResultType = getFunctionOrMethodResultType(D);
if (ResultType->isAnyPointerType() || ResultType->isBlockPointerType()) {
  D->addAttr(::new (S.Context) RestrictAttr(S.Context, AL));
  return;
}

S.Diag(AL.getLoc(), diag::warn_attribute_return_pointers_only)
    << AL << getFunctionOrMethodResultSourceRange(D);
2007}

2009static void handleCPUSpecificAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
FunctionDecl *FD = cast<FunctionDecl>(D);

if (const auto *MD = dyn_cast<CXXMethodDecl>(D)) {
  if (MD->getParent()->isLambda()) {
    S.Diag(AL.getLoc(), diag::err_attribute_dll_lambda) << AL;
    return;
  }
}

if (!checkAttributeAtLeastNumArgs(S, AL, 1))
  return;

SmallVector<IdentifierInfo *, 8> CPUs;
for (unsigned ArgNo = 0; ArgNo < getNumAttributeArgs(AL); ++ArgNo) {
  if (!AL.isArgIdent(ArgNo)) {
    S.Diag(AL.getLoc(), diag::err_attribute_argument_type)
        << AL << AANT_ArgumentIdentifier;
    return;
  }

  IdentifierLoc *CPUArg = AL.getArgAsIdent(ArgNo);
  StringRef CPUName = CPUArg->Ident->getName().trim();

  if (!S.Context.getTargetInfo().validateCPUSpecificCPUDispatch(CPUName)) {
    S.Diag(CPUArg->Loc, diag::err_invalid_cpu_specific_dispatch_value)
        << CPUName << (AL.getKind() == ParsedAttr::AT_CPUDispatch);
    return;
  }

  const TargetInfo &Target = S.Context.getTargetInfo();
  if (llvm::any_of(CPUs, [CPUName, &Target](const IdentifierInfo *Cur) {
        return Target.CPUSpecificManglingCharacter(CPUName) ==
               Target.CPUSpecificManglingCharacter(Cur->getName());
      })) {
    S.Diag(AL.getLoc(), diag::warn_multiversion_duplicate_entries);
    return;
  }
  CPUs.push_back(CPUArg->Ident);
}

FD->setIsMultiVersion(true);
if (AL.getKind() == ParsedAttr::AT_CPUSpecific)
  D->addAttr(::new (S.Context)
                 CPUSpecificAttr(S.Context, AL, CPUs.data(), CPUs.size()));
else
  D->addAttr(::new (S.Context)
                 CPUDispatchAttr(S.Context, AL, CPUs.data(), CPUs.size()));
2057}

2059static void handleCommonAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (S.LangOpts.CPlusPlus) {
  S.Diag(AL.getLoc(), diag::err_attribute_not_supported_in_lang)
      << AL << AttributeLangSupport::Cpp;
  return;
}

if (CommonAttr *CA = S.mergeCommonAttr(D, AL))
  D->addAttr(CA);
2068}

2070static void handleCmseNSEntryAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (S.LangOpts.CPlusPlus && !D->getDeclContext()->isExternCContext()) {
  S.Diag(AL.getLoc(), diag::err_attribute_not_clinkage) << AL;
  return;
}

const auto *FD = cast<FunctionDecl>(D);
if (!FD->isExternallyVisible()) {
  S.Diag(AL.getLoc(), diag::warn_attribute_cmse_entry_static);
  return;
}

D->addAttr(::new (S.Context) CmseNSEntryAttr(S.Context, AL));
2083}

2085static void handleNakedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (checkAttrMutualExclusion<DisableTailCallsAttr>(S, D, AL))
  return;

if (AL.isDeclspecAttribute()) {
  const auto &Triple = S.getASTContext().getTargetInfo().getTriple();
  const auto &Arch = Triple.getArch();
  if (Arch != llvm::Triple::x86 &&
      (Arch != llvm::Triple::arm && Arch != llvm::Triple::thumb)) {
    S.Diag(AL.getLoc(), diag::err_attribute_not_supported_on_arch)
        << AL << Triple.getArchName();
    return;
  }
}

D->addAttr(::new (S.Context) NakedAttr(S.Context, AL));
2101}

2103static void handleNoReturnAttr(Sema &S, Decl *D, const ParsedAttr &Attrs) {
if (hasDeclarator(D)) return;

if (!isa<ObjCMethodDecl>(D)) {
  S.Diag(Attrs.getLoc(), diag::warn_attribute_wrong_decl_type)
      << Attrs << ExpectedFunctionOrMethod;
  return;
}

D->addAttr(::new (S.Context) NoReturnAttr(S.Context, Attrs));
2113}

2115static void handleNoCfCheckAttr(Sema &S, Decl *D, const ParsedAttr &Attrs) {
if (!S.getLangOpts().CFProtectionBranch)
  S.Diag(Attrs.getLoc(), diag::warn_nocf_check_attribute_ignored);
else
  handleSimpleAttribute<AnyX86NoCfCheckAttr>(S, D, Attrs);
2120}

2122bool Sema::CheckAttrNoArgs(const ParsedAttr &Attrs) {
if (!checkAttributeNumArgs(*this, Attrs, 0)) {
  Attrs.setInvalid();
  return true;
}

return false;
2129}

2131bool Sema::CheckAttrTarget(const ParsedAttr &AL) {
// Check whether the attribute is valid on the current target.
if (!AL.existsInTarget(Context.getTargetInfo())) {
  Diag(AL.getLoc(), diag::warn_unknown_attribute_ignored)
      << AL << AL.getRange();
  AL.setInvalid();
  return true;
}

return false;
2141}

2143static void handleAnalyzerNoReturnAttr(Sema &S, Decl *D, const ParsedAttr &AL) {

// The checking path for 'noreturn' and 'analyzer_noreturn' are different
// because 'analyzer_noreturn' does not impact the type.
if (!isFunctionOrMethodOrBlock(D)) {
  ValueDecl *VD = dyn_cast<ValueDecl>(D);
  if (!VD || (!VD->getType()->isBlockPointerType() &&
              !VD->getType()->isFunctionPointerType())) {
    S.Diag(AL.getLoc(), AL.isCXX11Attribute()
                            ? diag::err_attribute_wrong_decl_type
                            : diag::warn_attribute_wrong_decl_type)
        << AL << ExpectedFunctionMethodOrBlock;
    return;
  }
}

D->addAttr(::new (S.Context) AnalyzerNoReturnAttr(S.Context, AL));
2160}

2162// PS3 PPU-specific.
2163static void handleVecReturnAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
/*
  Returning a Vector Class in Registers

  According to the PPU ABI specifications, a class with a single member of
  vector type is returned in memory when used as the return value of a
  function.
  This results in inefficient code when implementing vector classes. To return
  the value in a single vector register, add the vecreturn attribute to the
  class definition. This attribute is also applicable to struct types.

  Example:

  struct Vector
  {
    __vector float xyzw;
  } __attribute__((vecreturn));

  Vector Add(Vector lhs, Vector rhs)
  {
    Vector result;
    result.xyzw = vec_add(lhs.xyzw, rhs.xyzw);
    return result; // This will be returned in a register
  }
*/
if (VecReturnAttr *A = D->getAttr<VecReturnAttr>()) {
  S.Diag(AL.getLoc(), diag::err_repeat_attribute) << A;
  return;
}

const auto *R = cast<RecordDecl>(D);
int count = 0;

if (!isa<CXXRecordDecl>(R)) {
  S.Diag(AL.getLoc(), diag::err_attribute_vecreturn_only_vector_member);
  return;
}

if (!cast<CXXRecordDecl>(R)->isPOD()) {
  S.Diag(AL.getLoc(), diag::err_attribute_vecreturn_only_pod_record);
  return;
}

for (const auto *I : R->fields()) {
  if ((count == 1) || !I->getType()->isVectorType()) {
    S.Diag(AL.getLoc(), diag::err_attribute_vecreturn_only_vector_member);
    return;
  }
  count++;
}

D->addAttr(::new (S.Context) VecReturnAttr(S.Context, AL));
2215}

2217static void handleDependencyAttr(Sema &S, Scope *Scope, Decl *D,
                               const ParsedAttr &AL) {
if (isa<ParmVarDecl>(D)) {
  // [[carries_dependency]] can only be applied to a parameter if it is a
  // parameter of a function declaration or lambda.
  if (!(Scope->getFlags() & clang::Scope::FunctionDeclarationScope)) {
    S.Diag(AL.getLoc(),
           diag::err_carries_dependency_param_not_function_decl);
    return;
  }
}

D->addAttr(::new (S.Context) CarriesDependencyAttr(S.Context, AL));
2230}

2232static void handleUnusedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
bool IsCXX17Attr = AL.isCXX11Attribute() && !AL.getScopeName();

// If this is spelled as the standard C++17 attribute, but not in C++17, warn
// about using it as an extension.
if (!S.getLangOpts().CPlusPlus17 && IsCXX17Attr)
  S.Diag(AL.getLoc(), diag::ext_cxx17_attr) << AL;

D->addAttr(::new (S.Context) UnusedAttr(S.Context, AL));
2241}

2243static void handleConstructorAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
uint32_t priority = ConstructorAttr::DefaultPriority;
if (AL.getNumArgs() &&
    !checkUInt32Argument(S, AL, AL.getArgAsExpr(0), priority))
  return;

D->addAttr(::new (S.Context) ConstructorAttr(S.Context, AL, priority));
2250}

2252static void handleDestructorAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
uint32_t priority = DestructorAttr::DefaultPriority;
if (AL.getNumArgs() &&
    !checkUInt32Argument(S, AL, AL.getArgAsExpr(0), priority))
  return;

D->addAttr(::new (S.Context) DestructorAttr(S.Context, AL, priority));
2259}

2261template <typename AttrTy>
2262static void handleAttrWithMessage(Sema &S, Decl *D, const ParsedAttr &AL) {
// Handle the case where the attribute has a text message.
StringRef Str;
if (AL.getNumArgs() == 1 && !S.checkStringLiteralArgumentAttr(AL, 0, Str))
  return;

D->addAttr(::new (S.Context) AttrTy(S.Context, AL, Str));
2269}

2271static void handleObjCSuppresProtocolAttr(Sema &S, Decl *D,
                                        const ParsedAttr &AL) {
if (!cast<ObjCProtocolDecl>(D)->isThisDeclarationADefinition()) {
  S.Diag(AL.getLoc(), diag::err_objc_attr_protocol_requires_definition)
      << AL << AL.getRange();
  return;
}

D->addAttr(::new (S.Context) ObjCExplicitProtocolImplAttr(S.Context, AL));
2280}

2282static bool checkAvailabilityAttr(Sema &S, SourceRange Range,
                                IdentifierInfo *Platform,
                                VersionTuple Introduced,
                                VersionTuple Deprecated,
                                VersionTuple Obsoleted) {
StringRef PlatformName
  = AvailabilityAttr::getPrettyPlatformName(Platform->getName());
if (PlatformName.empty())
  PlatformName = Platform->getName();

// Ensure that Introduced <= Deprecated <= Obsoleted (although not all
// of these steps are needed).
if (!Introduced.empty() && !Deprecated.empty() &&
    !(Introduced <= Deprecated)) {
  S.Diag(Range.getBegin(), diag::warn_availability_version_ordering)
    << 1 << PlatformName << Deprecated.getAsString()
    << 0 << Introduced.getAsString();
  return true;
}

if (!Introduced.empty() && !Obsoleted.empty() &&
    !(Introduced <= Obsoleted)) {
  S.Diag(Range.getBegin(), diag::warn_availability_version_ordering)
    << 2 << PlatformName << Obsoleted.getAsString()
    << 0 << Introduced.getAsString();
  return true;
}

if (!Deprecated.empty() && !Obsoleted.empty() &&
    !(Deprecated <= Obsoleted)) {
  S.Diag(Range.getBegin(), diag::warn_availability_version_ordering)
    << 2 << PlatformName << Obsoleted.getAsString()
    << 1 << Deprecated.getAsString();
  return true;
}

return false;
2319}

2321/// Check whether the two versions match.
2322///
2323/// If either version tuple is empty, then they are assumed to match. If
2324/// \p BeforeIsOkay is true, then \p X can be less than or equal to \p Y.
2325static bool versionsMatch(const VersionTuple &X, const VersionTuple &Y,
                        bool BeforeIsOkay) {
if (X.empty() || Y.empty())
  return true;

if (X == Y)
  return true;

if (BeforeIsOkay && X < Y)
  return true;

return false;
2337}

2339AvailabilityAttr *Sema::mergeAvailabilityAttr(
  NamedDecl *D, const AttributeCommonInfo &CI, IdentifierInfo *Platform,
  bool Implicit, VersionTuple Introduced, VersionTuple Deprecated,
  VersionTuple Obsoleted, bool IsUnavailable, StringRef Message,
  bool IsStrict, StringRef Replacement, AvailabilityMergeKind AMK,
  int Priority) {
VersionTuple MergedIntroduced = Introduced;
VersionTuple MergedDeprecated = Deprecated;
VersionTuple MergedObsoleted = Obsoleted;
bool FoundAny = false;
bool OverrideOrImpl = false;
switch (AMK) {
case AMK_None:
case AMK_Redeclaration:
  OverrideOrImpl = false;
  break;

case AMK_Override:
case AMK_ProtocolImplementation:
  OverrideOrImpl = true;
  break;
}

if (D->hasAttrs()) {
  AttrVec &Attrs = D->getAttrs();
  for (unsigned i = 0, e = Attrs.size(); i != e;) {
    const auto *OldAA = dyn_cast<AvailabilityAttr>(Attrs[i]);
    if (!OldAA) {
      ++i;
      continue;
    }

    IdentifierInfo *OldPlatform = OldAA->getPlatform();
    if (OldPlatform != Platform) {
      ++i;
      continue;
    }

    // If there is an existing availability attribute for this platform that
    // has a lower priority use the existing one and discard the new
    // attribute.
    if (OldAA->getPriority() < Priority)
      return nullptr;

    // If there is an existing attribute for this platform that has a higher
    // priority than the new attribute then erase the old one and continue
    // processing the attributes.
    if (OldAA->getPriority() > Priority) {
      Attrs.erase(Attrs.begin() + i);
      --e;
      continue;
    }

    FoundAny = true;
    VersionTuple OldIntroduced = OldAA->getIntroduced();
    VersionTuple OldDeprecated = OldAA->getDeprecated();
    VersionTuple OldObsoleted = OldAA->getObsoleted();
    bool OldIsUnavailable = OldAA->getUnavailable();

    if (!versionsMatch(OldIntroduced, Introduced, OverrideOrImpl) ||
        !versionsMatch(Deprecated, OldDeprecated, OverrideOrImpl) ||
        !versionsMatch(Obsoleted, OldObsoleted, OverrideOrImpl) ||
        !(OldIsUnavailable == IsUnavailable ||
          (OverrideOrImpl && !OldIsUnavailable && IsUnavailable))) {
      if (OverrideOrImpl) {
        int Which = -1;
        VersionTuple FirstVersion;
        VersionTuple SecondVersion;
        if (!versionsMatch(OldIntroduced, Introduced, OverrideOrImpl)) {
          Which = 0;
          FirstVersion = OldIntroduced;
          SecondVersion = Introduced;
        } else if (!versionsMatch(Deprecated, OldDeprecated, OverrideOrImpl)) {
          Which = 1;
          FirstVersion = Deprecated;
          SecondVersion = OldDeprecated;
        } else if (!versionsMatch(Obsoleted, OldObsoleted, OverrideOrImpl)) {
          Which = 2;
          FirstVersion = Obsoleted;
          SecondVersion = OldObsoleted;
        }

        if (Which == -1) {
          Diag(OldAA->getLocation(),
               diag::warn_mismatched_availability_override_unavail)
            << AvailabilityAttr::getPrettyPlatformName(Platform->getName())
            << (AMK == AMK_Override);
        } else {
          Diag(OldAA->getLocation(),
               diag::warn_mismatched_availability_override)
            << Which
            << AvailabilityAttr::getPrettyPlatformName(Platform->getName())
            << FirstVersion.getAsString() << SecondVersion.getAsString()
            << (AMK == AMK_Override);
        }
        if (AMK == AMK_Override)
          Diag(CI.getLoc(), diag::note_overridden_method);
        else
          Diag(CI.getLoc(), diag::note_protocol_method);
      } else {
        Diag(OldAA->getLocation(), diag::warn_mismatched_availability);
        Diag(CI.getLoc(), diag::note_previous_attribute);
      }

      Attrs.erase(Attrs.begin() + i);
      --e;
      continue;
    }

    VersionTuple MergedIntroduced2 = MergedIntroduced;
    VersionTuple MergedDeprecated2 = MergedDeprecated;
    VersionTuple MergedObsoleted2 = MergedObsoleted;

    if (MergedIntroduced2.empty())
      MergedIntroduced2 = OldIntroduced;
    if (MergedDeprecated2.empty())
      MergedDeprecated2 = OldDeprecated;
    if (MergedObsoleted2.empty())
      MergedObsoleted2 = OldObsoleted;

    if (checkAvailabilityAttr(*this, OldAA->getRange(), Platform,
                              MergedIntroduced2, MergedDeprecated2,
                              MergedObsoleted2)) {
      Attrs.erase(Attrs.begin() + i);
      --e;
      continue;
    }

    MergedIntroduced = MergedIntroduced2;
    MergedDeprecated = MergedDeprecated2;
    MergedObsoleted = MergedObsoleted2;
    ++i;
  }
}

if (FoundAny &&
    MergedIntroduced == Introduced &&
    MergedDeprecated == Deprecated &&
    MergedObsoleted == Obsoleted)
  return nullptr;

// Only create a new attribute if !OverrideOrImpl, but we want to do
// the checking.
if (!checkAvailabilityAttr(*this, CI.getRange(), Platform, MergedIntroduced,
                           MergedDeprecated, MergedObsoleted) &&
    !OverrideOrImpl) {
  auto *Avail = ::new (Context) AvailabilityAttr(
      Context, CI, Platform, Introduced, Deprecated, Obsoleted, IsUnavailable,
      Message, IsStrict, Replacement, Priority);
  Avail->setImplicit(Implicit);
  return Avail;
}
return nullptr;
2492}

2494static void handleAvailabilityAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (!checkAttributeNumArgs(S, AL, 1))
  return;
IdentifierLoc *Platform = AL.getArgAsIdent(0);

IdentifierInfo *II = Platform->Ident;
if (AvailabilityAttr::getPrettyPlatformName(II->getName()).empty())
  S.Diag(Platform->Loc, diag::warn_availability_unknown_platform)
    << Platform->Ident;

auto *ND = dyn_cast<NamedDecl>(D);
if (!ND) // We warned about this already, so just return.
  return;

AvailabilityChange Introduced = AL.getAvailabilityIntroduced();
AvailabilityChange Deprecated = AL.getAvailabilityDeprecated();
AvailabilityChange Obsoleted = AL.getAvailabilityObsoleted();
bool IsUnavailable = AL.getUnavailableLoc().isValid();
bool IsStrict = AL.getStrictLoc().isValid();
StringRef Str;
if (const auto *SE = dyn_cast_or_null<StringLiteral>(AL.getMessageExpr()))
  Str = SE->getString();
StringRef Replacement;
if (const auto *SE = dyn_cast_or_null<StringLiteral>(AL.getReplacementExpr()))
  Replacement = SE->getString();

if (II->isStr("swift")) {
  if (Introduced.isValid() || Obsoleted.isValid() ||
      (!IsUnavailable && !Deprecated.isValid())) {
    S.Diag(AL.getLoc(),
           diag::warn_availability_swift_unavailable_deprecated_only);
    return;
  }
}

int PriorityModifier = AL.isPragmaClangAttribute()
                           ? Sema::AP_PragmaClangAttribute
                           : Sema::AP_Explicit;
AvailabilityAttr *NewAttr = S.mergeAvailabilityAttr(
    ND, AL, II, false /*Implicit*/, Introduced.Version, Deprecated.Version,
    Obsoleted.Version, IsUnavailable, Str, IsStrict, Replacement,
    Sema::AMK_None, PriorityModifier);
if (NewAttr)
  D->addAttr(NewAttr);

// Transcribe "ios" to "watchos" (and add a new attribute) if the versioning
// matches before the start of the watchOS platform.
if (S.Context.getTargetInfo().getTriple().isWatchOS()) {
  IdentifierInfo *NewII = nullptr;
  if (II->getName() == "ios")
    NewII = &S.Context.Idents.get("watchos");
  else if (II->getName() == "ios_app_extension")
    NewII = &S.Context.Idents.get("watchos_app_extension");

  if (NewII) {
      auto adjustWatchOSVersion = [](VersionTuple Version) -> VersionTuple {
        if (Version.empty())
          return Version;
        auto Major = Version.getMajor();
        auto NewMajor = Major >= 9 ? Major - 7 : 0;
        if (NewMajor >= 2) {
          if (Version.getMinor().hasValue()) {
            if (Version.getSubminor().hasValue())
              return VersionTuple(NewMajor, Version.getMinor().getValue(),
                                  Version.getSubminor().getValue());
            else
              return VersionTuple(NewMajor, Version.getMinor().getValue());
          }
          return VersionTuple(NewMajor);
        }

        return VersionTuple(2, 0);
      };

      auto NewIntroduced = adjustWatchOSVersion(Introduced.Version);
      auto NewDeprecated = adjustWatchOSVersion(Deprecated.Version);
      auto NewObsoleted = adjustWatchOSVersion(Obsoleted.Version);

      AvailabilityAttr *NewAttr = S.mergeAvailabilityAttr(
          ND, AL, NewII, true /*Implicit*/, NewIntroduced, NewDeprecated,
          NewObsoleted, IsUnavailable, Str, IsStrict, Replacement,
          Sema::AMK_None,
          PriorityModifier + Sema::AP_InferredFromOtherPlatform);
      if (NewAttr)
        D->addAttr(NewAttr);
    }
} else if (S.Context.getTargetInfo().getTriple().isTvOS()) {
  // Transcribe "ios" to "tvos" (and add a new attribute) if the versioning
  // matches before the start of the tvOS platform.
  IdentifierInfo *NewII = nullptr;
  if (II->getName() == "ios")
    NewII = &S.Context.Idents.get("tvos");
  else if (II->getName() == "ios_app_extension")
    NewII = &S.Context.Idents.get("tvos_app_extension");

  if (NewII) {
    AvailabilityAttr *NewAttr = S.mergeAvailabilityAttr(
        ND, AL, NewII, true /*Implicit*/, Introduced.Version,
        Deprecated.Version, Obsoleted.Version, IsUnavailable, Str, IsStrict,
        Replacement, Sema::AMK_None,
        PriorityModifier + Sema::AP_InferredFromOtherPlatform);
    if (NewAttr)
      D->addAttr(NewAttr);
    }
}
2599}

2601static void handleExternalSourceSymbolAttr(Sema &S, Decl *D,
                                         const ParsedAttr &AL) {
if (!checkAttributeAtLeastNumArgs(S, AL, 1))
  return;
assert(checkAttributeAtMostNumArgs(S, AL, 3) &&((checkAttributeAtMostNumArgs(S, AL, 3) && "Invalid number of arguments in an external_source_symbol attribute"
) ? static_cast<void> (0) : __assert_fail ("checkAttributeAtMostNumArgs(S, AL, 3) && \"Invalid number of arguments in an external_source_symbol attribute\""
, "/build/llvm-toolchain-snapshot-13~++20210308111132+66e3a4abe99c/clang/lib/Sema/SemaDeclAttr.cpp"
, 2606, __PRETTY_FUNCTION__))
       "Invalid number of arguments in an external_source_symbol attribute")((checkAttributeAtMostNumArgs(S, AL, 3) && "Invalid number of arguments in an external_source_symbol attribute"
) ? static_cast<void> (0) : __assert_fail ("checkAttributeAtMostNumArgs(S, AL, 3) && \"Invalid number of arguments in an external_source_symbol attribute\""
, "/build/llvm-toolchain-snapshot-13~++20210308111132+66e3a4abe99c/clang/lib/Sema/SemaDeclAttr.cpp"
, 2606, __PRETTY_FUNCTION__));

StringRef Language;
if (const auto *SE = dyn_cast_or_null<StringLiteral>(AL.getArgAsExpr(0)))
  Language = SE->getString();
StringRef DefinedIn;
if (const auto *SE = dyn_cast_or_null<StringLiteral>(AL.getArgAsExpr(1)))
  DefinedIn = SE->getString();
bool IsGeneratedDeclaration = AL.getArgAsIdent(2) != nullptr;

D->addAttr(::new (S.Context) ExternalSourceSymbolAttr(
    S.Context, AL, Language, DefinedIn, IsGeneratedDeclaration));
2618}

2620template <class T>
2621static T *mergeVisibilityAttr(Sema &S, Decl *D, const AttributeCommonInfo &CI,
                            typename T::VisibilityType value) {
T *existingAttr = D->getAttr<T>();
if (existingAttr) {
  typename T::VisibilityType existingValue = existingAttr->getVisibility();
  if (existingValue == value)
    return nullptr;
  S.Diag(existingAttr->getLocation(), diag::err_mismatched_visibility);
  S.Diag(CI.getLoc(), diag::note_previous_attribute);
  D->dropAttr<T>();
}
return ::new (S.Context) T(S.Context, CI, value);
2633}

2635VisibilityAttr *Sema::mergeVisibilityAttr(Decl *D,
                                        const AttributeCommonInfo &CI,
                                        VisibilityAttr::VisibilityType Vis) {
return ::mergeVisibilityAttr<VisibilityAttr>(*this, D, CI, Vis);
2639}

2641TypeVisibilityAttr *
2642Sema::mergeTypeVisibilityAttr(Decl *D, const AttributeCommonInfo &CI,
                            TypeVisibilityAttr::VisibilityType Vis) {
return ::mergeVisibilityAttr<TypeVisibilityAttr>(*this, D, CI, Vis);
2645}

2647static void handleVisibilityAttr(Sema &S, Decl *D, const ParsedAttr &AL,
                               bool isTypeVisibility) {
// Visibility attributes don't mean anything on a typedef.
if (isa<TypedefNameDecl>(D)) {
  S.Diag(AL.getRange().getBegin(), diag::warn_attribute_ignored) << AL;
  return;
}

// 'type_visibility' can only go on a type or namespace.
if (isTypeVisibility &&
    !(isa<TagDecl>(D) ||
      isa<ObjCInterfaceDecl>(D) ||
      isa<NamespaceDecl>(D))) {
  S.Diag(AL.getRange().getBegin(), diag::err_attribute_wrong_decl_type)
      << AL << ExpectedTypeOrNamespace;
  return;
}

// Check that the argument is a string literal.
StringRef TypeStr;
SourceLocation LiteralLoc;
if (!S.checkStringLiteralArgumentAttr(AL, 0, TypeStr, &LiteralLoc))
  return;

VisibilityAttr::VisibilityType type;
if (!VisibilityAttr::ConvertStrToVisibilityType(TypeStr, type)) {
  S.Diag(LiteralLoc, diag::warn_attribute_type_not_supported) << AL
                                                              << TypeStr;
  return;
}

// Complain about attempts to use protected visibility on targets
// (like Darwin) that don't support it.
if (type == VisibilityAttr::Protected &&
    !S.Context.getTargetInfo().hasProtectedVisibility()) {
  S.Diag(AL.getLoc(), diag::warn_attribute_protected_visibility);
  type = VisibilityAttr::Default;
}

Attr *newAttr;
if (isTypeVisibility) {
  newAttr = S.mergeTypeVisibilityAttr(
      D, AL, (TypeVisibilityAttr::VisibilityType)type);
} else {
  newAttr = S.mergeVisibilityAttr(D, AL, type);
}
if (newAttr)
  D->addAttr(newAttr);
2695}

2697static void handleObjCNonRuntimeProtocolAttr(Sema &S, Decl *D,
                                           const ParsedAttr &AL) {
handleSimpleAttribute<ObjCNonRuntimeProtocolAttr>(S, D, AL);
2700}

2702static void handleObjCDirectAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
// objc_direct cannot be set on methods declared in the context of a protocol
if (isa<ObjCProtocolDecl>(D->getDeclContext())) {
  S.Diag(AL.getLoc(), diag::err_objc_direct_on_protocol) << false;
  return;
}

if (S.getLangOpts().ObjCRuntime.allowsDirectDispatch()) {
  handleSimpleAttribute<ObjCDirectAttr>(S, D, AL);
} else {
  S.Diag(AL.getLoc(), diag::warn_objc_direct_ignored) << AL;
}
2714}

2716static void handleObjCDirectMembersAttr(Sema &S, Decl *D,
                                      const ParsedAttr &AL) {
if (S.getLangOpts().ObjCRuntime.allowsDirectDispatch()) {
  handleSimpleAttribute<ObjCDirectMembersAttr>(S, D, AL);
} else {
  S.Diag(AL.getLoc(), diag::warn_objc_direct_ignored) << AL;
}
2723}

2725static void handleObjCMethodFamilyAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
const auto *M = cast<ObjCMethodDecl>(D);
if (!AL.isArgIdent(0)) {
  S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
      << AL << 1 << AANT_ArgumentIdentifier;
  return;
}

IdentifierLoc *IL = AL.getArgAsIdent(0);
ObjCMethodFamilyAttr::FamilyKind F;
if (!ObjCMethodFamilyAttr::ConvertStrToFamilyKind(IL->Ident->getName(), F)) {
  S.Diag(IL->Loc, diag::warn_attribute_type_not_supported) << AL << IL->Ident;
  return;
}

if (F == ObjCMethodFamilyAttr::OMF_init &&
    !M->getReturnType()->isObjCObjectPointerType()) {
  S.Diag(M->getLocation(), diag::err_init_method_bad_return_type)
      << M->getReturnType();
  // Ignore the attribute.
  return;
}

D->addAttr(new (S.Context) ObjCMethodFamilyAttr(S.Context, AL, F));
2749}

2751static void handleObjCNSObject(Sema &S, Decl *D, const ParsedAttr &AL) {
if (const auto *TD = dyn_cast<TypedefNameDecl>(D)) {
  QualType T = TD->getUnderlyingType();
  if (!T->isCARCBridgableType()) {
    S.Diag(TD->getLocation(), diag::err_nsobject_attribute);
    return;
  }
}
else if (const auto *PD = dyn_cast<ObjCPropertyDecl>(D)) {
  QualType T = PD->getType();
  if (!T->isCARCBridgableType()) {
    S.Diag(PD->getLocation(), diag::err_nsobject_attribute);
    return;
  }
}
else {
  // It is okay to include this attribute on properties, e.g.:
  //
  //  @property (retain, nonatomic) struct Bork *Q __attribute__((NSObject));
  //
  // In this case it follows tradition and suppresses an error in the above
  // case.
  S.Diag(D->getLocation(), diag::warn_nsobject_attribute);
}
D->addAttr(::new (S.Context) ObjCNSObjectAttr(S.Context, AL));
2776}

2778static void handleObjCIndependentClass(Sema &S, Decl *D, const ParsedAttr &AL) {
if (const auto *TD = dyn_cast<TypedefNameDecl>(D)) {
  QualType T = TD->getUnderlyingType();
  if (!T->isObjCObjectPointerType()) {
    S.Diag(TD->getLocation(), diag::warn_ptr_independentclass_attribute);
    return;
  }
} else {
  S.Diag(D->getLocation(), diag::warn_independentclass_attribute);
  return;
}
D->addAttr(::new (S.Context) ObjCIndependentClassAttr(S.Context, AL));
2790}

2792static void handleBlocksAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (!AL.isArgIdent(0)) {
  S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
      << AL << 1 << AANT_ArgumentIdentifier;
  return;
}

IdentifierInfo *II = AL.getArgAsIdent(0)->Ident;
BlocksAttr::BlockType type;
if (!BlocksAttr::ConvertStrToBlockType(II->getName(), type)) {
  S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported) << AL << II;
  return;
}

D->addAttr(::new (S.Context) BlocksAttr(S.Context, AL, type));
2807}

2809static void handleSentinelAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
unsigned sentinel = (unsigned)SentinelAttr::DefaultSentinel;
if (AL.getNumArgs() > 0) {
  Expr *E = AL.getArgAsExpr(0);
  Optional<llvm::APSInt> Idx = llvm::APSInt(32);
  if (E->isTypeDependent() || E->isValueDependent() ||
      !(Idx = E->getIntegerConstantExpr(S.Context))) {
    S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
        << AL << 1 << AANT_ArgumentIntegerConstant << E->getSourceRange();
    return;
  }

  if (Idx->isSigned() && Idx->isNegative()) {
    S.Diag(AL.getLoc(), diag::err_attribute_sentinel_less_than_zero)
      << E->getSourceRange();
    return;
  }

  sentinel = Idx->getZExtValue();
}

unsigned nullPos = (unsigned)SentinelAttr::DefaultNullPos;
if (AL.getNumArgs() > 1) {
  Expr *E = AL.getArgAsExpr(1);
  Optional<llvm::APSInt> Idx = llvm::APSInt(32);
  if (E->isTypeDependent() || E->isValueDependent() ||
      !(Idx = E->getIntegerConstantExpr(S.Context))) {
    S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
        << AL << 2 << AANT_ArgumentIntegerConstant << E->getSourceRange();
    return;
  }
  nullPos = Idx->getZExtValue();

  if ((Idx->isSigned() && Idx->isNegative()) || nullPos > 1) {
    // FIXME: This error message could be improved, it would be nice
    // to say what the bounds actually are.
    S.Diag(AL.getLoc(), diag::err_attribute_sentinel_not_zero_or_one)
      << E->getSourceRange();
    return;
  }
}

if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
  const FunctionType *FT = FD->getType()->castAs<FunctionType>();
  if (isa<FunctionNoProtoType>(FT)) {
    S.Diag(AL.getLoc(), diag::warn_attribute_sentinel_named_arguments);
    return;
  }

  if (!cast<FunctionProtoType>(FT)->isVariadic()) {
    S.Diag(AL.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0;
    return;
  }
} else if (const auto *MD = dyn_cast<ObjCMethodDecl>(D)) {
  if (!MD->isVariadic()) {
    S.Diag(AL.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0;
    return;
  }
} else if (const auto *BD = dyn_cast<BlockDecl>(D)) {
  if (!BD->isVariadic()) {
    S.Diag(AL.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 1;
    return;
  }
} else if (const auto *V = dyn_cast<VarDecl>(D)) {
  QualType Ty = V->getType();
  if (Ty->isBlockPointerType() || Ty->isFunctionPointerType()) {
    const FunctionType *FT = Ty->isFunctionPointerType()
     ? D->getFunctionType()
     : Ty->castAs<BlockPointerType>()->getPointeeType()->getAs<FunctionType>();
    if (!cast<FunctionProtoType>(FT)->isVariadic()) {
      int m = Ty->isFunctionPointerType() ? 0 : 1;
      S.Diag(AL.getLoc(), diag::warn_attribute_sentinel_not_variadic) << m;
      return;
    }
  } else {
    S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type)
        << AL << ExpectedFunctionMethodOrBlock;
    return;
  }
} else {
  S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type)
      << AL << ExpectedFunctionMethodOrBlock;
  return;
}
D->addAttr(::new (S.Context) SentinelAttr(S.Context, AL, sentinel, nullPos));
2894}

2896static void handleWarnUnusedResult(Sema &S, Decl *D, const ParsedAttr &AL) {
if (D->getFunctionType() &&
    D->getFunctionType()->getReturnType()->isVoidType() &&
    !isa<CXXConstructorDecl>(D)) {
  S.Diag(AL.getLoc(), diag::warn_attribute_void_function_method) << AL << 0;
  return;
}
if (const auto *MD = dyn_cast<ObjCMethodDecl>(D))
  if (MD->getReturnType()->isVoidType()) {
    S.Diag(AL.getLoc(), diag::warn_attribute_void_function_method) << AL << 1;
    return;
  }

StringRef Str;
if ((AL.isCXX11Attribute() || AL.isC2xAttribute()) && !AL.getScopeName()) {
  // The standard attribute cannot be applied to variable declarations such
  // as a function pointer.
  if (isa<VarDecl>(D))
    S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type_str)
        << AL << "functions, classes, or enumerations";

  // If this is spelled as the standard C++17 attribute, but not in C++17,
  // warn about using it as an extension. If there are attribute arguments,
  // then claim it's a C++2a extension instead.
  // FIXME: If WG14 does not seem likely to adopt the same feature, add an
  // extension warning for C2x mode.
  const LangOptions &LO = S.getLangOpts();
  if (AL.getNumArgs() == 1) {
    if (LO.CPlusPlus && !LO.CPlusPlus20)
      S.Diag(AL.getLoc(), diag::ext_cxx20_attr) << AL;

    // Since this this is spelled [[nodiscard]], get the optional string
    // literal. If in C++ mode, but not in C++2a mode, diagnose as an
    // extension.
    // FIXME: C2x should support this feature as well, even as an extension.
    if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, nullptr))
      return;
  } else if (LO.CPlusPlus && !LO.CPlusPlus17)
    S.Diag(AL.getLoc(), diag::ext_cxx17_attr) << AL;
}

D->addAttr(::new (S.Context) WarnUnusedResultAttr(S.Context, AL, Str));
2938}

2940static void handleWeakImportAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
// weak_import only applies to variable & function declarations.
bool isDef = false;
if (!D->canBeWeakImported(isDef)) {
  if (isDef)
    S.Diag(AL.getLoc(), diag::warn_attribute_invalid_on_definition)
      << "weak_import";
  else if (isa<ObjCPropertyDecl>(D) || isa<ObjCMethodDecl>(D) ||
           (S.Context.getTargetInfo().getTriple().isOSDarwin() &&
            (isa<ObjCInterfaceDecl>(D) || isa<EnumDecl>(D)))) {
    // Nothing to warn about here.
  } else
    S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type)
        << AL << ExpectedVariableOrFunction;

  return;
}

D->addAttr(::new (S.Context) WeakImportAttr(S.Context, AL));
2959}

2961// Handles reqd_work_group_size and work_group_size_hint.
2962template <typename WorkGroupAttr>
2963static void handleWorkGroupSize(Sema &S, Decl *D, const ParsedAttr &AL) {
uint32_t WGSize[3];
for (unsigned i = 0; i < 3; ++i) {
  const Expr *E = AL.getArgAsExpr(i);
  if (!checkUInt32Argument(S, AL, E, WGSize[i], i,
                           /*StrictlyUnsigned=*/true))
    return;
  if (WGSize[i] == 0) {
    S.Diag(AL.getLoc(), diag::err_attribute_argument_is_zero)
        << AL << E->getSourceRange();
    return;
  }
}

WorkGroupAttr *Existing = D->getAttr<WorkGroupAttr>();
if (Existing && !(Existing->getXDim() == WGSize[0] &&
                  Existing->getYDim() == WGSize[1] &&
                  Existing->getZDim() == WGSize[2]))
  S.Diag(AL.getLoc(), diag::warn_duplicate_attribute) << AL;

D->addAttr(::new (S.Context)
               WorkGroupAttr(S.Context, AL, WGSize[0], WGSize[1], WGSize[2]));
2985}

2987// Handles intel_reqd_sub_group_size.
2988static void handleSubGroupSize(Sema &S, Decl *D, const ParsedAttr &AL) {
uint32_t SGSize;
const Expr *E = AL.getArgAsExpr(0);
if (!checkUInt32Argument(S, AL, E, SGSize))
  return;
if (SGSize == 0) {
  S.Diag(AL.getLoc(), diag::err_attribute_argument_is_zero)
      << AL << E->getSourceRange();
  return;
}

OpenCLIntelReqdSubGroupSizeAttr *Existing =
    D->getAttr<OpenCLIntelReqdSubGroupSizeAttr>();
if (Existing && Existing->getSubGroupSize() != SGSize)
  S.Diag(AL.getLoc(), diag::warn_duplicate_attribute) << AL;

D->addAttr(::new (S.Context)
               OpenCLIntelReqdSubGroupSizeAttr(S.Context, AL, SGSize));
3006}

3008static void handleVecTypeHint(Sema &S, Decl *D, const ParsedAttr &AL) {
if (!AL.hasParsedType()) {
  S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) << AL << 1;
  return;
}

TypeSourceInfo *ParmTSI = nullptr;
QualType ParmType = S.GetTypeFromParser(AL.getTypeArg(), &ParmTSI);
assert(ParmTSI && "no type source info for attribute argument")((ParmTSI && "no type source info for attribute argument"
) ? static_cast<void> (0) : __assert_fail ("ParmTSI && \"no type source info for attribute argument\""
, "/build/llvm-toolchain-snapshot-13~++20210308111132+66e3a4abe99c/clang/lib/Sema/SemaDeclAttr.cpp"
, 3016, __PRETTY_FUNCTION__));

if (!ParmType->isExtVectorType() && !ParmType->isFloatingType() &&
    (ParmType->isBooleanType() ||
     !ParmType->isIntegralType(S.getASTContext()))) {
  S.Diag(AL.getLoc(), diag::err_attribute_invalid_argument) << 2 << AL;
  return;
}

if (VecTypeHintAttr *A = D->getAttr<VecTypeHintAttr>()) {
  if (!S.Context.hasSameType(A->getTypeHint(), ParmType)) {
    S.Diag(AL.getLoc(), diag::warn_duplicate_attribute) << AL;
    return;
  }
}

D->addAttr(::new (S.Context) VecTypeHintAttr(S.Context, AL, ParmTSI));
3033}

3035SectionAttr *Sema::mergeSectionAttr(Decl *D, const AttributeCommonInfo &CI,
                                  StringRef Name) {
// Explicit or partial specializations do not inherit
// the section attribute from the primary template.
if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
  if (CI.getAttributeSpellingListIndex() == SectionAttr::Declspec_allocate &&
      FD->isFunctionTemplateSpecialization())
    return nullptr;
}
if (SectionAttr *ExistingAttr = D->getAttr<SectionAttr>()) {
  if (ExistingAttr->getName() == Name)
    return nullptr;
  Diag(ExistingAttr->getLocation(), diag::warn_mismatched_section)
       << 1 /*section*/;
  Diag(CI.getLoc(), diag::note_previous_attribute);
  return nullptr;
}
return ::new (Context) SectionAttr(Context, CI, Name);
3053}

3055bool Sema::checkSectionName(SourceLocation LiteralLoc, StringRef SecName) {
if (llvm::Error E =
        Context.getTargetInfo().isValidSectionSpecifier(SecName)) {
  Diag(LiteralLoc, diag::err_attribute_section_invalid_for_target)
      << toString(std::move(E)) << 1 /*'section'*/;
  return false;
}
return true;
3063}

3065static void handleSectionAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
// Make sure that there is a string literal as the sections's single
// argument.
StringRef Str;
SourceLocation LiteralLoc;
if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &LiteralLoc))
  return;

if (!S.checkSectionName(LiteralLoc, Str))
  return;

// If the target wants to validate the section specifier, make it happen.
if (llvm::Error E = S.Context.getTargetInfo().isValidSectionSpecifier(Str)) {
  S.Diag(LiteralLoc, diag::err_attribute_section_invalid_for_target)
      << toString(std::move(E));
  return;
}

SectionAttr *NewAttr = S.mergeSectionAttr(D, AL, Str);
if (NewAttr) {
  D->addAttr(NewAttr);
  if (isa<FunctionDecl, FunctionTemplateDecl, ObjCMethodDecl,
          ObjCPropertyDecl>(D))
    S.UnifySection(NewAttr->getName(),
                   ASTContext::PSF_Execute | ASTContext::PSF_Read,
                   cast<NamedDecl>(D));
}
3092}

3094// This is used for `__declspec(code_seg("segname"))` on a decl.
3095// `#pragma code_seg("segname")` uses checkSectionName() instead.
3096static bool checkCodeSegName(Sema &S, SourceLocation LiteralLoc,
                           StringRef CodeSegName) {
if (llvm::Error E =
        S.Context.getTargetInfo().isValidSectionSpecifier(CodeSegName)) {
  S.Diag(LiteralLoc, diag::err_attribute_section_invalid_for_target)
      << toString(std::move(E)) << 0 /*'code-seg'*/;
  return false;
}

return true;
3106}

3108CodeSegAttr *Sema::mergeCodeSegAttr(Decl *D, const AttributeCommonInfo &CI,
                                  StringRef Name) {
// Explicit or partial specializations do not inherit
// the code_seg attribute from the primary template.
if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
  if (FD->isFunctionTemplateSpecialization())
    return nullptr;
}
if (const auto *ExistingAttr = D->getAttr<CodeSegAttr>()) {
  if (ExistingAttr->getName() == Name)
    return nullptr;
  Diag(ExistingAttr->getLocation(), diag::warn_mismatched_section)
       << 0 /*codeseg*/;
  Diag(CI.getLoc(), diag::note_previous_attribute);
  return nullptr;
}
return ::new (Context) CodeSegAttr(Context, CI, Name);
3125}

3127static void handleCodeSegAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
StringRef Str;
SourceLocation LiteralLoc;
if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &LiteralLoc))
  return;
if (!checkCodeSegName(S, LiteralLoc, Str))
  return;
if (const auto *ExistingAttr = D->getAttr<CodeSegAttr>()) {
  if (!ExistingAttr->isImplicit()) {
    S.Diag(AL.getLoc(),
           ExistingAttr->getName() == Str
           ? diag::warn_duplicate_codeseg_attribute
           : diag::err_conflicting_codeseg_attribute);
    return;
  }
  D->dropAttr<CodeSegAttr>();
}
if (CodeSegAttr *CSA = S.mergeCodeSegAttr(D, AL, Str))
  D->addAttr(CSA);
3146}

3148// Check for things we'd like to warn about. Multiversioning issues are
3149// handled later in the process, once we know how many exist.
3150bool Sema::checkTargetAttr(SourceLocation LiteralLoc, StringRef AttrStr) {
enum FirstParam { Unsupported, Duplicate, Unknown };
enum SecondParam { None, Architecture, Tune };
if (AttrStr.find("fpmath=") != StringRef::npos)
  return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
         << Unsupported << None << "fpmath=";

// Diagnose use of tune if target doesn't support it.
if (!Context.getTargetInfo().supportsTargetAttributeTune() &&
    AttrStr.find("tune=") != StringRef::npos)
  return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
         << Unsupported << None << "tune=";

ParsedTargetAttr ParsedAttrs = TargetAttr::parse(AttrStr);

if (!ParsedAttrs.Architecture.empty() &&
    !Context.getTargetInfo().isValidCPUName(ParsedAttrs.Architecture))
  return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
         << Unknown << Architecture << ParsedAttrs.Architecture;

if (!ParsedAttrs.Tune.empty() &&
    !Context.getTargetInfo().isValidCPUName(ParsedAttrs.Tune))
  return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
         << Unknown << Tune << ParsedAttrs.Tune;

if (ParsedAttrs.DuplicateArchitecture)
  return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
         << Duplicate << None << "arch=";
if (ParsedAttrs.DuplicateTune)
  return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
         << Duplicate << None << "tune=";

for (const auto &Feature : ParsedAttrs.Features) {
  auto CurFeature = StringRef(Feature).drop_front(); // remove + or -.
  if (!Context.getTargetInfo().isValidFeatureName(CurFeature))
    return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
           << Unsupported << None << CurFeature;
}

TargetInfo::BranchProtectionInfo BPI;
StringRef Error;
if (!ParsedAttrs.BranchProtection.empty() &&
    !Context.getTargetInfo().validateBranchProtection(
        ParsedAttrs.BranchProtection, BPI, Error)) {
  if (Error.empty())
    return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
           << Unsupported << None << "branch-protection";
  else
    return Diag(LiteralLoc, diag::err_invalid_branch_protection_spec)
           << Error;
}

return false;
3203}

3205static void handleTargetAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
StringRef Str;
SourceLocation LiteralLoc;
if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &LiteralLoc) ||
    S.checkTargetAttr(LiteralLoc, Str))
  return;

TargetAttr *NewAttr = ::new (S.Context) TargetAttr(S.Context, AL, Str);
D->addAttr(NewAttr);
3214}

3216static void handleMinVectorWidthAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
Expr *E = AL.getArgAsExpr(0);
uint32_t VecWidth;
if (!checkUInt32Argument(S, AL, E, VecWidth)) {
  AL.setInvalid();
  return;
}

MinVectorWidthAttr *Existing = D->getAttr<MinVectorWidthAttr>();
if (Existing && Existing->getVectorWidth() != VecWidth) {
  S.Diag(AL.getLoc(), diag::warn_duplicate_attribute) << AL;
  return;
}

D->addAttr(::new (S.Context) MinVectorWidthAttr(S.Context, AL, VecWidth));
3231}

3233static void handleCleanupAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
Expr *E = AL.getArgAsExpr(0);
SourceLocation Loc = E->getExprLoc();
FunctionDecl *FD = nullptr;
DeclarationNameInfo NI;

// gcc only allows for simple identifiers. Since we support more than gcc, we
// will warn the user.
if (auto *DRE = dyn_cast<DeclRefExpr>(E)) {
  if (DRE->hasQualifier())
    S.Diag(Loc, diag::warn_cleanup_ext);
  FD = dyn_cast<FunctionDecl>(DRE->getDecl());
  NI = DRE->getNameInfo();
  if (!FD) {
    S.Diag(Loc, diag::err_attribute_cleanup_arg_not_function) << 1
      << NI.getName();
    return;
  }
} else if (auto *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
  if (ULE->hasExplicitTemplateArgs())
    S.Diag(Loc, diag::warn_cleanup_ext);
  FD = S.ResolveSingleFunctionTemplateSpecialization(ULE, true);
  NI = ULE->getNameInfo();
  if (!FD) {
    S.Diag(Loc, diag::err_attribute_cleanup_arg_not_function) << 2
      << NI.getName();
    if (ULE->getType() == S.Context.OverloadTy)
      S.NoteAllOverloadCandidates(ULE);
    return;
  }
} else {
  S.Diag(Loc, diag::err_attribute_cleanup_arg_not_function) << 0;
  return;
}

if (FD->getNumParams() != 1) {
  S.Diag(Loc, diag::err_attribute_cleanup_func_must_take_one_arg)
    << NI.getName();
  return;
}

// We're currently more strict than GCC about what function types we accept.
// If this ever proves to be a problem it should be easy to fix.
QualType Ty = S.Context.getPointerType(cast<VarDecl>(D)->getType());
QualType ParamTy = FD->getParamDecl(0)->getType();
if (S.CheckAssignmentConstraints(FD->getParamDecl(0)->getLocation(),
                                 ParamTy, Ty) != Sema::Compatible) {
  S.Diag(Loc, diag::err_attribute_cleanup_func_arg_incompatible_type)
    << NI.getName() << ParamTy << Ty;
  return;
}

D->addAttr(::new (S.Context) CleanupAttr(S.Context, AL, FD));
3286}

3288static void handleEnumExtensibilityAttr(Sema &S, Decl *D,
                                      const ParsedAttr &AL) {
if (!AL.isArgIdent(0)) {
  S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
      << AL << 0 << AANT_ArgumentIdentifier;
  return;
}

EnumExtensibilityAttr::Kind ExtensibilityKind;
IdentifierInfo *II = AL.getArgAsIdent(0)->Ident;
if (!EnumExtensibilityAttr::ConvertStrToKind(II->getName(),
                                             ExtensibilityKind)) {
  S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported) << AL << II;
  return;
}

D->addAttr(::new (S.Context)
               EnumExtensibilityAttr(S.Context, AL, ExtensibilityKind));
3306}

3308/// Handle __attribute__((format_arg((idx)))) attribute based on
3309/// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
3310static void handleFormatArgAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
Expr *IdxExpr = AL.getArgAsExpr(0);
ParamIdx Idx;
if (!checkFunctionOrMethodParameterIndex(S, D, AL, 1, IdxExpr, Idx))
  return;

// Make sure the format string is really a string.
QualType Ty = getFunctionOrMethodParamType(D, Idx.getASTIndex());

bool NotNSStringTy = !isNSStringType(Ty, S.Context);
if (NotNSStringTy &&
    !isCFStringType(Ty, S.Context) &&
    (!Ty->isPointerType() ||
     !Ty->castAs<PointerType>()->getPointeeType()->isCharType())) {
  S.Diag(AL.getLoc(), diag::err_format_attribute_not)
      << "a string type" << IdxExpr->getSourceRange()
      << getFunctionOrMethodParamRange(D, 0);
  return;
}
Ty = getFunctionOrMethodResultType(D);
if (!isNSStringType(Ty, S.Context) &&
    !isCFStringType(Ty, S.Context) &&
    (!Ty->isPointerType() ||
     !Ty->castAs<PointerType>()->getPointeeType()->isCharType())) {
  S.Diag(AL.getLoc(), diag::err_format_attribute_result_not)
      << (NotNSStringTy ? "string type" : "NSString")
      << IdxExpr->getSourceRange() << getFunctionOrMethodParamRange(D, 0);
  return;
}

D->addAttr(::new (S.Context) FormatArgAttr(S.Context, AL, Idx));
3341}

3343enum FormatAttrKind {
CFStringFormat,
NSStringFormat,
StrftimeFormat,
SupportedFormat,
IgnoredFormat,
InvalidFormat
3350};

3352/// getFormatAttrKind - Map from format attribute names to supported format
3353/// types.
3354static FormatAttrKind getFormatAttrKind(StringRef Format) {
return llvm::StringSwitch<FormatAttrKind>(Format)
    // Check for formats that get handled specially.
    .Case("NSString", NSStringFormat)
    .Case("CFString", CFStringFormat)
    .Case("strftime", StrftimeFormat)

    // Otherwise, check for supported formats.
    .Cases("scanf", "printf", "printf0", "strfmon", SupportedFormat)
    .Cases("cmn_err", "vcmn_err", "zcmn_err", SupportedFormat)
    .Case("kprintf", SupportedFormat)         // OpenBSD.
    .Case("freebsd_kprintf", SupportedFormat) // FreeBSD.
    .Case("os_trace", SupportedFormat)
    .Case("os_log", SupportedFormat)

    .Cases("gcc_diag", "gcc_cdiag", "gcc_cxxdiag", "gcc_tdiag", IgnoredFormat)
    .Default(InvalidFormat);
3371}

3373/// Handle __attribute__((init_priority(priority))) attributes based on
3374/// http://gcc.gnu.org/onlinedocs/gcc/C_002b_002b-Attributes.html
3375static void handleInitPriorityAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (!S.getLangOpts().CPlusPlus) {
  S.Diag(AL.getLoc(), diag::warn_attribute_ignored) << AL;
  return;
}

if (S.getCurFunctionOrMethodDecl()) {
  S.Diag(AL.getLoc(), diag::err_init_priority_object_attr);
  AL.setInvalid();
  return;
}
QualType T = cast<VarDecl>(D)->getType();
if (S.Context.getAsArrayType(T))
  T = S.Context.getBaseElementType(T);
if (!T->getAs<RecordType>()) {
  S.Diag(AL.getLoc(), diag::err_init_priority_object_attr);
  AL.setInvalid();
  return;
}

Expr *E = AL.getArgAsExpr(0);
uint32_t prioritynum;
if (!checkUInt32Argument(S, AL, E, prioritynum)) {
  AL.setInvalid();
  return;
}

// Only perform the priority check if the attribute is outside of a system
// header. Values <= 100 are reserved for the implementation, and libc++
// benefits from being able to specify values in that range.
if ((prioritynum < 101 || prioritynum > 65535) &&
    !S.getSourceManager().isInSystemHeader(AL.getLoc())) {
  S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_range)
      << E->getSourceRange() << AL << 101 << 65535;
  AL.setInvalid();
  return;
}
D->addAttr(::new (S.Context) InitPriorityAttr(S.Context, AL, prioritynum));
3413}

3415FormatAttr *Sema::mergeFormatAttr(Decl *D, const AttributeCommonInfo &CI,
                                IdentifierInfo *Format, int FormatIdx,
                                int FirstArg) {
// Check whether we already have an equivalent format attribute.
for (auto *F : D->specific_attrs<FormatAttr>()) {
  if (F->getType() == Format &&
      F->getFormatIdx() == FormatIdx &&
      F->getFirstArg() == FirstArg) {
    // If we don't have a valid location for this attribute, adopt the
    // location.
    if (F->getLocation().isInvalid())
      F->setRange(CI.getRange());
    return nullptr;
  }
}

return ::new (Context) FormatAttr(Context, CI, Format, FormatIdx, FirstArg);
3432}

3434/// Handle __attribute__((format(type,idx,firstarg))) attributes based on
3435/// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
3436static void handleFormatAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (!AL.isArgIdent(0)) {
  S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
      << AL << 1 << AANT_ArgumentIdentifier;
  return;
}

// In C++ the implicit 'this' function parameter also counts, and they are
// counted from one.
bool HasImplicitThisParam = isInstanceMethod(D);
unsigned NumArgs = getFunctionOrMethodNumParams(D) + HasImplicitThisParam;

IdentifierInfo *II = AL.getArgAsIdent(0)->Ident;
StringRef Format = II->getName();

if (normalizeName(Format)) {
  // If we've modified the string name, we need a new identifier for it.
  II = &S.Context.Idents.get(Format);
}

// Check for supported formats.
FormatAttrKind Kind = getFormatAttrKind(Format);

if (Kind == IgnoredFormat)
  return;

if (Kind == InvalidFormat) {
  S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported)
      << AL << II->getName();
  return;
}

// checks for the 2nd argument
Expr *IdxExpr = AL.getArgAsExpr(1);
uint32_t Idx;
if (!checkUInt32Argument(S, AL, IdxExpr, Idx, 2))
  return;

if (Idx < 1 || Idx > NumArgs) {
  S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_bounds)
      << AL << 2 << IdxExpr->getSourceRange();
  return;
}

// FIXME: Do we need to bounds check?
unsigned ArgIdx = Idx - 1;

if (HasImplicitThisParam) {
  if (ArgIdx == 0) {
    S.Diag(AL.getLoc(),
           diag::err_format_attribute_implicit_this_format_string)
      << IdxExpr->getSourceRange();
    return;
  }
  ArgIdx--;
}

// make sure the format string is really a string
QualType Ty = getFunctionOrMethodParamType(D, ArgIdx);

if (Kind == CFStringFormat) {
  if (!isCFStringType(Ty, S.Context)) {
    S.Diag(AL.getLoc(), diag::err_format_attribute_not)
      << "a CFString" << IdxExpr->getSourceRange()
      << getFunctionOrMethodParamRange(D, ArgIdx);
    return;
  }
} else if (Kind == NSStringFormat) {
  // FIXME: do we need to check if the type is NSString*?  What are the
  // semantics?
  if (!isNSStringType(Ty, S.Context)) {
    S.Diag(AL.getLoc(), diag::err_format_attribute_not)
      << "an NSString" << IdxExpr->getSourceRange()
      << getFunctionOrMethodParamRange(D, ArgIdx);
    return;
  }
} else if (!Ty->isPointerType() ||
           !Ty->castAs<PointerType>()->getPointeeType()->isCharType()) {
  S.Diag(AL.getLoc(), diag::err_format_attribute_not)
    << "a string type" << IdxExpr->getSourceRange()
    << getFunctionOrMethodParamRange(D, ArgIdx);
  return;
}

// check the 3rd argument
Expr *FirstArgExpr = AL.getArgAsExpr(2);
uint32_t FirstArg;
if (!checkUInt32Argument(S, AL, FirstArgExpr, FirstArg, 3))
  return;

// check if the function is variadic if the 3rd argument non-zero
if (FirstArg != 0) {
  if (isFunctionOrMethodVariadic(D)) {
    ++NumArgs; // +1 for ...
  } else {
    S.Diag(D->getLocation(), diag::err_format_attribute_requires_variadic);
    return;
  }
}

// strftime requires FirstArg to be 0 because it doesn't read from any
// variable the input is just the current time + the format string.
if (Kind == StrftimeFormat) {
  if (FirstArg != 0) {
    S.Diag(AL.getLoc(), diag::err_format_strftime_third_parameter)
      << FirstArgExpr->getSourceRange();
    return;
  }
// if 0 it disables parameter checking (to use with e.g. va_list)
} else if (FirstArg != 0 && FirstArg != NumArgs) {
  S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_bounds)
      << AL << 3 << FirstArgExpr->getSourceRange();
  return;
}

FormatAttr *NewAttr = S.mergeFormatAttr(D, AL, II, Idx, FirstArg);
if (NewAttr)
  D->addAttr(NewAttr);
3554}

3556/// Handle __attribute__((callback(CalleeIdx, PayloadIdx0, ...))) attributes.
3557static void handleCallbackAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
// The index that identifies the callback callee is mandatory.
if (AL.getNumArgs() == 0) {
  S.Diag(AL.getLoc(), diag::err_callback_attribute_no_callee)
      << AL.getRange();
  return;
}

bool HasImplicitThisParam = isInstanceMethod(D);
int32_t NumArgs = getFunctionOrMethodNumParams(D);

FunctionDecl *FD = D->getAsFunction();
assert(FD && "Expected a function declaration!")((FD && "Expected a function declaration!") ? static_cast
<void> (0) : __assert_fail ("FD && \"Expected a function declaration!\""
, "/build/llvm-toolchain-snapshot-13~++20210308111132+66e3a4abe99c/clang/lib/Sema/SemaDeclAttr.cpp"
, 3569, __PRETTY_FUNCTION__));

llvm::StringMap<int> NameIdxMapping;
NameIdxMapping["__"] = -1;

NameIdxMapping["this"] = 0;

int Idx = 1;
for (const ParmVarDecl *PVD : FD->parameters())
  NameIdxMapping[PVD->getName()] = Idx++;

auto UnknownName = NameIdxMapping.end();

SmallVector<int, 8> EncodingIndices;
for (unsigned I = 0, E = AL.getNumArgs(); I < E; ++I) {
  SourceRange SR;
  int32_t ArgIdx;

  if (AL.isArgIdent(I)) {
    IdentifierLoc *IdLoc = AL.getArgAsIdent(I);
    auto It = NameIdxMapping.find(IdLoc->Ident->getName());
    if (It == UnknownName) {
      S.Diag(AL.getLoc(), diag::err_callback_attribute_argument_unknown)
          << IdLoc->Ident << IdLoc->Loc;
      return;
    }

    SR = SourceRange(IdLoc->Loc);
    ArgIdx = It->second;
  } else if (AL.isArgExpr(I)) {
    Expr *IdxExpr = AL.getArgAsExpr(I);

    // If the expression is not parseable as an int32_t we have a problem.
    if (!checkUInt32Argument(S, AL, IdxExpr, (uint32_t &)ArgIdx, I + 1,
                             false)) {
      S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_bounds)
          << AL << (I + 1) << IdxExpr->getSourceRange();
      return;
    }

    // Check oob, excluding the special values, 0 and -1.
    if (ArgIdx < -1 || ArgIdx > NumArgs) {
      S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_bounds)
          << AL << (I + 1) << IdxExpr->getSourceRange();
      return;
    }

    SR = IdxExpr->getSourceRange();
  } else {
    llvm_unreachable("Unexpected ParsedAttr argument type!")::llvm::llvm_unreachable_internal("Unexpected ParsedAttr argument type!"
, "/build/llvm-toolchain-snapshot-13~++20210308111132+66e3a4abe99c/clang/lib/Sema/SemaDeclAttr.cpp"
, 3618);
  }

  if (ArgIdx == 0 && !HasImplicitThisParam) {
    S.Diag(AL.getLoc(), diag::err_callback_implicit_this_not_available)
        << (I + 1) << SR;
    return;
  }

  // Adjust for the case we do not have an implicit "this" parameter. In this
  // case we decrease all positive values by 1 to get LLVM argument indices.
  if (!HasImplicitThisParam && ArgIdx > 0)
    ArgIdx -= 1;

  EncodingIndices.push_back(ArgIdx);
}

int CalleeIdx = EncodingIndices.front();
// Check if the callee index is proper, thus not "this" and not "unknown".
// This means the "CalleeIdx" has to be non-negative if "HasImplicitThisParam"
// is false and positive if "HasImplicitThisParam" is true.
if (CalleeIdx < (int)HasImplicitThisParam) {
  S.Diag(AL.getLoc(), diag::err_callback_attribute_invalid_callee)
      << AL.getRange();
  return;
}

// Get the callee type, note the index adjustment as the AST doesn't contain
// the this type (which the callee cannot reference anyway!).
const Type *CalleeType =
    getFunctionOrMethodParamType(D, CalleeIdx - HasImplicitThisParam)
        .getTypePtr();
if (!CalleeType || !CalleeType->isFunctionPointerType()) {
  S.Diag(AL.getLoc(), diag::err_callback_callee_no_function_type)
      << AL.getRange();
  return;
}

const Type *CalleeFnType =
    CalleeType->getPointeeType()->getUnqualifiedDesugaredType();

// TODO: Check the type of the callee arguments.

const auto *CalleeFnProtoType = dyn_cast<FunctionProtoType>(CalleeFnType);
if (!CalleeFnProtoType) {
  S.Diag(AL.getLoc(), diag::err_callback_callee_no_function_type)
      << AL.getRange();
  return;
}

if (CalleeFnProtoType->getNumParams() > EncodingIndices.size() - 1) {
  S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments)
      << AL << (unsigned)(EncodingIndices.size() - 1);
  return;
}

if (CalleeFnProtoType->getNumParams() < EncodingIndices.size() - 1) {
  S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments)
      << AL << (unsigned)(EncodingIndices.size() - 1);
  return;
}

if (CalleeFnProtoType->isVariadic()) {
  S.Diag(AL.getLoc(), diag::err_callback_callee_is_variadic) << AL.getRange();
  return;
}

// Do not allow multiple callback attributes.
if (D->hasAttr<CallbackAttr>()) {
  S.Diag(AL.getLoc(), diag::err_callback_attribute_multiple) << AL.getRange();
  return;
}

D->addAttr(::new (S.Context) CallbackAttr(
    S.Context, AL, EncodingIndices.data(), EncodingIndices.size()));
3693}

3695static bool isFunctionLike(const Type &T) {
// Check for explicit function types.
// 'called_once' is only supported in Objective-C and it has
// function pointers and block pointers.
return T.isFunctionPointerType() || T.isBlockPointerType();
3700}

3702/// Handle 'called_once' attribute.
3703static void handleCalledOnceAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
// 'called_once' only applies to parameters representing functions.
QualType T = cast<ParmVarDecl>(D)->getType();

if (!isFunctionLike(*T)) {
  S.Diag(AL.getLoc(), diag::err_called_once_attribute_wrong_type);
  return;
}

D->addAttr(::new (S.Context) CalledOnceAttr(S.Context, AL));
3713}

3715static void handleTransparentUnionAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
// Try to find the underlying union declaration.
RecordDecl *RD = nullptr;
const auto *TD = dyn_cast<TypedefNameDecl>(D);
if (TD && TD->getUnderlyingType()->isUnionType())
  RD = TD->getUnderlyingType()->getAsUnionType()->getDecl();
else
  RD = dyn_cast<RecordDecl>(D);

if (!RD || !RD->isUnion()) {
  S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type) << AL
                                                            << ExpectedUnion;
  return;
}

if (!RD->isCompleteDefinition()) {
  if (!RD->isBeingDefined())
    S.Diag(AL.getLoc(),
           diag::warn_transparent_union_attribute_not_definition);
  return;
}

RecordDecl::field_iterator Field = RD->field_begin(),
                        FieldEnd = RD->field_end();
if (Field == FieldEnd) {
  S.Diag(AL.getLoc(), diag::warn_transparent_union_attribute_zero_fields);
  return;
}

FieldDecl *FirstField = *Field;
QualType FirstType = FirstField->getType();
if (FirstType->hasFloatingRepresentation() || FirstType->isVectorType()) {
  S.Diag(FirstField->getLocation(),
         diag::warn_transparent_union_attribute_floating)
    << FirstType->isVectorType() << FirstType;
  return;
}

if (FirstType->isIncompleteType())
  return;
uint64_t FirstSize = S.Context.getTypeSize(FirstType);
uint64_t FirstAlign = S.Context.getTypeAlign(FirstType);
for (; Field != FieldEnd; ++Field) {
  QualType FieldType = Field->getType();
  if (FieldType->isIncompleteType())
    return;
  // FIXME: this isn't fully correct; we also need to test whether the
  // members of the union would all have the same calling convention as the
  // first member of the union. Checking just the size and alignment isn't
  // sufficient (consider structs passed on the stack instead of in registers
  // as an example).
  if (S.Context.getTypeSize(FieldType) != FirstSize ||
      S.Context.getTypeAlign(FieldType) > FirstAlign) {
    // Warn if we drop the attribute.
    bool isSize = S.Context.getTypeSize(FieldType) != FirstSize;
    unsigned FieldBits = isSize ? S.Context.getTypeSize(FieldType)
                                : S.Context.getTypeAlign(FieldType);
    S.Diag(Field->getLocation(),
           diag::warn_transparent_union_attribute_field_size_align)
        << isSize << *Field << FieldBits;
    unsigned FirstBits = isSize ? FirstSize : FirstAlign;
    S.Diag(FirstField->getLocation(),
           diag::note_transparent_union_first_field_size_align)
        << isSize << FirstBits;
    return;
  }
}

RD->addAttr(::new (S.Context) TransparentUnionAttr(S.Context, AL));
3784}

3786void Sema::AddAnnotationAttr(Decl *D, const AttributeCommonInfo &CI,
                           StringRef Str, MutableArrayRef<Expr *> Args) {
auto *Attr = AnnotateAttr::Create(Context, Str, Args.data(), Args.size(), CI);
llvm::SmallVector<PartialDiagnosticAt, 8> Notes;
for (unsigned Idx = 0; Idx < Attr->args_size(); Idx++) {
  Expr *&E = Attr->args_begin()[Idx];
  assert(E && "error are handled before")((E && "error are handled before") ? static_cast<void
> (0) : __assert_fail ("E && \"error are handled before\""
, "/build/llvm-toolchain-snapshot-13~++20210308111132+66e3a4abe99c/clang/lib/Sema/SemaDeclAttr.cpp"
, 3792, __PRETTY_FUNCTION__));
  if (E->isValueDependent() || E->isTypeDependent())
    continue;

  if (E->getType()->isArrayType())
    E = ImpCastExprToType(E, Context.getPointerType(E->getType()),
                          clang::CK_ArrayToPointerDecay)
            .get();
  if (E->getType()->isFunctionType())
    E = ImplicitCastExpr::Create(Context,
                                 Context.getPointerType(E->getType()),
                                 clang::CK_FunctionToPointerDecay, E, nullptr,
                                 VK_RValue, FPOptionsOverride());
  if (E->isLValue())
    E = ImplicitCastExpr::Create(Context, E->getType().getNonReferenceType(),
                                 clang::CK_LValueToRValue, E, nullptr,
                                 VK_RValue, FPOptionsOverride());

  Expr::EvalResult Eval;
  Notes.clear();
  Eval.Diag = &Notes;

  bool Result =
      E->EvaluateAsConstantExpr(Eval, Context);

  /// Result means the expression can be folded to a constant.
  /// Note.empty() means the expression is a valid constant expression in the
  /// current language mode.
  if (!Result || !Notes.empty()) {
    Diag(E->getBeginLoc(), diag::err_attribute_argument_n_type)
        << CI << (Idx + 1) << AANT_ArgumentConstantExpr;
    for (auto &Note : Notes)
      Diag(Note.first, Note.second);
    return;
  }
  assert(Eval.Val.hasValue())((Eval.Val.hasValue()) ? static_cast<void> (0) : __assert_fail
 ("Eval.Val.hasValue()", "/build/llvm-toolchain-snapshot-13~++20210308111132+66e3a4abe99c/clang/lib/Sema/SemaDeclAttr.cpp"
, 3827, __PRETTY_FUNCTION__));
  E = ConstantExpr::Create(Context, E, Eval.Val);
}
D->addAttr(Attr);
3831}

3833static void handleAnnotateAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
// Make sure that there is a string literal as the annotation's first
// argument.
StringRef Str;
if (!S.checkStringLiteralArgumentAttr(AL, 0, Str))
  return;

llvm::SmallVector<Expr *, 4> Args;
Args.reserve(AL.getNumArgs() - 1);
for (unsigned Idx = 1; Idx < AL.getNumArgs(); Idx++) {
  assert(!AL.isArgIdent(Idx))((!AL.isArgIdent(Idx)) ? static_cast<void> (0) : __assert_fail
 ("!AL.isArgIdent(Idx)", "/build/llvm-toolchain-snapshot-13~++20210308111132+66e3a4abe99c/clang/lib/Sema/SemaDeclAttr.cpp"
, 3843, __PRETTY_FUNCTION__));
  Args.push_back(AL.getArgAsExpr(Idx));
}

S.AddAnnotationAttr(D, AL, Str, Args);
3848}

3850static void handleAlignValueAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
S.AddAlignValueAttr(D, AL, AL.getArgAsExpr(0));
3852}

3854void Sema::AddAlignValueAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E) {
AlignValueAttr TmpAttr(Context, CI, E);
SourceLocation AttrLoc = CI.getLoc();

QualType T;
if (const auto *TD = dyn_cast<TypedefNameDecl>(D))
  T = TD->getUnderlyingType();
else if (const auto *VD = dyn_cast<ValueDecl>(D))
  T = VD->getType();
else
  llvm_unreachable("Unknown decl type for align_value")::llvm::llvm_unreachable_internal("Unknown decl type for align_value"
, "/build/llvm-toolchain-snapshot-13~++20210308111132+66e3a4abe99c/clang/lib/Sema/SemaDeclAttr.cpp"
, 3864);

if (!T->isDependentType() && !T->isAnyPointerType() &&
    !T->isReferenceType() && !T->isMemberPointerType()) {
  Diag(AttrLoc, diag::warn_attribute_pointer_or_reference_only)
    << &TmpAttr << T << D->getSourceRange();
  return;
}

if (!E->isValueDependent()) {
  llvm::APSInt Alignment;
  ExprResult ICE = VerifyIntegerConstantExpression(
      E, &Alignment, diag::err_align_value_attribute_argument_not_int);
  if (ICE.isInvalid())
    return;

  if (!Alignment.isPowerOf2()) {
    Diag(AttrLoc, diag::err_alignment_not_power_of_two)
      << E->getSourceRange();
    return;
  }

  D->addAttr(::new (Context) AlignValueAttr(Context, CI, ICE.get()));
  return;
}

// Save dependent expressions in the AST to be instantiated.
D->addAttr(::new (Context) AlignValueAttr(Context, CI, E));
3892}

3894static void handleAlignedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
// check the attribute arguments.
if (AL.getNumArgs() > 1) {
  S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) << AL << 1;
  return;
}

if (AL.getNumArgs() == 0) {
  D->addAttr(::new (S.Context) AlignedAttr(S.Context, AL, true, nullptr));
  return;
}

Expr *E = AL.getArgAsExpr(0);
if (AL.isPackExpansion() && !E->containsUnexpandedParameterPack()) {
  S.Diag(AL.getEllipsisLoc(),
         diag::err_pack_expansion_without_parameter_packs);
  return;
}

if (!AL.isPackExpansion() && S.DiagnoseUnexpandedParameterPack(E))
  return;

S.AddAlignedAttr(D, AL, E, AL.isPackExpansion());
3917}

3919void Sema::AddAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E,
                        bool IsPackExpansion) {
AlignedAttr TmpAttr(Context, CI, true, E);
SourceLocation AttrLoc = CI.getLoc();

// C++11 alignas(...) and C11 _Alignas(...) have additional requirements.
if (TmpAttr.isAlignas()) {
  // C++11 [dcl.align]p1:
  //   An alignment-specifier may be applied to a variable or to a class
  //   data member, but it shall not be applied to a bit-field, a function
  //   parameter, the formal parameter of a catch clause, or a variable
  //   declared with the register storage class specifier. An
  //   alignment-specifier may also be applied to the declaration of a class
  //   or enumeration type.
  // C11 6.7.5/2:
  //   An alignment attribute shall not be specified in a declaration of
  //   a typedef, or a bit-field, or a function, or a parameter, or an
  //   object declared with the register storage-class specifier.
  int DiagKind = -1;
  if (isa<ParmVarDecl>(D)) {
    DiagKind = 0;
  } else if (const auto *VD = dyn_cast<VarDecl>(D)) {
    if (VD->getStorageClass() == SC_Register)
      DiagKind = 1;
    if (VD->isExceptionVariable())
      DiagKind = 2;
  } else if (const auto *FD = dyn_cast<FieldDecl>(D)) {
    if (FD->isBitField())
      DiagKind = 3;
  } else if (!isa<TagDecl>(D)) {
    Diag(AttrLoc, diag::err_attribute_wrong_decl_type) << &TmpAttr
      << (TmpAttr.isC11() ? ExpectedVariableOrField
                          : ExpectedVariableFieldOrTag);
    return;
  }
  if (DiagKind != -1) {
    Diag(AttrLoc, diag::err_alignas_attribute_wrong_decl_type)
      << &TmpAttr << DiagKind;
    return;
  }
}

if (E->isValueDependent()) {
  // We can't support a dependent alignment on a non-dependent type,
  // because we have no way to model that a type is "alignment-dependent"
  // but not dependent in any other way.
  if (const auto *TND = dyn_cast<TypedefNameDecl>(D)) {
    if (!TND->getUnderlyingType()->isDependentType()) {
      Diag(AttrLoc, diag::err_alignment_dependent_typedef_name)
          << E->getSourceRange();
      return;
    }
  }

  // Save dependent expressions in the AST to be instantiated.
  AlignedAttr *AA = ::new (Context) AlignedAttr(Context, CI, true, E);
  AA->setPackExpansion(IsPackExpansion);
  D->addAttr(AA);
  return;
}

// FIXME: Cache the number on the AL object?
llvm::APSInt Alignment;
ExprResult ICE = VerifyIntegerConstantExpression(
    E, &Alignment, diag::err_aligned_attribute_argument_not_int);
if (ICE.isInvalid())
  return;

uint64_t AlignVal = Alignment.getZExtValue();

// C++11 [dcl.align]p2:
//   -- if the constant expression evaluates to zero, the alignment
//      specifier shall have no effect
// C11 6.7.5p6:
//   An alignment specification of zero has no effect.
if (!(TmpAttr.isAlignas() && !Alignment)) {
  if (!llvm::isPowerOf2_64(AlignVal)) {
    Diag(AttrLoc, diag::err_alignment_not_power_of_two)
      << E->getSourceRange();
    return;
  }
}

unsigned MaximumAlignment = Sema::MaximumAlignment;
if (Context.getTargetInfo().getTriple().isOSBinFormatCOFF())
  MaximumAlignment = std::min(MaximumAlignment, 8192u);
if (AlignVal > MaximumAlignment) {
  Diag(AttrLoc, diag::err_attribute_aligned_too_great)
      << MaximumAlignment << E->getSourceRange();
  return;
}

if (Context.getTargetInfo().isTLSSupported()) {
  unsigned MaxTLSAlign =
      Context.toCharUnitsFromBits(Context.getTargetInfo().getMaxTLSAlign())
          .getQuantity();
  const auto *VD = dyn_cast<VarDecl>(D);
  if (MaxTLSAlign && AlignVal > MaxTLSAlign && VD &&
      VD->getTLSKind() != VarDecl::TLS_None) {
    Diag(VD->getLocation(), diag::err_tls_var_aligned_over_maximum)
        << (unsigned)AlignVal << VD << MaxTLSAlign;
    return;
  }
}

AlignedAttr *AA = ::new (Context) AlignedAttr(Context, CI, true, ICE.get());
AA->setPackExpansion(IsPackExpansion);
D->addAttr(AA);
4027}

4029void Sema::AddAlignedAttr(Decl *D, const AttributeCommonInfo &CI,
                        TypeSourceInfo *TS, bool IsPackExpansion) {
// FIXME: Cache the number on the AL object if non-dependent?
// FIXME: Perform checking of type validity
AlignedAttr *AA = ::new (Context) AlignedAttr(Context, CI, false, TS);
AA->setPackExpansion(IsPackExpansion);
D->addAttr(AA);
4036}

4038void Sema::CheckAlignasUnderalignment(Decl *D) {
assert(D->hasAttrs() && "no attributes on decl")((D->hasAttrs() && "no attributes on decl") ? static_cast
<void> (0) : __assert_fail ("D->hasAttrs() && \"no attributes on decl\""
, "/build/llvm-toolchain-snapshot-13~++20210308111132+66e3a4abe99c/clang/lib/Sema/SemaDeclAttr.cpp"
, 4039, __PRETTY_FUNCTION__));

QualType UnderlyingTy, DiagTy;
if (const auto *VD = dyn_cast<ValueDecl>(D)) {
  UnderlyingTy = DiagTy = VD->getType();
} else {
  UnderlyingTy = DiagTy = Context.getTagDeclType(cast<TagDecl>(D));
  if (const auto *ED = dyn_cast<EnumDecl>(D))
    UnderlyingTy = ED->getIntegerType();
}
if (DiagTy->isDependentType() || DiagTy->isIncompleteType())
  return;

// C++11 [dcl.align]p5, C11 6.7.5/4:
//   The combined effect of all alignment attributes in a declaration shall
//   not specify an alignment that is less strict than the alignment that
//   would otherwise be required for the entity being declared.
AlignedAttr *AlignasAttr = nullptr;
AlignedAttr *LastAlignedAttr = nullptr;
unsigned Align = 0;
for (auto *I : D->specific_attrs<AlignedAttr>()) {
  if (I->isAlignmentDependent())
    return;
  if (I->isAlignas())
    AlignasAttr = I;
  Align = std::max(Align, I->getAlignment(Context));
  LastAlignedAttr = I;
}

if (Align && DiagTy->isSizelessType()) {
  Diag(LastAlignedAttr->getLocation(), diag::err_attribute_sizeless_type)
      << LastAlignedAttr << DiagTy;
} else if (AlignasAttr && Align) {
  CharUnits RequestedAlign = Context.toCharUnitsFromBits(Align);
  CharUnits NaturalAlign = Context.getTypeAlignInChars(UnderlyingTy);
  if (NaturalAlign > RequestedAlign)
    Diag(AlignasAttr->getLocation(), diag::err_alignas_underaligned)
      << DiagTy << (unsigned)NaturalAlign.getQuantity();
}
4078}

4080bool Sema::checkMSInheritanceAttrOnDefinition(
  CXXRecordDecl *RD, SourceRange Range, bool BestCase,
  MSInheritanceModel ExplicitModel) {
assert(RD->hasDefinition() && "RD has no definition!")((RD->hasDefinition() && "RD has no definition!") ?
 static_cast<void> (0) : __assert_fail ("RD->hasDefinition() && \"RD has no definition!\""
, "/build/llvm-toolchain-snapshot-13~++20210308111132+66e3a4abe99c/clang/lib/Sema/SemaDeclAttr.cpp"
, 4083, __PRETTY_FUNCTION__));

// We may not have seen base specifiers or any virtual methods yet.  We will
// have to wait until the record is defined to catch any mismatches.
if (!RD->getDefinition()->isCompleteDefinition())
  return false;

// The unspecified model never matches what a definition could need.
if (ExplicitModel == MSInheritanceModel::Unspecified)
  return false;

if (BestCase) {
  if (RD->calculateInheritanceModel() == ExplicitModel)
    return false;
} else {
  if (RD->calculateInheritanceModel() <= ExplicitModel)
    return false;
}

Diag(Range.getBegin(), diag::err_mismatched_ms_inheritance)
    << 0 /*definition*/;
Diag(RD->getDefinition()->getLocation(), diag::note_defined_here) << RD;
return true;
4106}

4108/// parseModeAttrArg - Parses attribute mode string and returns parsed type
4109/// attribute.
4110static void parseModeAttrArg(Sema &S, StringRef Str, unsigned &DestWidth,
                           bool &IntegerMode, bool &ComplexMode,
                           bool &ExplicitIEEE) {
IntegerMode = true;
ComplexMode = false;
switch (Str.size()) {
case 2:
  switch (Str[0]) {
  case 'Q':
    DestWidth = 8;
    break;
  case 'H':
    DestWidth = 16;
    break;
  case 'S':
    DestWidth = 32;
    break;
  case 'D':
    DestWidth = 64;
    break;
  case 'X':
    DestWidth = 96;
    break;
  case 'K': // KFmode - IEEE quad precision (__float128)
    ExplicitIEEE = true;
    DestWidth = Str[1] == 'I' ? 0 : 128;
    break;
  case 'T':
    ExplicitIEEE = false;
    DestWidth = 128;
    break;
  }
  if (Str[1] == 'F') {
    IntegerMode = false;
  } else if (Str[1] == 'C') {
    IntegerMode = false;
    ComplexMode = true;
  } else if (Str[1] != 'I') {
    DestWidth = 0;
  }
  break;
case 4:
  // FIXME: glibc uses 'word' to define register_t; this is narrower than a
  // pointer on PIC16 and other embedded platforms.
  if (Str == "word")
    DestWidth = S.Context.getTargetInfo().getRegisterWidth();
  else if (Str == "byte")
    DestWidth = S.Context.getTargetInfo().getCharWidth();
  break;
case 7:
  if (Str == "pointer")
    DestWidth = S.Context.getTargetInfo().getPointerWidth(0);
  break;
case 11:
  if (Str == "unwind_word")
    DestWidth = S.Context.getTargetInfo().getUnwindWordWidth();
  break;
}
4168}

4170/// handleModeAttr - This attribute modifies the width of a decl with primitive
4171/// type.
4172///
4173/// Despite what would be logical, the mode attribute is a decl attribute, not a
4174/// type attribute: 'int ** __attribute((mode(HI))) *G;' tries to make 'G' be
4175/// HImode, not an intermediate pointer.
4176static void handleModeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
// This attribute isn't documented, but glibc uses it.  It changes
// the width of an int or unsigned int to the specified size.
if (!AL.isArgIdent(0)) {
  S.Diag(AL.getLoc(), diag::err_attribute_argument_type)
      << AL << AANT_ArgumentIdentifier;
  return;
}

IdentifierInfo *Name = AL.getArgAsIdent(0)->Ident;

S.AddModeAttr(D, AL, Name);
4188}

4190void Sema::AddModeAttr(Decl *D, const AttributeCommonInfo &CI,
                     IdentifierInfo *Name, bool InInstantiation) {
StringRef Str = Name->getName();
normalizeName(Str);
SourceLocation AttrLoc = CI.getLoc();

unsigned DestWidth = 0;
bool IntegerMode = true;
bool ComplexMode = false;
bool ExplicitIEEE = false;
llvm::APInt VectorSize(64, 0);
if (Str.size() >= 4 && Str[0] == 'V') {
  // Minimal length of vector mode is 4: 'V' + NUMBER(>=1) + TYPE(>=2).
  size_t StrSize = Str.size();
  size_t VectorStringLength = 0;
  while ((VectorStringLength + 1) < StrSize &&
         isdigit(Str[VectorStringLength + 1]))
    ++VectorStringLength;
  if (VectorStringLength &&
      !Str.substr(1, VectorStringLength).getAsInteger(10, VectorSize) &&
      VectorSize.isPowerOf2()) {
    parseModeAttrArg(*this, Str.substr(VectorStringLength + 1), DestWidth,
                     IntegerMode, ComplexMode, ExplicitIEEE);
    // Avoid duplicate warning from template instantiation.
    if (!InInstantiation)
      Diag(AttrLoc, diag::warn_vector_mode_deprecated);
  } else {
    VectorSize = 0;
  }
}

if (!VectorSize)
  parseModeAttrArg(*this, Str, DestWidth, IntegerMode, ComplexMode,
                   ExplicitIEEE);

// FIXME: Sync this with InitializePredefinedMacros; we need to match int8_t
// and friends, at least with glibc.
// FIXME: Make sure floating-point mappings are accurate
// FIXME: Support XF and TF types
if (!DestWidth) {
  Diag(AttrLoc, diag::err_machine_mode) << 0 /*Unknown*/ << Name;
  return;
}

QualType OldTy;
if (const auto *TD = dyn_cast<TypedefNameDecl>(D))
  OldTy = TD->getUnderlyingType();
else if (const auto *ED = dyn_cast<EnumDecl>(D)) {
  // Something like 'typedef enum { X } __attribute__((mode(XX))) T;'.
  // Try to get type from enum declaration, default to int.
  OldTy = ED->getIntegerType();
  if (OldTy.isNull())
    OldTy = Context.IntTy;
} else
  OldTy = cast<ValueDecl>(D)->getType();

if (OldTy->isDependentType()) {
  D->addAttr(::new (Context) ModeAttr(Context, CI, Name));
  return;
}

// Base type can also be a vector type (see PR17453).
// Distinguish between base type and base element type.
QualType OldElemTy = OldTy;
if (const auto *VT = OldTy->getAs<VectorType>())
  OldElemTy = VT->getElementType();

// GCC allows 'mode' attribute on enumeration types (even incomplete), except
// for vector modes. So, 'enum X __attribute__((mode(QI)));' forms a complete
// type, 'enum { A } __attribute__((mode(V4SI)))' is rejected.
if ((isa<EnumDecl>(D) || OldElemTy->getAs<EnumType>()) &&
    VectorSize.getBoolValue()) {
  Diag(AttrLoc, diag::err_enum_mode_vector_type) << Name << CI.getRange();
  return;
}
bool IntegralOrAnyEnumType = (OldElemTy->isIntegralOrEnumerationType() &&
                              !OldElemTy->isExtIntType()) ||
                             OldElemTy->getAs<EnumType>();

if (!OldElemTy->getAs<BuiltinType>() && !OldElemTy->isComplexType() &&
    !IntegralOrAnyEnumType)
  Diag(AttrLoc, diag::err_mode_not_primitive);
else if (IntegerMode) {
  if (!IntegralOrAnyEnumType)
    Diag(AttrLoc, diag::err_mode_wrong_type);
} else if (ComplexMode) {
  if (!OldElemTy->isComplexType())
    Diag(AttrLoc, diag::err_mode_wrong_type);
} else {
  if (!OldElemTy->isFloatingType())
    Diag(AttrLoc, diag::err_mode_wrong_type);
}

QualType NewElemTy;

if (IntegerMode)
  NewElemTy = Context.getIntTypeForBitwidth(DestWidth,
                                            OldElemTy->isSignedIntegerType());
else
  NewElemTy = Context.getRealTypeForBitwidth(DestWidth, ExplicitIEEE);

if (NewElemTy.isNull()) {
  Diag(AttrLoc, diag::err_machine_mode) << 1 /*Unsupported*/ << Name;
  return;
}

if (ComplexMode) {
  NewElemTy = Context.getComplexType(NewElemTy);
}

QualType NewTy = NewElemTy;
if (VectorSize.getBoolValue()) {
  NewTy = Context.getVectorType(NewTy, VectorSize.getZExtValue(),
                                VectorType::GenericVector);
} else if (const auto *OldVT = OldTy->getAs<VectorType>()) {
  // Complex machine mode does not support base vector types.
  if (ComplexMode) {
    Diag(AttrLoc, diag::err_complex_mode_vector_type);
    return;
  }
  unsigned NumElements = Context.getTypeSize(OldElemTy) *
                         OldVT->getNumElements() /
                         Context.getTypeSize(NewElemTy);
  NewTy =
      Context.getVectorType(NewElemTy, NumElements, OldVT->getVectorKind());
}

if (NewTy.isNull()) {
  Diag(AttrLoc, diag::err_mode_wrong_type);
  return;
}

// Install the new type.
if (auto *TD = dyn_cast<TypedefNameDecl>(D))
  TD->setModedTypeSourceInfo(TD->getTypeSourceInfo(), NewTy);
else if (auto *ED = dyn_cast<EnumDecl>(D))
  ED->setIntegerType(NewTy);
else
  cast<ValueDecl>(D)->setType(NewTy);

D->addAttr(::new (Context) ModeAttr(Context, CI, Name));
4331}

4333static void handleNoDebugAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
D->addAttr(::new (S.Context) NoDebugAttr(S.Context, AL));
4335}

4337AlwaysInlineAttr *Sema::mergeAlwaysInlineAttr(Decl *D,
                                            const AttributeCommonInfo &CI,
                                            const IdentifierInfo *Ident) {
if (OptimizeNoneAttr *Optnone = D->getAttr<OptimizeNoneAttr>()) {
  Diag(CI.getLoc(), diag::warn_attribute_ignored) << Ident;
  Diag(Optnone->getLocation(), diag::note_conflicting_attribute);
  return nullptr;
}

if (D->hasAttr<AlwaysInlineAttr>())
  return nullptr;

return ::new (Context) AlwaysInlineAttr(Context, CI);
4350}

4352CommonAttr *Sema::mergeCommonAttr(Decl *D, const ParsedAttr &AL) {
if (checkAttrMutualExclusion<InternalLinkageAttr>(*this, D, AL))
  return nullptr;

return ::new (Context) CommonAttr(Context, AL);
4357}

4359CommonAttr *Sema::mergeCommonAttr(Decl *D, const CommonAttr &AL) {
if (checkAttrMutualExclusion<InternalLinkageAttr>(*this, D, AL))
  return nullptr;

return ::new (Context) CommonAttr(Context, AL);
4364}

4366InternalLinkageAttr *Sema::mergeInternalLinkageAttr(Decl *D,
                                                  const ParsedAttr &AL) {
if (const auto *VD = dyn_cast<VarDecl>(D)) {
  // Attribute applies to Var but not any subclass of it (like ParmVar,
  // ImplicitParm or VarTemplateSpecialization).
  if (VD->getKind() != Decl::Var) {
    Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type)
        << AL << (getLangOpts().CPlusPlus ? ExpectedFunctionVariableOrClass
                                          : ExpectedVariableOrFunction);
    return nullptr;
  }
  // Attribute does not apply to non-static local variables.
  if (VD->hasLocalStorage()) {
    Diag(VD->getLocation(), diag::warn_internal_linkage_local_storage);
    return nullptr;
  }
}

if (checkAttrMutualExclusion<CommonAttr>(*this, D, AL))
  return nullptr;

return ::new (Context) InternalLinkageAttr(Context, AL);
4388}
4389InternalLinkageAttr *
4390Sema::mergeInternalLinkageAttr(Decl *D, const InternalLinkageAttr &AL) {
if (const auto *VD = dyn_cast<VarDecl>(D)) {
  // Attribute applies to Var but not any subclass of it (like ParmVar,
  // ImplicitParm or VarTemplateSpecialization).
  if (VD->getKind() != Decl::Var) {
    Diag(AL.getLocation(), diag::warn_attribute_wrong_decl_type)
        << &AL << (getLangOpts().CPlusPlus ? ExpectedFunctionVariableOrClass
                                           : ExpectedVariableOrFunction);
    return nullptr;
  }
  // Attribute does not apply to non-static local variables.
  if (VD->hasLocalStorage()) {
    Diag(VD->getLocation(), diag::warn_internal_linkage_local_storage);
    return nullptr;
  }
}

if (checkAttrMutualExclusion<CommonAttr>(*this, D, AL))
  return nullptr;

return ::new (Context) InternalLinkageAttr(Context, AL);
4411}

4413MinSizeAttr *Sema::mergeMinSizeAttr(Decl *D, const AttributeCommonInfo &CI) {
if (OptimizeNoneAttr *Optnone = D->getAttr<OptimizeNoneAttr>()) {
  Diag(CI.getLoc(), diag::warn_attribute_ignored) << "'minsize'";
  Diag(Optnone->getLocation(), diag::note_conflicting_attribute);
  return nullptr;
}

if (D->hasAttr<MinSizeAttr>())
  return nullptr;

return ::new (Context) MinSizeAttr(Context, CI);
4424}

4426NoSpeculativeLoadHardeningAttr *Sema::mergeNoSpeculativeLoadHardeningAttr(
  Decl *D, const NoSpeculativeLoadHardeningAttr &AL) {
if (checkAttrMutualExclusion<SpeculativeLoadHardeningAttr>(*this, D, AL))
  return nullptr;

return ::new (Context) NoSpeculativeLoadHardeningAttr(Context, AL);
4432}

4434SwiftNameAttr *Sema::mergeSwiftNameAttr(Decl *D, const SwiftNameAttr &SNA,
                                      StringRef Name) {
if (const auto *PrevSNA = D->getAttr<SwiftNameAttr>()) {
  if (PrevSNA->getName() != Name && !PrevSNA->isImplicit()) {
    Diag(PrevSNA->getLocation(), diag::err_attributes_are_not_compatible)
        << PrevSNA << &SNA;
    Diag(SNA.getLoc(), diag::note_conflicting_attribute);
  }

  D->dropAttr<SwiftNameAttr>();
}
return ::new (Context) SwiftNameAttr(Context, SNA, Name);
4446}

4448OptimizeNoneAttr *Sema::mergeOptimizeNoneAttr(Decl *D,
                                            const AttributeCommonInfo &CI) {
if (AlwaysInlineAttr *Inline = D->getAttr<AlwaysInlineAttr>()) {
  Diag(Inline->getLocation(), diag::warn_attribute_ignored) << Inline;
  Diag(CI.getLoc(), diag::note_conflicting_attribute);
  D->dropAttr<AlwaysInlineAttr>();
}
if (MinSizeAttr *MinSize = D->getAttr<MinSizeAttr>()) {
  Diag(MinSize->getLocation(), diag::warn_attribute_ignored) << MinSize;
  Diag(CI.getLoc(), diag::note_conflicting_attribute);
  D->dropAttr<MinSizeAttr>();
}

if (D->hasAttr<OptimizeNoneAttr>())
  return nullptr;

return ::new (Context) OptimizeNoneAttr(Context, CI);
4465}

4467SpeculativeLoadHardeningAttr *Sema::mergeSpeculativeLoadHardeningAttr(
  Decl *D, const SpeculativeLoadHardeningAttr &AL) {
if (checkAttrMutualExclusion<NoSpeculativeLoadHardeningAttr>(*this, D, AL))
  return nullptr;

return ::new (Context) SpeculativeLoadHardeningAttr(Context, AL);
4473}

4475static void handleAlwaysInlineAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (checkAttrMutualExclusion<NotTailCalledAttr>(S, D, AL))
  return;

if (AlwaysInlineAttr *Inline =
        S.mergeAlwaysInlineAttr(D, AL, AL.getAttrName()))
  D->addAttr(Inline);
4482}

4484static void handleMinSizeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (MinSizeAttr *MinSize = S.mergeMinSizeAttr(D, AL))
  D->addAttr(MinSize);
4487}

4489static void handleOptimizeNoneAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (OptimizeNoneAttr *Optnone = S.mergeOptimizeNoneAttr(D, AL))
  D->addAttr(Optnone);
4492}

4494static void handleConstantAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (checkAttrMutualExclusion<CUDASharedAttr>(S, D, AL) ||
    checkAttrMutualExclusion<HIPManagedAttr>(S, D, AL))
  return;
const auto *VD = cast<VarDecl>(D);
if (VD->hasLocalStorage()) {
  S.Diag(AL.getLoc(), diag::err_cuda_nonstatic_constdev);
  return;
}
D->addAttr(::new (S.Context) CUDAConstantAttr(S.Context, AL));
4504}

4506static void handleSharedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (checkAttrMutualExclusion<CUDAConstantAttr>(S, D, AL) ||
    checkAttrMutualExclusion<HIPManagedAttr>(S, D, AL))
  return;
const auto *VD = cast<VarDecl>(D);
// extern __shared__ is only allowed on arrays with no length (e.g.
// "int x[]").
if (!S.getLangOpts().GPURelocatableDeviceCode && VD->hasExternalStorage() &&
    !isa<IncompleteArrayType>(VD->getType())) {
  S.Diag(AL.getLoc(), diag::err_cuda_extern_shared) << VD;
  return;
}
if (S.getLangOpts().CUDA && VD->hasLocalStorage() &&
    S.CUDADiagIfHostCode(AL.getLoc(), diag::err_cuda_host_shared)
        << S.CurrentCUDATarget())
  return;
D->addAttr(::new (S.Context) CUDASharedAttr(S.Context, AL));
4523}

4525static void handleGlobalAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (checkAttrMutualExclusion<CUDADeviceAttr>(S, D, AL) ||
    checkAttrMutualExclusion<CUDAHostAttr>(S, D, AL)) {
  return;
}
const auto *FD = cast<FunctionDecl>(D);
if (!FD->getReturnType()->isVoidType() &&
    !FD->getReturnType()->getAs<AutoType>() &&
    !FD->getReturnType()->isInstantiationDependentType()) {
  SourceRange RTRange = FD->getReturnTypeSourceRange();
  S.Diag(FD->getTypeSpecStartLoc(), diag::err_kern_type_not_void_return)
      << FD->getType()
      << (RTRange.isValid() ? FixItHint::CreateReplacement(RTRange, "void")
                            : FixItHint());
  return;
}
if (const auto *Method = dyn_cast<CXXMethodDecl>(FD)) {
  if (Method->isInstance()) {
    S.Diag(Method->getBeginLoc(), diag::err_kern_is_nonstatic_method)
        << Method;
    return;
  }
  S.Diag(Method->getBeginLoc(), diag::warn_kern_is_method) << Method;
}
// Only warn for "inline" when compiling for host, to cut down on noise.
if (FD->isInlineSpecified() && !S.getLangOpts().CUDAIsDevice)
  S.Diag(FD->getBeginLoc(), diag::warn_kern_is_inline) << FD;

D->addAttr(::new (S.Context) CUDAGlobalAttr(S.Context, AL));
// In host compilation the kernel is emitted as a stub function, which is
// a helper function for launching the kernel. The instructions in the helper
// function has nothing to do with the source code of the kernel. Do not emit
// debug info for the stub function to avoid confusing the debugger.
if (S.LangOpts.HIP && !S.LangOpts.CUDAIsDevice)
  D->addAttr(NoDebugAttr::CreateImplicit(S.Context));
4560}

4562static void handleDeviceAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (checkAttrMutualExclusion<CUDAGlobalAttr>(S, D, AL)) {
  return;
}

if (const auto *VD = dyn_cast<VarDecl>(D)) {
  if (VD->hasLocalStorage()) {
    S.Diag(AL.getLoc(), diag::err_cuda_nonstatic_constdev);
    return;
  }
}

if (auto *A = D->getAttr<CUDADeviceAttr>()) {
  if (!A->isImplicit())
    return;
  D->dropAttr<CUDADeviceAttr>();
}
D->addAttr(::new (S.Context) CUDADeviceAttr(S.Context, AL));
4580}

4582static void handleManagedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (checkAttrMutualExclusion<CUDAConstantAttr>(S, D, AL) ||
    checkAttrMutualExclusion<CUDASharedAttr>(S, D, AL)) {
  return;
}

if (const auto *VD = dyn_cast<VarDecl>(D)) {
  if (VD->hasLocalStorage()) {
    S.Diag(AL.getLoc(), diag::err_cuda_nonstatic_constdev);
    return;
  }
}
if (!D->hasAttr<HIPManagedAttr>())
  D->addAttr(::new (S.Context) HIPManagedAttr(S.Context, AL));
if (!D->hasAttr<CUDADeviceAttr>())
  D->addAttr(CUDADeviceAttr::CreateImplicit(S.Context));
4598}

4600static void handleGNUInlineAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
const auto *Fn = cast<FunctionDecl>(D);
if (!Fn->isInlineSpecified()) {
  S.Diag(AL.getLoc(), diag::warn_gnu_inline_attribute_requires_inline);
  return;
}

if (S.LangOpts.CPlusPlus && Fn->getStorageClass() != SC_Extern)
  S.Diag(AL.getLoc(), diag::warn_gnu_inline_cplusplus_without_extern);

D->addAttr(::new (S.Context) GNUInlineAttr(S.Context, AL));
4611}

4613static void handleCallConvAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (hasDeclarator(D)) return;

// Diagnostic is emitted elsewhere: here we store the (valid) AL
// in the Decl node for syntactic reasoning, e.g., pretty-printing.
CallingConv CC;
if (S.CheckCallingConvAttr(AL, CC, /*FD*/nullptr))
  return;

if (!isa<ObjCMethodDecl>(D)) {
  S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type)
      << AL << ExpectedFunctionOrMethod;
  return;
}

switch (AL.getKind()) {
case ParsedAttr::AT_FastCall:
  D->addAttr(::new (S.Context) FastCallAttr(S.Context, AL));
  return;
case ParsedAttr::AT_StdCall:
  D->addAttr(::new (S.Context) StdCallAttr(S.Context, AL));
  return;
case ParsedAttr::AT_ThisCall:
  D->addAttr(::new (S.Context) ThisCallAttr(S.Context, AL));
  return;
case ParsedAttr::AT_CDecl:
  D->addAttr(::new (S.Context) CDeclAttr(S.Context, AL));
  return;
case ParsedAttr::AT_Pascal:
  D->addAttr(::new (S.Context) PascalAttr(S.Context, AL));
  return;
case ParsedAttr::AT_SwiftCall:
  D->addAttr(::new (S.Context) SwiftCallAttr(S.Context, AL));
  return;
case ParsedAttr::AT_VectorCall:
  D->addAttr(::new (S.Context) VectorCallAttr(S.Context, AL));
  return;
case ParsedAttr::AT_MSABI:
  D->addAttr(::new (S.Context) MSABIAttr(S.Context, AL));
  return;
case ParsedAttr::AT_SysVABI:
  D->addAttr(::new (S.Context) SysVABIAttr(S.Context, AL));
  return;
case ParsedAttr::AT_RegCall:
  D->addAttr(::new (S.Context) RegCallAttr(S.Context, AL));
  return;
case ParsedAttr::AT_Pcs: {
  PcsAttr::PCSType PCS;
  switch (CC) {
  case CC_AAPCS:
    PCS = PcsAttr::AAPCS;
    break;
  case CC_AAPCS_VFP:
    PCS = PcsAttr::AAPCS_VFP;
    break;
  default:
    llvm_unreachable("unexpected calling convention in pcs attribute")::llvm::llvm_unreachable_internal("unexpected calling convention in pcs attribute"
, "/build/llvm-toolchain-snapshot-13~++20210308111132+66e3a4abe99c/clang/lib/Sema/SemaDeclAttr.cpp"
, 4669);
  }

  D->addAttr(::new (S.Context) PcsAttr(S.Context, AL, PCS));
  return;
}
case ParsedAttr::AT_AArch64VectorPcs:
  D->addAttr(::new (S.Context) AArch64VectorPcsAttr(S.Context, AL));
  return;
case ParsedAttr::AT_IntelOclBicc:
  D->addAttr(::new (S.Context) IntelOclBiccAttr(S.Context, AL));
  return;
case ParsedAttr::AT_PreserveMost:
  D->addAttr(::new (S.Context) PreserveMostAttr(S.Context, AL));
  return;
case ParsedAttr::AT_PreserveAll:
  D->addAttr(::new (S.Context) PreserveAllAttr(S.Context, AL));
  return;
default:
  llvm_unreachable("unexpected attribute kind")::llvm::llvm_unreachable_internal("unexpected attribute kind"
, "/build/llvm-toolchain-snapshot-13~++20210308111132+66e3a4abe99c/clang/lib/Sema/SemaDeclAttr.cpp"
, 4688);
}
4690}

4692static void handleSuppressAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (!checkAttributeAtLeastNumArgs(S, AL, 1))
  return;

std::vector<StringRef> DiagnosticIdentifiers;
for (unsigned I = 0, E = AL.getNumArgs(); I != E; ++I) {
  StringRef RuleName;

  if (!S.checkStringLiteralArgumentAttr(AL, I, RuleName, nullptr))
    return;

  // FIXME: Warn if the rule name is unknown. This is tricky because only
  // clang-tidy knows about available rules.
  DiagnosticIdentifiers.push_back(RuleName);
}
D->addAttr(::new (S.Context)
               SuppressAttr(S.Context, AL, DiagnosticIdentifiers.data(),
                            DiagnosticIdentifiers.size()));
4710}

4712static void handleLifetimeCategoryAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
TypeSourceInfo *DerefTypeLoc = nullptr;
QualType ParmType;
if (AL.hasParsedType()) {
  ParmType = S.GetTypeFromParser(AL.getTypeArg(), &DerefTypeLoc);

  unsigned SelectIdx = ~0U;
  if (ParmType->isReferenceType())
    SelectIdx = 0;
  else if (ParmType->isArrayType())
    SelectIdx = 1;

  if (SelectIdx != ~0U) {
    S.Diag(AL.getLoc(), diag::err_attribute_invalid_argument)
        << SelectIdx << AL;
    return;
  }
}

// To check if earlier decl attributes do not conflict the newly parsed ones
// we always add (and check) the attribute to the cannonical decl.
D = D->getCanonicalDecl();
if (AL.getKind() == ParsedAttr::AT_Owner) {
  if (checkAttrMutualExclusion<PointerAttr>(S, D, AL))
    return;
  if (const auto *OAttr = D->getAttr<OwnerAttr>()) {
    const Type *ExistingDerefType = OAttr->getDerefTypeLoc()
                                        ? OAttr->getDerefType().getTypePtr()
                                        : nullptr;
    if (ExistingDerefType != ParmType.getTypePtrOrNull()) {
      S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible)
          << AL << OAttr;
      S.Diag(OAttr->getLocation(), diag::note_conflicting_attribute);
    }
    return;
  }
  for (Decl *Redecl : D->redecls()) {
    Redecl->addAttr(::new (S.Context) OwnerAttr(S.Context, AL, DerefTypeLoc));
  }
} else {
  if (checkAttrMutualExclusion<OwnerAttr>(S, D, AL))
    return;
  if (const auto *PAttr = D->getAttr<PointerAttr>()) {
    const Type *ExistingDerefType = PAttr->getDerefTypeLoc()
                                        ? PAttr->getDerefType().getTypePtr()
                                        : nullptr;
    if (ExistingDerefType != ParmType.getTypePtrOrNull()) {
      S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible)
          << AL << PAttr;
      S.Diag(PAttr->getLocation(), diag::note_conflicting_attribute);
    }
    return;
  }
  for (Decl *Redecl : D->redecls()) {
    Redecl->addAttr(::new (S.Context)
                        PointerAttr(S.Context, AL, DerefTypeLoc));
  }
}
4770}

4772bool Sema::CheckCallingConvAttr(const ParsedAttr &Attrs, CallingConv &CC,
                              const FunctionDecl *FD) {
if (Attrs.isInvalid())
  return true;

if (Attrs.hasProcessingCache()) {
  CC = (CallingConv) Attrs.getProcessingCache();
  return false;
}

unsigned ReqArgs = Attrs.getKind() == ParsedAttr::AT_Pcs ? 1 : 0;
if (!checkAttributeNumArgs(*this, Attrs, ReqArgs)) {
  Attrs.setInvalid();
  return true;
}

// TODO: diagnose uses of these conventions on the wrong target.
switch (Attrs.getKind()) {
case ParsedAttr::AT_CDecl:
  CC = CC_C;
  break;
case ParsedAttr::AT_FastCall:
  CC = CC_X86FastCall;
  break;
case ParsedAttr::AT_StdCall:
  CC = CC_X86StdCall;
  break;
case ParsedAttr::AT_ThisCall:
  CC = CC_X86ThisCall;
  break;
case ParsedAttr::AT_Pascal:
  CC = CC_X86Pascal;
  break;
case ParsedAttr::AT_SwiftCall:
  CC = CC_Swift;
  break;
case ParsedAttr::AT_VectorCall:
  CC = CC_X86VectorCall;
  break;
case ParsedAttr::AT_AArch64VectorPcs:
  CC = CC_AArch64VectorCall;
  break;
case ParsedAttr::AT_RegCall:
  CC = CC_X86RegCall;
  break;
case ParsedAttr::AT_MSABI:
  CC = Context.getTargetInfo().getTriple().isOSWindows() ? CC_C :
                                                           CC_Win64;
  break;
case ParsedAttr::AT_SysVABI:
  CC = Context.getTargetInfo().getTriple().isOSWindows() ? CC_X86_64SysV :
                                                           CC_C;
  break;
case ParsedAttr::AT_Pcs: {
  StringRef StrRef;
  if (!checkStringLiteralArgumentAttr(Attrs, 0, StrRef)) {
    Attrs.setInvalid();
    return true;
  }
  if (StrRef == "aapcs") {
    CC = CC_AAPCS;
    break;
  } else if (StrRef == "aapcs-vfp") {
    CC = CC_AAPCS_VFP;
    break;
  }

  Attrs.setInvalid();
  Diag(Attrs.getLoc(), diag::err_invalid_pcs);
  return true;
}
case ParsedAttr::AT_IntelOclBicc:
  CC = CC_IntelOclBicc;
  break;
case ParsedAttr::AT_PreserveMost:
  CC = CC_PreserveMost;
  break;
case ParsedAttr::AT_PreserveAll:
  CC = CC_PreserveAll;
  break;
default: llvm_unreachable("unexpected attribute kind")::llvm::llvm_unreachable_internal("unexpected attribute kind"
, "/build/llvm-toolchain-snapshot-13~++20210308111132+66e3a4abe99c/clang/lib/Sema/SemaDeclAttr.cpp"
, 4852);
}

TargetInfo::CallingConvCheckResult A = TargetInfo::CCCR_OK;
const TargetInfo &TI = Context.getTargetInfo();
// CUDA functions may have host and/or device attributes which indicate
// their targeted execution environment, therefore the calling convention
// of functions in CUDA should be checked against the target deduced based
// on their host/device attributes.
if (LangOpts.CUDA) {
  auto *Aux = Context.getAuxTargetInfo();
  auto CudaTarget = IdentifyCUDATarget(FD);
  bool CheckHost = false, CheckDevice = false;
  switch (CudaTarget) {
  case CFT_HostDevice:
    CheckHost = true;
    CheckDevice = true;
    break;
  case CFT_Host:
    CheckHost = true;
    break;
  case CFT_Device:
  case CFT_Global:
    CheckDevice = true;
    break;
  case CFT_InvalidTarget:
    llvm_unreachable("unexpected cuda target")::llvm::llvm_unreachable_internal("unexpected cuda target", "/build/llvm-toolchain-snapshot-13~++20210308111132+66e3a4abe99c/clang/lib/Sema/SemaDeclAttr.cpp"
, 4878);
  }
  auto *HostTI = LangOpts.CUDAIsDevice ? Aux : &TI;
  auto *DeviceTI = LangOpts.CUDAIsDevice ? &TI : Aux;
  if (CheckHost && HostTI)
    A = HostTI->checkCallingConvention(CC);
  if (A == TargetInfo::CCCR_OK && CheckDevice && DeviceTI)
    A = DeviceTI->checkCallingConvention(CC);
} else {
  A = TI.checkCallingConvention(CC);
}

switch (A) {
case TargetInfo::CCCR_OK:
  break;

case TargetInfo::CCCR_Ignore:
  // Treat an ignored convention as if it was an explicit C calling convention
  // attribute. For example, __stdcall on Win x64 functions as __cdecl, so
  // that command line flags that change the default convention to
  // __vectorcall don't affect declarations marked __stdcall.
  CC = CC_C;
  break;

case TargetInfo::CCCR_Error:
  Diag(Attrs.getLoc(), diag::error_cconv_unsupported)
      << Attrs << (int)CallingConventionIgnoredReason::ForThisTarget;
  break;

case TargetInfo::CCCR_Warning: {
  Diag(Attrs.getLoc(), diag::warn_cconv_unsupported)
      << Attrs << (int)CallingConventionIgnoredReason::ForThisTarget;

  // This convention is not valid for the target. Use the default function or
  // method calling convention.
  bool IsCXXMethod = false, IsVariadic = false;
  if (FD) {
    IsCXXMethod = FD->isCXXInstanceMember();
    IsVariadic = FD->isVariadic();
  }
  CC = Context.getDefaultCallingConvention(IsVariadic, IsCXXMethod);
  break;
}
}

Attrs.setProcessingCache((unsigned) CC);
return false;
4925}

4927/// Pointer-like types in the default address space.
4928static bool isValidSwiftContextType(QualType Ty) {
if (!Ty->hasPointerRepresentation())
  return Ty->isDependentType();
return Ty->getPointeeType().getAddressSpace() == LangAS::Default;
4932}

4934/// Pointers and references in the default address space.
4935static bool isValidSwiftIndirectResultType(QualType Ty) {
if (const auto *PtrType = Ty->getAs<PointerType>()) {
  Ty = PtrType->getPointeeType();
} else if (const auto *RefType = Ty->getAs<ReferenceType>()) {
  Ty = RefType->getPointeeType();
} else {
  return Ty->isDependentType();
}
return Ty.getAddressSpace() == LangAS::Default;
4944}

4946/// Pointers and references to pointers in the default address space.
4947static bool isValidSwiftErrorResultType(QualType Ty) {
if (const auto *PtrType = Ty->getAs<PointerType>()) {
  Ty = PtrType->getPointeeType();
} else if (const auto *RefType = Ty->getAs<ReferenceType>()) {
  Ty = RefType->getPointeeType();
} else {
  return Ty->isDependentType();
}
if (!Ty.getQualifiers().empty())
  return false;
return isValidSwiftContextType(Ty);
4958}

4960void Sema::AddParameterABIAttr(Decl *D, const AttributeCommonInfo &CI,
                             ParameterABI abi) {

QualType type = cast<ParmVarDecl>(D)->getType();

if (auto existingAttr = D->getAttr<ParameterABIAttr>()) {
  if (existingAttr->getABI() != abi) {
    Diag(CI.getLoc(), diag::err_attributes_are_not_compatible)
        << getParameterABISpelling(abi) << existingAttr;
    Diag(existingAttr->getLocation(), diag::note_conflicting_attribute);
    return;
  }
}

switch (abi) {
case ParameterABI::Ordinary:
  llvm_unreachable("explicit attribute for ordinary parameter ABI?")::llvm::llvm_unreachable_internal("explicit attribute for ordinary parameter ABI?"
, "/build/llvm-toolchain-snapshot-13~++20210308111132+66e3a4abe99c/clang/lib/Sema/SemaDeclAttr.cpp"
, 4976);

case ParameterABI::SwiftContext:
  if (!isValidSwiftContextType(type)) {
    Diag(CI.getLoc(), diag::err_swift_abi_parameter_wrong_type)
        << getParameterABISpelling(abi) << /*pointer to pointer */ 0 << type;
  }
  D->addAttr(::new (Context) SwiftContextAttr(Context, CI));
  return;

case ParameterABI::SwiftErrorResult:
  if (!isValidSwiftErrorResultType(type)) {
    Diag(CI.getLoc(), diag::err_swift_abi_parameter_wrong_type)
        << getParameterABISpelling(abi) << /*pointer to pointer */ 1 << type;
  }
  D->addAttr(::new (Context) SwiftErrorResultAttr(Context, CI));
  return;

case ParameterABI::SwiftIndirectResult:
  if (!isValidSwiftIndirectResultType(type)) {
    Diag(CI.getLoc(), diag::err_swift_abi_parameter_wrong_type)
        << getParameterABISpelling(abi) << /*pointer*/ 0 << type;
  }
  D->addAttr(::new (Context) SwiftIndirectResultAttr(Context, CI));
  return;
}
llvm_unreachable("bad parameter ABI attribute")::llvm::llvm_unreachable_internal("bad parameter ABI attribute"
, "/build/llvm-toolchain-snapshot-13~++20210308111132+66e3a4abe99c/clang/lib/Sema/SemaDeclAttr.cpp"
, 5002);
5003}

5005/// Checks a regparm attribute, returning true if it is ill-formed and
5006/// otherwise setting numParams to the appropriate value.
5007bool Sema::CheckRegparmAttr(const ParsedAttr &AL, unsigned &numParams) {
if (AL.isInvalid())
  return true;

if (!checkAttributeNumArgs(*this, AL, 1)) {
  AL.setInvalid();
  return true;
}

uint32_t NP;
Expr *NumParamsExpr = AL.getArgAsExpr(0);
if (!checkUInt32Argument(*this, AL, NumParamsExpr, NP)) {
  AL.setInvalid();
  return true;
}

if (Context.getTargetInfo().getRegParmMax() == 0) {
  Diag(AL.getLoc(), diag::err_attribute_regparm_wrong_platform)
    << NumParamsExpr->getSourceRange();
  AL.setInvalid();
  return true;
}

numParams = NP;
if (numParams > Context.getTargetInfo().getRegParmMax()) {
  Diag(AL.getLoc(), diag::err_attribute_regparm_invalid_number)
    << Context.getTargetInfo().getRegParmMax() << NumParamsExpr->getSourceRange();
  AL.setInvalid();
  return true;
}

return false;
5039}

5041// Checks whether an argument of launch_bounds attribute is
5042// acceptable, performs implicit conversion to Rvalue, and returns
5043// non-nullptr Expr result on success. Otherwise, it returns nullptr
5044// and may output an error.
5045static Expr *makeLaunchBoundsArgExpr(Sema &S, Expr *E,
                                   const CUDALaunchBoundsAttr &AL,
                                   const unsigned Idx) {
if (S.DiagnoseUnexpandedParameterPack(E))
  return nullptr;

// Accept template arguments for now as they depend on something else.
// We'll get to check them when they eventually get instantiated.
if (E->isValueDependent())
  return E;

Optional<llvm::APSInt> I = llvm::APSInt(64);
if (!(I = E->getIntegerConstantExpr(S.Context))) {
  S.Diag(E->getExprLoc(), diag::err_attribute_argument_n_type)
      << &AL << Idx << AANT_ArgumentIntegerConstant << E->getSourceRange();
  return nullptr;
}
// Make sure we can fit it in 32 bits.
if (!I->isIntN(32)) {
  S.Diag(E->getExprLoc(), diag::err_ice_too_large)
      << I->toString(10, false) << 32 << /* Unsigned */ 1;
  return nullptr;
}
if (*I < 0)
  S.Diag(E->getExprLoc(), diag::warn_attribute_argument_n_negative)
      << &AL << Idx << E->getSourceRange();

// We may need to perform implicit conversion of the argument.
InitializedEntity Entity = InitializedEntity::InitializeParameter(
    S.Context, S.Context.getConstType(S.Context.IntTy), /*consume*/ false);
ExprResult ValArg = S.PerformCopyInitialization(Entity, SourceLocation(), E);
assert(!ValArg.isInvalid() &&((!ValArg.isInvalid() && "Unexpected PerformCopyInitialization() failure."
) ? static_cast<void> (0) : __assert_fail ("!ValArg.isInvalid() && \"Unexpected PerformCopyInitialization() failure.\""
, "/build/llvm-toolchain-snapshot-13~++20210308111132+66e3a4abe99c/clang/lib/Sema/SemaDeclAttr.cpp"
, 5077, __PRETTY_FUNCTION__))
       "Unexpected PerformCopyInitialization() failure.")((!ValArg.isInvalid() && "Unexpected PerformCopyInitialization() failure."
) ? static_cast<void> (0) : __assert_fail ("!ValArg.isInvalid() && \"Unexpected PerformCopyInitialization() failure.\""
, "/build/llvm-toolchain-snapshot-13~++20210308111132+66e3a4abe99c/clang/lib/Sema/SemaDeclAttr.cpp"
, 5077, __PRETTY_FUNCTION__));

return ValArg.getAs<Expr>();
5080}

5082void Sema::AddLaunchBoundsAttr(Decl *D, const AttributeCommonInfo &CI,
                             Expr *MaxThreads, Expr *MinBlocks) {
CUDALaunchBoundsAttr TmpAttr(Context, CI, MaxThreads, MinBlocks);
MaxThreads = makeLaunchBoundsArgExpr(*this, MaxThreads, TmpAttr, 0);
if (MaxThreads == nullptr)
  return;

if (MinBlocks) {
  MinBlocks = makeLaunchBoundsArgExpr(*this, MinBlocks, TmpAttr, 1);
  if (MinBlocks == nullptr)
    return;
}

D->addAttr(::new (Context)
               CUDALaunchBoundsAttr(Context, CI, MaxThreads, MinBlocks));
5097}

5099static void handleLaunchBoundsAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (!checkAttributeAtLeastNumArgs(S, AL, 1) ||
    !checkAttributeAtMostNumArgs(S, AL, 2))
  return;

S.AddLaunchBoundsAttr(D, AL, AL.getArgAsExpr(0),
                      AL.getNumArgs() > 1 ? AL.getArgAsExpr(1) : nullptr);
5106}

5108static void handleArgumentWithTypeTagAttr(Sema &S, Decl *D,
                                        const ParsedAttr &AL) {
if (!AL.isArgIdent(0)) {
  S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
      << AL << /* arg num = */ 1 << AANT_ArgumentIdentifier;
  return;
}

ParamIdx ArgumentIdx;
if (!checkFunctionOrMethodParameterIndex(S, D, AL, 2, AL.getArgAsExpr(1),
                                         ArgumentIdx))
  return;

ParamIdx TypeTagIdx;
if (!checkFunctionOrMethodParameterIndex(S, D, AL, 3, AL.getArgAsExpr(2),
                                         TypeTagIdx))
  return;

bool IsPointer = AL.getAttrName()->getName() == "pointer_with_type_tag";
if (IsPointer) {
  // Ensure that buffer has a pointer type.
  unsigned ArgumentIdxAST = ArgumentIdx.getASTIndex();
  if (ArgumentIdxAST >= getFunctionOrMethodNumParams(D) ||
      !getFunctionOrMethodParamType(D, ArgumentIdxAST)->isPointerType())
    S.Diag(AL.getLoc(), diag::err_attribute_pointers_only) << AL << 0;
}

D->addAttr(::new (S.Context) ArgumentWithTypeTagAttr(
    S.Context, AL, AL.getArgAsIdent(0)->Ident, ArgumentIdx, TypeTagIdx,
    IsPointer));
5138}

5140static void handleTypeTagForDatatypeAttr(Sema &S, Decl *D,
                                       const ParsedAttr &AL) {
if (!AL.isArgIdent(0)) {
  S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
      << AL << 1 << AANT_ArgumentIdentifier;
  return;
}

if (!checkAttributeNumArgs(S, AL, 1))
  return;

if (!isa<VarDecl>(D)) {
  S.Diag(AL.getLoc(), diag::err_attribute_wrong_decl_type)
      << AL << ExpectedVariable;
  return;
}

IdentifierInfo *PointerKind = AL.getArgAsIdent(0)->Ident;
TypeSourceInfo *MatchingCTypeLoc = nullptr;
S.GetTypeFromParser(AL.getMatchingCType(), &MatchingCTypeLoc);
assert(MatchingCTypeLoc && "no type source info for attribute argument")((MatchingCTypeLoc && "no type source info for attribute argument"
) ? static_cast<void> (0) : __assert_fail ("MatchingCTypeLoc && \"no type source info for attribute argument\""
, "/build/llvm-toolchain-snapshot-13~++20210308111132+66e3a4abe99c/clang/lib/Sema/SemaDeclAttr.cpp"
, 5160, __PRETTY_FUNCTION__));

D->addAttr(::new (S.Context) TypeTagForDatatypeAttr(
    S.Context, AL, PointerKind, MatchingCTypeLoc, AL.getLayoutCompatible(),
    AL.getMustBeNull()));
5165}

5167static void handleXRayLogArgsAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
ParamIdx ArgCount;

if (!checkFunctionOrMethodParameterIndex(S, D, AL, 1, AL.getArgAsExpr(0),
                                         ArgCount,
                                         true /* CanIndexImplicitThis */))
  return;

// ArgCount isn't a parameter index [0;n), it's a count [1;n]
D->addAttr(::new (S.Context)
               XRayLogArgsAttr(S.Context, AL, ArgCount.getSourceIndex()));
5178}

5180static void handlePatchableFunctionEntryAttr(Sema &S, Decl *D,
                                           const ParsedAttr &AL) {
uint32_t Count = 0, Offset = 0;
if (!checkUInt32Argument(S, AL, AL.getArgAsExpr(0), Count, 0, true))
  return;
if (AL.getNumArgs() == 2) {
  Expr *Arg = AL.getArgAsExpr(1);
  if (!checkUInt32Argument(S, AL, Arg, Offset, 1, true))
    return;
  if (Count < Offset) {
    S.Diag(getAttrLoc(AL), diag::err_attribute_argument_out_of_range)
        << &AL << 0 << Count << Arg->getBeginLoc();
    return;
  }
}
D->addAttr(::new (S.Context)
               PatchableFunctionEntryAttr(S.Context, AL, Count, Offset));
5197}

5199namespace {
5200struct IntrinToName {
uint32_t Id;
int32_t FullName;
int32_t ShortName;
5204};
5205} // unnamed namespace

5207static bool ArmBuiltinAliasValid(unsigned BuiltinID, StringRef AliasName,
                               ArrayRef<IntrinToName> Map,
                               const char *IntrinNames) {
if (AliasName.startswith("__arm_"))
  AliasName = AliasName.substr(6);
const IntrinToName *It = std::lower_bound(
    Map.begin(), Map.end(), BuiltinID,
    [](const IntrinToName &L, unsigned Id) { return L.Id < Id; });
if (It == Map.end() || It->Id != BuiltinID)
  return false;
StringRef FullName(&IntrinNames[It->FullName]);
if (AliasName == FullName)
  return true;
if (It->ShortName == -1)
  return false;
StringRef ShortName(&IntrinNames[It->ShortName]);
return AliasName == ShortName;
5224}

5226static bool ArmMveAliasValid(unsigned BuiltinID, StringRef AliasName) {
5227#include "clang/Basic/arm_mve_builtin_aliases.inc"
// The included file defines:
// - ArrayRef<IntrinToName> Map
// - const char IntrinNames[]
return ArmBuiltinAliasValid(BuiltinID, AliasName, Map, IntrinNames);
5232}

5234static bool ArmCdeAliasValid(unsigned BuiltinID, StringRef AliasName) {
5235#include "clang/Basic/arm_cde_builtin_aliases.inc"
return ArmBuiltinAliasValid(BuiltinID, AliasName, Map, IntrinNames);
5237}

5239static bool ArmSveAliasValid(unsigned BuiltinID, StringRef AliasName) {
switch (BuiltinID) {
default:
  return false;
5243#define GET_SVE_BUILTINS
5244#define BUILTIN(name, types, attr)case SVE::BIname: case SVE::BI##name:
5245#include "clang/Basic/arm_sve_builtins.inc"
  return true;
}
5248}

5250static void handleArmBuiltinAliasAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (!AL.isArgIdent(0)) {
  S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
      << AL << 1 << AANT_ArgumentIdentifier;
  return;
}

IdentifierInfo *Ident = AL.getArgAsIdent(0)->Ident;
unsigned BuiltinID = Ident->getBuiltinID();
StringRef AliasName = cast<FunctionDecl>(D)->getIdentifier()->getName();

bool IsAArch64 = S.Context.getTargetInfo().getTriple().isAArch64();
if ((IsAArch64 && !ArmSveAliasValid(BuiltinID, AliasName)) ||
    (!IsAArch64 && !ArmMveAliasValid(BuiltinID, AliasName) &&
     !ArmCdeAliasValid(BuiltinID, AliasName))) {
  S.Diag(AL.getLoc(), diag::err_attribute_arm_builtin_alias);
  return;
}

D->addAttr(::new (S.Context) ArmBuiltinAliasAttr(S.Context, AL, Ident));
5270}

5272//===----------------------------------------------------------------------===//
5273// Checker-specific attribute handlers.
5274//===----------------------------------------------------------------------===//
5275static bool isValidSubjectOfNSReturnsRetainedAttribute(QualType QT) {
return QT->isDependentType() || QT->isObjCRetainableType();
5277}

5279static bool isValidSubjectOfNSAttribute(QualType QT) {
return QT->isDependentType() || QT->isObjCObjectPointerType() ||
       QT->isObjCNSObjectType();
5282}

5284static bool isValidSubjectOfCFAttribute(QualType QT) {
return QT->isDependentType() || QT->isPointerType() ||
       isValidSubjectOfNSAttribute(QT);
5287}

5289static bool isValidSubjectOfOSAttribute(QualType QT) {
if (QT->isDependentType())
  return true;
QualType PT = QT->getPointeeType();
return !PT.isNull() && PT->getAsCXXRecordDecl() != nullptr;
5294}

5296void Sema::AddXConsumedAttr(Decl *D, const AttributeCommonInfo &CI,
                          RetainOwnershipKind K,
                          bool IsTemplateInstantiation) {
ValueDecl *VD = cast<ValueDecl>(D);
switch (K) {
case RetainOwnershipKind::OS:
  handleSimpleAttributeOrDiagnose<OSConsumedAttr>(
      *this, VD, CI, isValidSubjectOfOSAttribute(VD->getType()),
      diag::warn_ns_attribute_wrong_parameter_type,
      /*ExtraArgs=*/CI.getRange(), "os_consumed", /*pointers*/ 1);
  return;
case RetainOwnershipKind::NS:
  handleSimpleAttributeOrDiagnose<NSConsumedAttr>(
      *this, VD, CI, isValidSubjectOfNSAttribute(VD->getType()),

      // These attributes are normally just advisory, but in ARC, ns_consumed
      // is significant.  Allow non-dependent code to contain inappropriate
      // attributes even in ARC, but require template instantiations to be
      // set up correctly.
      ((IsTemplateInstantiation && getLangOpts().ObjCAutoRefCount)
           ? diag::err_ns_attribute_wrong_parameter_type
           : diag::warn_ns_attribute_wrong_parameter_type),
      /*ExtraArgs=*/CI.getRange(), "ns_consumed", /*objc pointers*/ 0);
  return;
case RetainOwnershipKind::CF:
  handleSimpleAttributeOrDiagnose<CFConsumedAttr>(
      *this, VD, CI, isValidSubjectOfCFAttribute(VD->getType()),
      diag::warn_ns_attribute_wrong_parameter_type,
      /*ExtraArgs=*/CI.getRange(), "cf_consumed", /*pointers*/ 1);
  return;
}
5327}

5329static Sema::RetainOwnershipKind
5330parsedAttrToRetainOwnershipKind(const ParsedAttr &AL) {
switch (AL.getKind()) {
case ParsedAttr::AT_CFConsumed:
case ParsedAttr::AT_CFReturnsRetained:
case ParsedAttr::AT_CFReturnsNotRetained:
  return Sema::RetainOwnershipKind::CF;
case ParsedAttr::AT_OSConsumesThis:
case ParsedAttr::AT_OSConsumed:
case ParsedAttr::AT_OSReturnsRetained:
case ParsedAttr::AT_OSReturnsNotRetained:
case ParsedAttr::AT_OSReturnsRetainedOnZero:
case ParsedAttr::AT_OSReturnsRetainedOnNonZero:
  return Sema::RetainOwnershipKind::OS;
case ParsedAttr::AT_NSConsumesSelf:
case ParsedAttr::AT_NSConsumed:
case ParsedAttr::AT_NSReturnsRetained:
case ParsedAttr::AT_NSReturnsNotRetained:
case ParsedAttr::AT_NSReturnsAutoreleased:
  return Sema::RetainOwnershipKind::NS;
default:
  llvm_unreachable("Wrong argument supplied")::llvm::llvm_unreachable_internal("Wrong argument supplied", "/build/llvm-toolchain-snapshot-13~++20210308111132+66e3a4abe99c/clang/lib/Sema/SemaDeclAttr.cpp"
, 5350);
}
5352}

5354bool Sema::checkNSReturnsRetainedReturnType(SourceLocation Loc, QualType QT) {
if (isValidSubjectOfNSReturnsRetainedAttribute(QT))
  return false;

Diag(Loc, diag::warn_ns_attribute_wrong_return_type)
    << "'ns_returns_retained'" << 0 << 0;
return true;
5361}

5363/// \return whether the parameter is a pointer to OSObject pointer.
5364static bool isValidOSObjectOutParameter(const Decl *D) {
const auto *PVD = dyn_cast<ParmVarDecl>(D);
if (!PVD)
  return false;
QualType QT = PVD->getType();
QualType PT = QT->getPointeeType();
return !PT.isNull() && isValidSubjectOfOSAttribute(PT);
5371}

5373static void handleXReturnsXRetainedAttr(Sema &S, Decl *D,
                                      const ParsedAttr &AL) {
QualType ReturnType;
Sema::RetainOwnershipKind K = parsedAttrToRetainOwnershipKind(AL);

if (const auto *MD = dyn_cast<ObjCMethodDecl>(D)) {
  ReturnType = MD->getReturnType();
} else if (S.getLangOpts().ObjCAutoRefCount && hasDeclarator(D) &&
           (AL.getKind() == ParsedAttr::AT_NSReturnsRetained)) {
  return; // ignore: was handled as a type attribute
} else if (const auto *PD = dyn_cast<ObjCPropertyDecl>(D)) {
  ReturnType = PD->getType();
} else if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
  ReturnType = FD->getReturnType();
} else if (const auto *Param = dyn_cast<ParmVarDecl>(D)) {
  // Attributes on parameters are used for out-parameters,
  // passed as pointers-to-pointers.
  unsigned DiagID = K == Sema::RetainOwnershipKind::CF
          ? /*pointer-to-CF-pointer*/2
          : /*pointer-to-OSObject-pointer*/3;
  ReturnType = Param->getType()->getPointeeType();
  if (ReturnType.isNull()) {
    S.Diag(D->getBeginLoc(), diag::warn_ns_attribute_wrong_parameter_type)
        << AL << DiagID << AL.getRange();
    return;
  }
} else if (AL.isUsedAsTypeAttr()) {
  return;
} else {
  AttributeDeclKind ExpectedDeclKind;
  switch (AL.getKind()) {
  default: llvm_unreachable("invalid ownership attribute")::llvm::llvm_unreachable_internal("invalid ownership attribute"
, "/build/llvm-toolchain-snapshot-13~++20210308111132+66e3a4abe99c/clang/lib/Sema/SemaDeclAttr.cpp"
, 5404);
  case ParsedAttr::AT_NSReturnsRetained:
  case ParsedAttr::AT_NSReturnsAutoreleased:
  case ParsedAttr::AT_NSReturnsNotRetained:
    ExpectedDeclKind = ExpectedFunctionOrMethod;
    break;

  case ParsedAttr::AT_OSReturnsRetained:
  case ParsedAttr::AT_OSReturnsNotRetained:
  case ParsedAttr::AT_CFReturnsRetained:
  case ParsedAttr::AT_CFReturnsNotRetained:
    ExpectedDeclKind = ExpectedFunctionMethodOrParameter;
    break;
  }
  S.Diag(D->getBeginLoc(), diag::warn_attribute_wrong_decl_type)
      << AL.getRange() << AL << ExpectedDeclKind;
  return;
}

bool TypeOK;
bool Cf;
unsigned ParmDiagID = 2; // Pointer-to-CF-pointer
switch (AL.getKind()) {
default: llvm_unreachable("invalid ownership attribute")::llvm::llvm_unreachable_internal("invalid ownership attribute"
, "/build/llvm-toolchain-snapshot-13~++20210308111132+66e3a4abe99c/clang/lib/Sema/SemaDeclAttr.cpp"
, 5427);
case ParsedAttr::AT_NSReturnsRetained:
  TypeOK = isValidSubjectOfNSReturnsRetainedAttribute(ReturnType);
  Cf = false;
  break;

case ParsedAttr::AT_NSReturnsAutoreleased:
case ParsedAttr::AT_NSReturnsNotRetained:
  TypeOK = isValidSubjectOfNSAttribute(ReturnType);
  Cf = false;
  break;

case ParsedAttr::AT_CFReturnsRetained:
case ParsedAttr::AT_CFReturnsNotRetained:
  TypeOK = isValidSubjectOfCFAttribute(ReturnType);
  Cf = true;
  break;

case ParsedAttr::AT_OSReturnsRetained:
case ParsedAttr::AT_OSReturnsNotRetained:
  TypeOK = isValidSubjectOfOSAttribute(ReturnType);
  Cf = true;
  ParmDiagID = 3; // Pointer-to-OSObject-pointer
  break;
}

if (!TypeOK) {
  if (AL.isUsedAsTypeAttr())
    return;

  if (isa<ParmVarDecl>(D)) {
    S.Diag(D->getBeginLoc(), diag::warn_ns_attribute_wrong_parameter_type)
        << AL << ParmDiagID << AL.getRange();
  } else {
    // Needs to be kept in sync with warn_ns_attribute_wrong_return_type.
    enum : unsigned {
      Function,
      Method,
      Property
    } SubjectKind = Function;
    if (isa<ObjCMethodDecl>(D))
      SubjectKind = Method;
    else if (isa<ObjCPropertyDecl>(D))
      SubjectKind = Property;
    S.Diag(D->getBeginLoc(), diag::warn_ns_attribute_wrong_return_type)
        << AL << SubjectKind << Cf << AL.getRange();
  }
  return;
}

switch (AL.getKind()) {
  default:
    llvm_unreachable("invalid ownership attribute")::llvm::llvm_unreachable_internal("invalid ownership attribute"
, "/build/llvm-toolchain-snapshot-13~++20210308111132+66e3a4abe99c/clang/lib/Sema/SemaDeclAttr.cpp"
, 5479);
  case ParsedAttr::AT_NSReturnsAutoreleased:
    handleSimpleAttribute<NSReturnsAutoreleasedAttr>(S, D, AL);
    return;
  case ParsedAttr::AT_CFReturnsNotRetained:
    handleSimpleAttribute<CFReturnsNotRetainedAttr>(S, D, AL);
    return;
  case ParsedAttr::AT_NSReturnsNotRetained:
    handleSimpleAttribute<NSReturnsNotRetainedAttr>(S, D, AL);
    return;
  case ParsedAttr::AT_CFReturnsRetained:
    handleSimpleAttribute<CFReturnsRetainedAttr>(S, D, AL);
    return;
  case ParsedAttr::AT_NSReturnsRetained:
    handleSimpleAttribute<NSReturnsRetainedAttr>(S, D, AL);
    return;
  case ParsedAttr::AT_OSReturnsRetained:
    handleSimpleAttribute<OSReturnsRetainedAttr>(S, D, AL);
    return;
  case ParsedAttr::AT_OSReturnsNotRetained:
    handleSimpleAttribute<OSReturnsNotRetainedAttr>(S, D, AL);
    return;
};
5502}

5504static void handleObjCReturnsInnerPointerAttr(Sema &S, Decl *D,
                                            const ParsedAttr &Attrs) {
const int EP_ObjCMethod = 1;
const int EP_ObjCProperty = 2;

SourceLocation loc = Attrs.getLoc();
QualType resultType;
if (isa<ObjCMethodDecl>(D))
  resultType = cast<ObjCMethodDecl>(D)->getReturnType();
else
  resultType = cast<ObjCPropertyDecl>(D)->getType();

if (!resultType->isReferenceType() &&
    (!resultType->isPointerType() || resultType->isObjCRetainableType())) {
  S.Diag(D->getBeginLoc(), diag::warn_ns_attribute_wrong_return_type)
      << SourceRange(loc) << Attrs
      << (isa<ObjCMethodDecl>(D) ? EP_ObjCMethod : EP_ObjCProperty)
      << /*non-retainable pointer*/ 2;

  // Drop the attribute.
  return;
}

D->addAttr(::new (S.Context) ObjCReturnsInnerPointerAttr(S.Context, Attrs));
5528}

5530static void handleObjCRequiresSuperAttr(Sema &S, Decl *D,
                                      const ParsedAttr &Attrs) {
const auto *Method = cast<ObjCMethodDecl>(D);

const DeclContext *DC = Method->getDeclContext();
if (const auto *PDecl = dyn_cast_or_null<ObjCProtocolDecl>(DC)) {
  S.Diag(D->getBeginLoc(), diag::warn_objc_requires_super_protocol) << Attrs
                                                                    << 0;
  S.Diag(PDecl->getLocation(), diag::note_protocol_decl);
  return;
}
if (Method->getMethodFamily() == OMF_dealloc) {
  S.Diag(D->getBeginLoc(), diag::warn_objc_requires_super_protocol) << Attrs
                                                                    << 1;
  return;
}

D->addAttr(::new (S.Context) ObjCRequiresSuperAttr(S.Context, Attrs));
5548}

5550static void handleNSErrorDomain(Sema &S, Decl *D, const ParsedAttr &AL) {
auto *E = AL.getArgAsExpr(0);
auto Loc = E ? E->getBeginLoc() : AL.getLoc();

auto *DRE = dyn_cast<DeclRefExpr>(AL.getArgAsExpr(0));
if (!DRE) {
  S.Diag(Loc, diag::err_nserrordomain_invalid_decl) << 0;
  return;
}

auto *VD = dyn_cast<VarDecl>(DRE->getDecl());
if (!VD) {
  S.Diag(Loc, diag::err_nserrordomain_invalid_decl) << 1 << DRE->getDecl();
  return;
}

if (!isNSStringType(VD->getType(), S.Context) &&
    !isCFStringType(VD->getType(), S.Context)) {
  S.Diag(Loc, diag::err_nserrordomain_wrong_type) << VD;
  return;
}

D->addAttr(::new (S.Context) NSErrorDomainAttr(S.Context, AL, VD));
5573}

5575static void handleObjCBridgeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
IdentifierLoc *Parm = AL.isArgIdent(0) ? AL.getArgAsIdent(0) : nullptr;

if (!Parm) {
  S.Diag(D->getBeginLoc(), diag::err_objc_attr_not_id) << AL << 0;
  return;
}

// Typedefs only allow objc_bridge(id) and have some additional checking.
if (const auto *TD = dyn_cast<TypedefNameDecl>(D)) {
  if (!Parm->Ident->isStr("id")) {
    S.Diag(AL.getLoc(), diag::err_objc_attr_typedef_not_id) << AL;
    return;
  }

  // Only allow 'cv void *'.
  QualType T = TD->getUnderlyingType();
  if (!T->isVoidPointerType()) {
    S.Diag(AL.getLoc(), diag::err_objc_attr_typedef_not_void_pointer);
    return;
  }
}

D->addAttr(::new (S.Context) ObjCBridgeAttr(S.Context, AL, Parm->Ident));
5599}

5601static void handleObjCBridgeMutableAttr(Sema &S, Decl *D,
                                      const ParsedAttr &AL) {
IdentifierLoc *Parm = AL.isArgIdent(0) ? AL.getArgAsIdent(0) : nullptr;

if (!Parm) {
  S.Diag(D->getBeginLoc(), diag::err_objc_attr_not_id) << AL << 0;
  return;
}

D->addAttr(::new (S.Context)
               ObjCBridgeMutableAttr(S.Context, AL, Parm->Ident));
5612}

5614static void handleObjCBridgeRelatedAttr(Sema &S, Decl *D,
                                      const ParsedAttr &AL) {
IdentifierInfo *RelatedClass =
    AL.isArgIdent(0) ? AL.getArgAsIdent(0)->Ident : nullptr;
if (!RelatedClass) {
  S.Diag(D->getBeginLoc(), diag::err_objc_attr_not_id) << AL << 0;
  return;
}
IdentifierInfo *ClassMethod =
  AL.getArgAsIdent(1) ? AL.getArgAsIdent(1)->Ident : nullptr;
IdentifierInfo *InstanceMethod =
  AL.getArgAsIdent(2) ? AL.getArgAsIdent(2)->Ident : nullptr;
D->addAttr(::new (S.Context) ObjCBridgeRelatedAttr(
    S.Context, AL, RelatedClass, ClassMethod, InstanceMethod));
5628}

5630static void handleObjCDesignatedInitializer(Sema &S, Decl *D,
                                          const ParsedAttr &AL) {
DeclContext *Ctx = D->getDeclContext();

// This attribute can only be applied to methods in interfaces or class
// extensions.
if (!isa<ObjCInterfaceDecl>(Ctx) &&
    !(isa<ObjCCategoryDecl>(Ctx) &&
      cast<ObjCCategoryDecl>(Ctx)->IsClassExtension())) {
  S.Diag(D->getLocation(), diag::err_designated_init_attr_non_init);
  return;
}

ObjCInterfaceDecl *IFace;
if (auto *CatDecl = dyn_cast<ObjCCategoryDecl>(Ctx))
  IFace = CatDecl->getClassInterface();
else
  IFace = cast<ObjCInterfaceDecl>(Ctx);

if (!IFace)
  return;

IFace->setHasDesignatedInitializers();
D->addAttr(::new (S.Context) ObjCDesignatedInitializerAttr(S.Context, AL));
5654}

5656static void handleObjCRuntimeName(Sema &S, Decl *D, const ParsedAttr &AL) {
StringRef MetaDataName;
if (!S.checkStringLiteralArgumentAttr(AL, 0, MetaDataName))
  return;
D->addAttr(::new (S.Context)
               ObjCRuntimeNameAttr(S.Context, AL, MetaDataName));
5662}

5664// When a user wants to use objc_boxable with a union or struct
5665// but they don't have access to the declaration (legacy/third-party code)
5666// then they can 'enable' this feature with a typedef:
5667// typedef struct __attribute((objc_boxable)) legacy_struct legacy_struct;
5668static void handleObjCBoxable(Sema &S, Decl *D, const ParsedAttr &AL) {
bool notify = false;

auto *RD = dyn_cast<RecordDecl>(D);
if (RD && RD->getDefinition()) {
  RD = RD->getDefinition();
  notify = true;
}

if (RD) {
  ObjCBoxableAttr *BoxableAttr =
      ::new (S.Context) ObjCBoxableAttr(S.Context, AL);
  RD->addAttr(BoxableAttr);
  if (notify) {
    // we need to notify ASTReader/ASTWriter about
    // modification of existing declaration
    if (ASTMutationListener *L = S.getASTMutationListener())
      L->AddedAttributeToRecord(BoxableAttr, RD);
  }
}
5688}

5690static void handleObjCOwnershipAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (hasDeclarator(D)) return;

S.Diag(D->getBeginLoc(), diag::err_attribute_wrong_decl_type)
    << AL.getRange() << AL << ExpectedVariable;
5695}

5697static void handleObjCPreciseLifetimeAttr(Sema &S, Decl *D,
                                        const ParsedAttr &AL) {
const auto *VD = cast<ValueDecl>(D);
QualType QT = VD->getType();

if (!QT->isDependentType() &&
    !QT->isObjCLifetimeType()) {
  S.Diag(AL.getLoc(), diag::err_objc_precise_lifetime_bad_type)
    << QT;
  return;
}

Qualifiers::ObjCLifetime Lifetime = QT.getObjCLifetime();

// If we have no lifetime yet, check the lifetime we're presumably
// going to infer.
if (Lifetime == Qualifiers::OCL_None && !QT->isDependentType())
  Lifetime = QT->getObjCARCImplicitLifetime();

switch (Lifetime) {
case Qualifiers::OCL_None:
  assert(QT->isDependentType() &&((QT->isDependentType() && "didn't infer lifetime for non-dependent type?"
) ? static_cast<void> (0) : __assert_fail ("QT->isDependentType() && \"didn't infer lifetime for non-dependent type?\""
, "/build/llvm-toolchain-snapshot-13~++20210308111132+66e3a4abe99c/clang/lib/Sema/SemaDeclAttr.cpp"
, 5719, __PRETTY_FUNCTION__))
         "didn't infer lifetime for non-dependent type?")((QT->isDependentType() && "didn't infer lifetime for non-dependent type?"
) ? static_cast<void> (0) : __assert_fail ("QT->isDependentType() && \"didn't infer lifetime for non-dependent type?\""
, "/build/llvm-toolchain-snapshot-13~++20210308111132+66e3a4abe99c/clang/lib/Sema/SemaDeclAttr.cpp"
, 5719, __PRETTY_FUNCTION__));
  break;

case Qualifiers::OCL_Weak:   // meaningful
case Qualifiers::OCL_Strong: // meaningful
  break;

case Qualifiers::OCL_ExplicitNone:
case Qualifiers::OCL_Autoreleasing:
  S.Diag(AL.getLoc(), diag::warn_objc_precise_lifetime_meaningless)
      << (Lifetime == Qualifiers::OCL_Autoreleasing);
  break;
}

D->addAttr(::new (S.Context) ObjCPreciseLifetimeAttr(S.Context, AL));
5734}

5736static void handleSwiftAttrAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
// Make sure that there is a string literal as the annotation's single
// argument.
StringRef Str;
if (!S.checkStringLiteralArgumentAttr(AL, 0, Str))
  return;

D->addAttr(::new (S.Context) SwiftAttrAttr(S.Context, AL, Str));
5744}

5746static void handleSwiftBridge(Sema &S, Decl *D, const ParsedAttr &AL) {
// Make sure that there is a string literal as the annotation's single
// argument.
StringRef BT;
if (!S.checkStringLiteralArgumentAttr(AL, 0, BT))
  return;

// Warn about duplicate attributes if they have different arguments, but drop
// any duplicate attributes regardless.
if (const auto *Other = D->getAttr<SwiftBridgeAttr>()) {
  if (Other->getSwiftType() != BT)
    S.Diag(AL.getLoc(), diag::warn_duplicate_attribute) << AL;
  return;
}

D->addAttr(::new (S.Context) SwiftBridgeAttr(S.Context, AL, BT));
5762}

5764static bool isErrorParameter(Sema &S, QualType QT) {
const auto *PT = QT->getAs<PointerType>();
if (!PT)
  return false;

QualType Pointee = PT->getPointeeType();

// Check for NSError**.
if (const auto *OPT = Pointee->getAs<ObjCObjectPointerType>())
  if (const auto *ID = OPT->getInterfaceDecl())
    if (ID->getIdentifier() == S.getNSErrorIdent())
      return true;

// Check for CFError**.
if (const auto *PT = Pointee->getAs<PointerType>())
  if (const auto *RT = PT->getPointeeType()->getAs<RecordType>())
    if (S.isCFError(RT->getDecl()))
      return true;

return false;
5784}

5786static void handleSwiftError(Sema &S, Decl *D, const ParsedAttr &AL) {
auto hasErrorParameter = [](Sema &S, Decl *D, const ParsedAttr &AL) -> bool {
  for (unsigned I = 0, E = getFunctionOrMethodNumParams(D); I != E; ++I) {
    if (isErrorParameter(S, getFunctionOrMethodParamType(D, I)))
      return true;
  }

  S.Diag(AL.getLoc(), diag::err_attr_swift_error_no_error_parameter)
      << AL << isa<ObjCMethodDecl>(D);
  return false;
};

auto hasPointerResult = [](Sema &S, Decl *D, const ParsedAttr &AL) -> bool {
  // - C, ObjC, and block pointers are definitely okay.
  // - References are definitely not okay.
  // - nullptr_t is weird, but acceptable.
  QualType RT = getFunctionOrMethodResultType(D);
  if (RT->hasPointerRepresentation() && !RT->isReferenceType())
    return true;

  S.Diag(AL.getLoc(), diag::err_attr_swift_error_return_type)
      << AL << AL.getArgAsIdent(0)->Ident->getName() << isa<ObjCMethodDecl>(D)
      << /*pointer*/ 1;
  return false;
};

auto hasIntegerResult = [](Sema &S, Decl *D, const ParsedAttr &AL) -> bool {
  QualType RT = getFunctionOrMethodResultType(D);
  if (RT->isIntegralType(S.Context))
    return true;

  S.Diag(AL.getLoc(), diag::err_attr_swift_error_return_type)
      << AL << AL.getArgAsIdent(0)->Ident->getName() << isa<ObjCMethodDecl>(D)
      << /*integral*/ 0;
  return false;
};

if (D->isInvalidDecl())
  return;

IdentifierLoc *Loc = AL.getArgAsIdent(0);
SwiftErrorAttr::ConventionKind Convention;
if (!SwiftErrorAttr::ConvertStrToConventionKind(Loc->Ident->getName(),
                                                Convention)) {
  S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported)
      << AL << Loc->Ident;
  return;
}

switch (Convention) {
case SwiftErrorAttr::None:
  // No additional validation required.
  break;

case SwiftErrorAttr::NonNullError:
  if (!hasErrorParameter(S, D, AL))
    return;
  break;

case SwiftErrorAttr::NullResult:
  if (!hasErrorParameter(S, D, AL) || !hasPointerResult(S, D, AL))
    return;
  break;

case SwiftErrorAttr::NonZeroResult:
case SwiftErrorAttr::ZeroResult:
  if (!hasErrorParameter(S, D, AL) || !hasIntegerResult(S, D, AL))
    return;
  break;
}

D->addAttr(::new (S.Context) SwiftErrorAttr(S.Context, AL, Convention));
5858}

5860static void checkSwiftAsyncErrorBlock(Sema &S, Decl *D,
                                    const SwiftAsyncErrorAttr *ErrorAttr,
                                    const SwiftAsyncAttr *AsyncAttr) {
if (AsyncAttr->getKind() == SwiftAsyncAttr::None) {
1
Assuming the condition is false→
2
←
Taking false branch→
  if (ErrorAttr->getConvention() != SwiftAsyncErrorAttr::None) {
    S.Diag(AsyncAttr->getLocation(),
           diag::err_swift_async_error_without_swift_async)
        << AsyncAttr << isa<ObjCMethodDecl>(D);
  }
  return;
}

const ParmVarDecl *HandlerParam = getFunctionOrMethodParam(
    D, AsyncAttr->getCompletionHandlerIndex().getASTIndex());
// handleSwiftAsyncAttr already verified the type is correct, so no need to
// double-check it here.
const auto *FuncTy = HandlerParam->getType()
3
←
Assuming the object is not a 'BlockPointerType'→
4
←
Called C++ object pointer is null
                         ->getAs<BlockPointerType>()
                         ->getPointeeType()
                         ->getAs<FunctionProtoType>();
ArrayRef<QualType> BlockParams;
if (FuncTy)
  BlockParams = FuncTy->getParamTypes();

switch (ErrorAttr->getConvention()) {
case SwiftAsyncErrorAttr::ZeroArgument:
case SwiftAsyncErrorAttr::NonZeroArgument: {
  uint32_t ParamIdx = ErrorAttr->getHandlerParamIdx();
  if (ParamIdx == 0 || ParamIdx > BlockParams.size()) {
    S.Diag(ErrorAttr->getLocation(),
           diag::err_attribute_argument_out_of_bounds) << ErrorAttr << 2;
    return;
  }
  QualType ErrorParam = BlockParams[ParamIdx - 1];
  if (!ErrorParam->isIntegralType(S.Context)) {
    StringRef ConvStr =
        ErrorAttr->getConvention() == SwiftAsyncErrorAttr::ZeroArgument
            ? "zero_argument"
            : "nonzero_argument";
    S.Diag(ErrorAttr->getLocation(), diag::err_swift_async_error_non_integral)
        << ErrorAttr << ConvStr << ParamIdx << ErrorParam;
    return;
  }
  break;
}
case SwiftAsyncErrorAttr::NonNullError: {
  bool AnyErrorParams = false;
  for (QualType Param : BlockParams) {
    // Check for NSError *.
    if (const auto *ObjCPtrTy = Param->getAs<ObjCObjectPointerType>()) {
      if (const auto *ID = ObjCPtrTy->getInterfaceDecl()) {
        if (ID->getIdentifier() == S.getNSErrorIdent()) {
          AnyErrorParams = true;
          break;
        }
      }
    }
    // Check for CFError *.
    if (const auto *PtrTy = Param->getAs<PointerType>()) {
      if (const auto *RT = PtrTy->getPointeeType()->getAs<RecordType>()) {
        if (S.isCFError(RT->getDecl())) {
          AnyErrorParams = true;
          break;
        }
      }
    }
  }

  if (!AnyErrorParams) {
    S.Diag(ErrorAttr->getLocation(),
           diag::err_swift_async_error_no_error_parameter)
        << ErrorAttr << isa<ObjCMethodDecl>(D);
    return;
  }
  break;
}
case SwiftAsyncErrorAttr::None:
  break;
}
5939}

5941static void handleSwiftAsyncError(Sema &S, Decl *D, const ParsedAttr &AL) {
IdentifierLoc *IDLoc = AL.getArgAsIdent(0);
SwiftAsyncErrorAttr::ConventionKind ConvKind;
if (!SwiftAsyncErrorAttr::ConvertStrToConventionKind(IDLoc->Ident->getName(),
                                                     ConvKind)) {
  S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported)
      << AL << IDLoc->Ident;
  return;
}

uint32_t ParamIdx = 0;
switch (ConvKind) {
case SwiftAsyncErrorAttr::ZeroArgument:
case SwiftAsyncErrorAttr::NonZeroArgument: {
  if (!checkAttributeNumArgs(S, AL, 2))
    return;

  Expr *IdxExpr = AL.getArgAsExpr(1);
  if (!checkUInt32Argument(S, AL, IdxExpr, ParamIdx))
    return;
  break;
}
case SwiftAsyncErrorAttr::NonNullError:
case SwiftAsyncErrorAttr::None: {
  if (!checkAttributeNumArgs(S, AL, 1))
    return;
  break;
}
}

auto *ErrorAttr =
    ::new (S.Context) SwiftAsyncErrorAttr(S.Context, AL, ConvKind, ParamIdx);
D->addAttr(ErrorAttr);

if (auto *AsyncAttr = D->getAttr<SwiftAsyncAttr>())
  checkSwiftAsyncErrorBlock(S, D, ErrorAttr, AsyncAttr);
5977}

5979// For a function, this will validate a compound Swift name, e.g.
5980// <code>init(foo:bar:baz:)</code> or <code>controllerForName(_:)</code>, and
5981// the function will output the number of parameter names, and whether this is a
5982// single-arg initializer.
5983//
5984// For a type, enum constant, property, or variable declaration, this will
5985// validate either a simple identifier, or a qualified
5986// <code>context.identifier</code> name.
5987static bool
5988validateSwiftFunctionName(Sema &S, const ParsedAttr &AL, SourceLocation Loc,
                        StringRef Name, unsigned &SwiftParamCount,
                        bool &IsSingleParamInit) {
SwiftParamCount = 0;
IsSingleParamInit = false;

// Check whether this will be mapped to a getter or setter of a property.
bool IsGetter = false, IsSetter = false;
if (Name.startswith("getter:")) {
  IsGetter = true;
  Name = Name.substr(7);
} else if (Name.startswith("setter:")) {
  IsSetter = true;
  Name = Name.substr(7);
}

if (Name.back() != ')') {
  S.Diag(Loc, diag::warn_attr_swift_name_function) << AL;
  return false;
}

bool IsMember = false;
StringRef ContextName, BaseName, Parameters;

std::tie(BaseName, Parameters) = Name.split('(');

// Split at the first '.', if it exists, which separates the context name
// from the base name.
std::tie(ContextName, BaseName) = BaseName.split('.');
if (BaseName.empty()) {
  BaseName = ContextName;
  ContextName = StringRef();
} else if (ContextName.empty() || !isValidIdentifier(ContextName)) {
  S.Diag(Loc, diag::warn_attr_swift_name_invalid_identifier)
      << AL << /*context*/ 1;
  return false;
} else {
  IsMember = true;
}

if (!isValidIdentifier(BaseName) || BaseName == "_") {
  S.Diag(Loc, diag::warn_attr_swift_name_invalid_identifier)
      << AL << /*basename*/ 0;
  return false;
}

bool IsSubscript = BaseName == "subscript";
// A subscript accessor must be a getter or setter.
if (IsSubscript && !IsGetter && !IsSetter) {
  S.Diag(Loc, diag::warn_attr_swift_name_subscript_invalid_parameter)
      << AL << /* getter or setter */ 0;
  return false;
}

if (Parameters.empty()) {
  S.Diag(Loc, diag::warn_attr_swift_name_missing_parameters) << AL;
  return false;
}

assert(Parameters.back() == ')' && "expected ')'")((Parameters.back() == ')' && "expected ')'") ? static_cast
<void> (0) : __assert_fail ("Parameters.back() == ')' && \"expected ')'\""
, "/build/llvm-toolchain-snapshot-13~++20210308111132+66e3a4abe99c/clang/lib/Sema/SemaDeclAttr.cpp"
, 6047, __PRETTY_FUNCTION__));
Parameters = Parameters.drop_back(); // ')'

if (Parameters.empty()) {
  // Setters and subscripts must have at least one parameter.
  if (IsSubscript) {
    S.Diag(Loc, diag::warn_attr_swift_name_subscript_invalid_parameter)
        << AL << /* have at least one parameter */1;
    return false;
  }

  if (IsSetter) {
    S.Diag(Loc, diag::warn_attr_swift_name_setter_parameters) << AL;
    return false;
  }

  return true;
}

if (Parameters.back() != ':') {
  S.Diag(Loc, diag::warn_attr_swift_name_function) << AL;
  return false;
}

StringRef CurrentParam;
llvm::Optional<unsigned> SelfLocation;
unsigned NewValueCount = 0;
llvm::Optional<unsigned> NewValueLocation;
do {
  std::tie(CurrentParam, Parameters) = Parameters.split(':');

  if (!isValidIdentifier(CurrentParam)) {
    S.Diag(Loc, diag::warn_attr_swift_name_invalid_identifier)
        << AL << /*parameter*/2;
    return false;
  }

  if (IsMember && CurrentParam == "self") {
    // "self" indicates the "self" argument for a member.

    // More than one "self"?
    if (SelfLocation) {
      S.Diag(Loc, diag::warn_attr_swift_name_multiple_selfs) << AL;
      return false;
    }

    // The "self" location is the current parameter.
    SelfLocation = SwiftParamCount;
  } else if (CurrentParam == "newValue") {
    // "newValue" indicates the "newValue" argument for a setter.

    // There should only be one 'newValue', but it's only significant for
    // subscript accessors, so don't error right away.
    ++NewValueCount;

    NewValueLocation = SwiftParamCount;
  }

  ++SwiftParamCount;
} while (!Parameters.empty());

// Only instance subscripts are currently supported.
if (IsSubscript && !SelfLocation) {
  S.Diag(Loc, diag::warn_attr_swift_name_subscript_invalid_parameter)
      << AL << /*have a 'self:' parameter*/2;
  return false;
}

IsSingleParamInit =
      SwiftParamCount == 1 && BaseName == "init" && CurrentParam != "_";

// Check the number of parameters for a getter/setter.
if (IsGetter || IsSetter) {
  // Setters have one parameter for the new value.
  unsigned NumExpectedParams = IsGetter ? 0 : 1;
  unsigned ParamDiag =
      IsGetter ? diag::warn_attr_swift_name_getter_parameters
               : diag::warn_attr_swift_name_setter_parameters;

  // Instance methods have one parameter for "self".
  if (SelfLocation)
    ++NumExpectedParams;

  // Subscripts may have additional parameters beyond the expected params for
  // the index.
  if (IsSubscript) {
    if (SwiftParamCount < NumExpectedParams) {
      S.Diag(Loc, ParamDiag) << AL;
      return false;
    }

    // A subscript setter must explicitly label its newValue parameter to
    // distinguish it from index parameters.
    if (IsSetter) {
      if (!NewValueLocation) {
        S.Diag(Loc, diag::warn_attr_swift_name_subscript_setter_no_newValue)
            << AL;
        return false;
      }
      if (NewValueCount > 1) {
        S.Diag(Loc, diag::warn_attr_swift_name_subscript_setter_multiple_newValues)
            << AL;
        return false;
      }
    } else {
      // Subscript getters should have no 'newValue:' parameter.
      if (NewValueLocation) {
        S.Diag(Loc, diag::warn_attr_swift_name_subscript_getter_newValue)
            << AL;
        return false;
      }
    }
  } else {
    // Property accessors must have exactly the number of expected params.
    if (SwiftParamCount != NumExpectedParams) {
      S.Diag(Loc, ParamDiag) << AL;
      return false;
    }
  }
}

return true;
6169}

6171bool Sema::DiagnoseSwiftName(Decl *D, StringRef Name, SourceLocation Loc,
                           const ParsedAttr &AL, bool IsAsync) {
if (isa<ObjCMethodDecl>(D) || isa<FunctionDecl>(D)) {
  ArrayRef<ParmVarDecl*> Params;
  unsigned ParamCount;

  if (const auto *Method = dyn_cast<ObjCMethodDecl>(D)) {
    ParamCount = Method->getSelector().getNumArgs();
    Params = Method->parameters().slice(0, ParamCount);
  } else {
    const auto *F = cast<FunctionDecl>(D);

    ParamCount = F->getNumParams();
    Params = F->parameters();

    if (!F->hasWrittenPrototype()) {
      Diag(Loc, diag::warn_attribute_wrong_decl_type) << AL
          << ExpectedFunctionWithProtoType;
      return false;
    }
  }

  // The async name drops the last callback parameter.
  if (IsAsync) {
    if (ParamCount == 0) {
      Diag(Loc, diag::warn_attr_swift_name_decl_missing_params)
          << AL << isa<ObjCMethodDecl>(D);
      return false;
    }
    ParamCount -= 1;
  }

  unsigned SwiftParamCount;
  bool IsSingleParamInit;
  if (!validateSwiftFunctionName(*this, AL, Loc, Name,
                                 SwiftParamCount, IsSingleParamInit))
    return false;

  bool ParamCountValid;
  if (SwiftParamCount == ParamCount) {
    ParamCountValid = true;
  } else if (SwiftParamCount > ParamCount) {
    ParamCountValid = IsSingleParamInit && ParamCount == 0;
  } else {
    // We have fewer Swift parameters than Objective-C parameters, but that
    // might be because we've transformed some of them. Check for potential
    // "out" parameters and err on the side of not warning.
    unsigned MaybeOutParamCount =
        std::count_if(Params.begin(), Params.end(),
                      [](const ParmVarDecl *Param) -> bool {
      QualType ParamTy = Param->getType();