RetroSearch Browse

->Loc, diag::err_attribute_argument_type)

139

Str =

->Ident->getName();

141

*ArgLocation =

->Loc;

147 const auto

*Literal = dyn_cast<StringLiteral>(ArgExpr->

IgnoreParenCasts

());

151 if

(!Literal || (!Literal->isUnevaluated() && !Literal->isOrdinary())) {

156

Str = Literal->getString();

178 bool

foundStarOperator = IsOverloadedOperatorPresent(

Record

, OO_Star);

179 bool

foundArrowOperator = IsOverloadedOperatorPresent(

Record

, OO_Arrow);

180 if

(foundStarOperator && foundArrowOperator)

187 for

(

const auto

&BaseSpecifier : CXXRecord->bases()) {

188 if

(!foundStarOperator)

189

foundStarOperator = IsOverloadedOperatorPresent(

190

BaseSpecifier.getType()->getAsRecordDecl(), OO_Star);

191 if

(!foundArrowOperator)

192

foundArrowOperator = IsOverloadedOperatorPresent(

193

BaseSpecifier.getType()->getAsRecordDecl(), OO_Arrow);

196 if

(foundStarOperator && foundArrowOperator)

207 const auto

*VD = cast<ValueDecl>(

);

216 if

(RT->isIncompleteType())

223

(AL.

(), diag::warn_thread_attribute_decl_not_pointer) << AL << QT;

240template

typename

AttrType>

247 if

(

const auto

*CRD = dyn_cast<CXXRecordDecl>(RD)) {

249

return !Base->hasAttr<AttrType>();

271 return

checkRecordDeclForAttr<CapabilityAttr>(RT->

());

284 return

checkRecordDeclForAttr<ScopedLockableAttr>(RT->

());

296 return

TN->

<CapabilityAttr>();

315 if

(

const auto

= dyn_cast<CastExpr>(Ex))

317 else if

(

const auto

= dyn_cast<ParenExpr>(Ex))

319 else if

(

const auto

= dyn_cast<UnaryOperator>(Ex)) {

320 if

(

->getOpcode() == UO_LNot ||

->getOpcode() == UO_AddrOf ||

321 E

->getOpcode() == UO_Deref)

324

}

else if

(

const auto

= dyn_cast<BinaryOperator>(Ex)) {

325 if

(

->getOpcode() == BO_LAnd ||

->getOpcode() == BO_LOr)

343 bool

ParamIdxOk =

false

) {

348 const auto

*MD = dyn_cast<const CXXMethodDecl>(

);

349 if

(MD && !MD->isStatic()) {

352 if

(!checkRecordDeclForAttr<CapabilityAttr>(RD) &&

353

!checkRecordDeclForAttr<ScopedLockableAttr>(RD))

355

diag::warn_thread_attribute_not_on_capability_member)

356

<< AL << MD->getParent();

358

(AL.

(), diag::warn_thread_attribute_not_on_non_static_member)

363 for

(

unsigned

Idx = Sidx; Idx < AL.

(); ++Idx) {

368

Args.push_back(ArgExp);

372 if

(

const auto

*StrLit = dyn_cast<StringLiteral>(ArgExp)) {

373 if

(StrLit->getLength() == 0 ||

374

(StrLit->isOrdinary() && StrLit->getString() ==

"*"

)) {

377

Args.push_back(ArgExp);

383

(AL.

(), diag::warn_thread_attribute_ignored) << AL;

384

Args.push_back(ArgExp);

392 if

(

const auto

*UOp = dyn_cast<UnaryOperator>(ArgExp))

393 if

(UOp->getOpcode() == UO_AddrOf)

394 if

(

const auto

*DRE = dyn_cast<DeclRefExpr>(UOp->getSubExpr()))

395 if

(DRE->getDecl()->isCXXInstanceMember())

396

ArgTy = DRE->getDecl()->getType();

402 if

(!RT && ParamIdxOk) {

403 const auto

*FD = dyn_cast<FunctionDecl>(

);

404 const auto

*IL = dyn_cast<IntegerLiteral>(ArgExp);

406 unsigned int

NumParams = FD->getNumParams();

407

llvm::APInt ArgValue = IL->getValue();

408

uint64_t ParamIdxFromOne = ArgValue.getZExtValue();

409

uint64_t ParamIdxFromZero = ParamIdxFromOne - 1;

410 if

(!ArgValue.isStrictlyPositive() || ParamIdxFromOne > NumParams) {

412

diag::err_attribute_argument_out_of_bounds_extra_info)

413

<< AL << Idx + 1 << NumParams;

416

ArgTy = FD->getParamDecl(ParamIdxFromZero)->getType();

425

(AL.

(), diag::warn_thread_attribute_argument_not_lockable)

428

Args.push_back(ArgExp);

440

(AL.

(), diag::warn_thread_attribute_not_on_scoped_lockable_param)

461 unsigned

Size = Args.size();

471 Expr

*Arg =

nullptr

;

479 Expr

*Arg =

nullptr

;

495 QualType

QT = cast<ValueDecl>(

)->getType();

497

(AL.

(), diag::warn_thread_attribute_decl_not_lockable) << AL;

514 Expr

**StartArg = &Args[0];

516

AcquiredAfterAttr(S.

, AL, StartArg, Args.size()));

524 Expr

**StartArg = &Args[0];

526

AcquiredBeforeAttr(S.

, AL, StartArg, Args.size()));

543 unsigned

Size = Args.size();

544 Expr

**StartArg = Size == 0 ? nullptr : &Args[0];

546

AssertSharedLockAttr(S.

, AL, StartArg, Size));

555 unsigned

Size = Args.size();

556 Expr

**StartArg = Size == 0 ? nullptr : &Args[0];

558

AssertExclusiveLockAttr(S.

, AL, StartArg, Size));

566template

typename

AttrInfo>

568 unsigned

AttrArgNo) {

569

assert(AI.isArgExpr(AttrArgNo) &&

"Expected expression argument"

);

570 Expr

*AttrArg = AI.getArgAsExpr(AttrArgNo);

579

(SrcLoc, diag::err_attribute_integers_only)

594

(AL.

(), diag::warn_attribute_return_pointers_only) << AL;

620

AllocSizeAttr(S.

, AL, SizeArgNo, NumberArgNo));

629

(AL.

(), diag::err_attribute_argument_n_type)

664 unsigned

Size = Args.size();

672 if

(

const auto

*ParmDecl = dyn_cast<ParmVarDecl>(

);

682 unsigned

Size = Args.size();

685 Expr

**StartArg = &Args[0];

688

LocksExcludedAttr(S.

, AL, StartArg, Size));

692 Expr

*&Cond, StringRef &Msg) {

698

Cond = Converted.

get

();

705

Msg =

"<no message provided>"

;

711

(AL.

(), diag::err_attr_cond_never_constant_expr) << AL;

713

(PDiag.first, PDiag.second);

720

(AL.

(), diag::ext_clang_enable_if);

729

StringRef NewUserDiagnostic;

738 const auto

*PD = isa<CXXRecordDecl>(

)

739

? cast<DeclContext>(

)

741 if

(

const auto

*RD = dyn_cast<CXXRecordDecl>(PD); RD && RD->isLocalClass()) {

743

diag::warn_attribute_exclude_from_explicit_instantiation_local_class)

744

<< AL <<

!isa<CXXRecordDecl>(

);

748

ExcludeFromExplicitInstantiationAttr(S.

, AL));

764 if

(

const auto

*MD = dyn_cast<CXXMethodDecl>(FD))

767

ClassType =

nullptr

;

772 bool

referencesArgs(

Expr

) {

780 "`this` doesn't refer to the enclosing class?"

);

785 bool

VisitDeclRefExpr(

DeclRefExpr

*DRE)

override

{

786 if

(

const auto

*PVD = dyn_cast<ParmVarDecl>(DRE->

()))

787 if

(Parms.count(PVD)) {

798 const auto

*DeclFD = cast<FunctionDecl>(

);

800 if

(

const auto

*MethodDecl = dyn_cast<CXXMethodDecl>(DeclFD))

801 if

(!MethodDecl->isStatic()) {

802

(AL.

(), diag::err_attribute_no_member_function) << AL;

809 if

(

auto

= dyn_cast<Expr *>(

Union

))

811 return

cast<IdentifierLoc *>(

Union

)->Loc;

814

(

, diag::err_attribute_argument_n_type) << AL << Index <<

;

820 auto

*F = dyn_cast_if_present<DeclRefExpr>(AL.

(0));

823 return

dyn_cast_if_present<FunctionDecl>(F->getFoundDecl());

832

(AL.

(), diag::err_attribute_wrong_number_arguments_for)

839 for

(

unsigned

I = 1; I < AL.

(); ++I) {

851 if

(Index > DeclFD->getNumParams()) {

852

(AL.

(), diag::err_attribute_bounds_for_function)

853

<< AL << Index << DeclFD << DeclFD->getNumParams();

858 QualType

T2 = DeclFD->getParamDecl(Index - 1)->getType();

862

(IndexExpr->

(), diag::err_attribute_parameter_types)

863

<< AL << Index << DeclFD << T2 << I << AttrFD << T1;

867

Indices.push_back(Index - 1);

871

, AL, AttrFD, Indices.data(), Indices.size()));

875

(AL.

(), diag::ext_clang_diagnose_if);

882

StringRef DefaultSevStr;

886

DiagnoseIfAttr::DefaultSeverity DefaultSev;

887 if

(!DiagnoseIfAttr::ConvertStrToDefaultSeverity(DefaultSevStr, DefaultSev)) {

889

diag::err_diagnose_if_invalid_diagnostic_type);

893

StringRef WarningGroup;

898 if

(WarningGroup.empty() ||

902

diag::err_diagnose_if_unknown_warning)

908 bool

ArgDependent =

false

;

909 if

(

const auto

*FD = dyn_cast<FunctionDecl>(

))

910

ArgDependent = ArgumentDependenceChecker(FD).referencesArgs(Cond);

912

, AL, Cond, Msg, DefaultSev, WarningGroup, ArgDependent,

913

cast<NamedDecl>(

)));

917 static constexpr const

StringRef kWildcard =

"*"

;

920 bool

HasWildcard =

false

;

922 const auto

AddBuiltinName = [&Names, &HasWildcard](StringRef Name) {

923 if

(Name == kWildcard)

925

Names.push_back(Name);

929 if

(

const auto

*NBA =

<NoBuiltinAttr>())

930 for

(StringRef BuiltinName : NBA->builtinNames())

931

AddBuiltinName(BuiltinName);

935

AddBuiltinName(kWildcard);

937 for

(

unsigned

I = 0,

= AL.

(); I !=

; ++I) {

938

StringRef BuiltinName;

944

AddBuiltinName(BuiltinName);

946

(LiteralLoc, diag::warn_attribute_no_builtin_invalid_builtin_name)

947

<< BuiltinName << AL;

952

Names.erase(std::unique(Names.begin(), Names.end()), Names.end());

955 if

(HasWildcard && Names.size() > 1)

957

diag::err_attribute_no_builtin_wildcard_or_builtin_name)

960 if

(

<NoBuiltinAttr>())

963

NoBuiltinAttr(S.

, AL, Names.data(), Names.size()));

967 if

(

<PassObjectSizeAttr>()) {

968

(

(), diag::err_attribute_only_once_per_parameter) << AL;

990 if

(!cast<ParmVarDecl>(

)->getType()->isPointerType()) {

991

(

(), diag::err_attribute_pointers_only) << AL << 1;

999

ConsumableAttr::ConsumedState DefaultState;

1003 if

(!ConsumableAttr::ConvertStrToConsumedState(IL->

(),

1005

(IL->

, diag::warn_attribute_type_not_supported) << AL

1010

(AL.

(), diag::err_attribute_argument_type)

1023 if

(!RD->hasAttr<ConsumableAttr>()) {

1024

(AL.

(), diag::warn_attr_on_unconsumable_class) << RD;

1041 for

(

unsigned

ArgIndex = 0; ArgIndex < AL.

(); ++ArgIndex) {

1042

CallableWhenAttr::ConsumedState CallableState;

1044

StringRef StateString;

1055 if

(!CallableWhenAttr::ConvertStrToConsumedState(StateString,

1057

(

, diag::warn_attribute_type_not_supported) << AL << StateString;

1061

States.push_back(CallableState);

1065

CallableWhenAttr(S.

, AL, States.data(), States.size()));

1069

ParamTypestateAttr::ConsumedState ParamState;

1075 if

(!ParamTypestateAttr::ConvertStrToConsumedState(StateString,

1077

(Ident->

, diag::warn_attribute_type_not_supported)

1078

<< AL << StateString;

1082

(AL.

(), diag::err_attribute_argument_type)

1103

ReturnTypestateAttr::ConsumedState ReturnState;

1107 if

(!ReturnTypestateAttr::ConvertStrToConsumedState(IL->

(),

1109

(IL->

, diag::warn_attribute_type_not_supported) << AL

1114

(AL.

(), diag::err_attribute_argument_type)

1151

SetTypestateAttr::ConsumedState NewState;

1155 if

(!SetTypestateAttr::ConvertStrToConsumedState(Param, NewState)) {

1156

(Ident->

, diag::warn_attribute_type_not_supported) << AL

1161

(AL.

(), diag::err_attribute_argument_type)

1173

TestTypestateAttr::ConsumedState TestState;

1177 if

(!TestTypestateAttr::ConvertStrToConsumedState(Param, TestState)) {

1178

(Ident->

, diag::warn_attribute_type_not_supported) << AL

1183

(AL.

(), diag::err_attribute_argument_type)

1197 if

(

auto

*TD = dyn_cast<TagDecl>(

))

1199 else if

(

auto

*FD = dyn_cast<FieldDecl>(

)) {

1206 if

(BitfieldByteAligned)

1208

(AL.

(), diag::warn_attribute_ignored_for_field_of_type)

1214 if

(BitfieldByteAligned)

1215

(AL.

(), diag::warn_attribute_packed_for_bitfield);

1221

(AL.

(), diag::warn_attribute_ignored) << AL;

1225 auto

*RD = cast<CXXRecordDecl>(

);

1227

assert(CTD &&

"attribute does not appertain to this declaration"

);

1238 if

(

const auto

*CTSD = dyn_cast_if_present<ClassTemplateSpecializationDecl>(

1240

Template = CTSD->getSpecializedTemplate();

1242 while

(TST && TST->isTypeAlias())

1245

Template = TST->getTemplateName().getAsTemplateDecl();

1254

(AL.

(), diag::err_attribute_preferred_name_arg_invalid)

1257

(TT->getDecl()->getLocation(), diag::note_entity_declared_at)

1266

NoSpecializationsAttr::Create(S.

, Message, AL));

1276 T

.getNonReferenceType();

1282 if

(UT && UT->getDecl()->hasAttr<TransparentUnionAttr>()) {

1284 for

(

const auto

*I : UD->

fields

()) {

1298 bool

isReturnValue =

false

) {

1301

(AL.

(), diag::warn_attribute_return_pointers_only)

1302

<< AL << AttrParmRange << TypeRange;

1304

(AL.

(), diag::warn_attribute_pointers_only)

1305

<< AL << AttrParmRange << TypeRange << 0;

1313 for

(

unsigned

I = 0; I < AL.

(); ++I) {

1327

NonNullArgs.push_back(Idx);

1338

I !=

&& !AnyPointers; ++I) {

1341

AnyPointers =

true

;

1345

(AL.

(), diag::warn_attribute_nonnull_no_pointers);

1348 ParamIdx

*Start = NonNullArgs.data();

1349 unsigned

Size = NonNullArgs.size();

1350

llvm::array_pod_sort(Start, Start + Size);

1360

(AL.

(), diag::warn_attribute_nonnull_parm_no_args)

1389 QualType T

= cast<ParmVarDecl>(

)->getType();

1391

(AL.

(), diag::warn_attribute_pointers_only)

1414

AssumeAlignedAttr TmpAttr(

, CI,

, OE);

1418 Diag

(AttrLoc, diag::warn_attribute_return_pointers_refs_only)

1419

<< &TmpAttr << TmpAttr.getRange() << SR;

1424

std::optional<llvm::APSInt> I = llvm::APSInt(64);

1427 Diag

(AttrLoc, diag::err_attribute_argument_n_type)

1431 Diag

(AttrLoc, diag::err_attribute_argument_type)

1437 if

(!I->isPowerOf2()) {

1438 Diag

(AttrLoc, diag::err_alignment_not_power_of_two)

1444 Diag

(CI.

(), diag::warn_assume_aligned_too_great)

1449 Diag

(AttrLoc, diag::err_attribute_argument_n_type)

1466 Diag

(AttrLoc, diag::warn_attribute_return_pointers_refs_only)

1472 const auto

*FuncDecl = cast<FunctionDecl>(

);

1482

<< FuncDecl->getParamDecl(Idx.

getASTIndex

())->getSourceRange();

1492 if

(AttrName.size() > 4 && AttrName.starts_with(

"__"

) &&

1493

AttrName.ends_with(

"__"

)) {

1494

AttrName = AttrName.drop_front(2).drop_back(2);

1510

(AL.

(), diag::err_attribute_argument_n_type)

1516

OwnershipAttr::OwnershipKind K =

1517

OwnershipAttr(S.

, AL,

nullptr

, 0).getOwnKind();

1521 case

OwnershipAttr::Takes:

1522 case

OwnershipAttr::Holds:

1524

(AL.

(), diag::err_attribute_too_few_arguments) << AL << 2;

1528 case

OwnershipAttr::Returns:

1530

(AL.

(), diag::err_attribute_too_many_arguments) << AL << 1;

1538 if

(K == OwnershipAttr::Returns &&

1540

(AL.

(), diag::err_ownership_takes_return_type) << AL;

1546

StringRef ModuleName =

Module

->getName();

1552 for

(

unsigned

i = 1; i < AL.

(); ++i) {

1562 case

OwnershipAttr::Takes:

1563 case

OwnershipAttr::Holds:

1567 case

OwnershipAttr::Returns:

1573

(AL.

(), diag::err_ownership_type) << AL << Err

1582 if

(I->getOwnKind() != K && llvm::is_contained(I->args(), Idx)) {

1583

(AL.

(), diag::err_attributes_are_not_compatible)

1586

I->isRegularKeywordAttribute());

1588

}

else if

(K == OwnershipAttr::Returns &&

1589

I->getOwnKind() == OwnershipAttr::Returns) {

1592 if

(!llvm::is_contained(I->args(), Idx)) {

1593

(I->getLocation(), diag::err_ownership_returns_index_mismatch)

1594

<< I->args_begin()->getSourceIndex();

1596

(AL.

(), diag::note_ownership_returns_index_mismatch)

1600

}

else if

(K == OwnershipAttr::Takes &&

1601

I->getOwnKind() == OwnershipAttr::Takes) {

1602 if

(I->getModule()->getName() != ModuleName) {

1603

(I->getLocation(), diag::err_ownership_takes_class_mismatch)

1604

<< I->getModule()->getName();

1605

(AL.

(), diag::note_ownership_takes_class_mismatch)

1612

OwnershipArgs.push_back(Idx);

1615 ParamIdx

*Start = OwnershipArgs.data();

1616 unsigned

Size = OwnershipArgs.size();

1617

llvm::array_pod_sort(Start, Start + Size);

1625

(AL.

(), diag::err_attribute_wrong_number_arguments) << AL << 1;

1640 if

(!Ctx->isFileContext()) {

1641

(AL.

(), diag::err_attribute_weakref_not_global_context)

1642

<< cast<NamedDecl>(

);

1686

std::unique_ptr<char, llvm::FreeDeleter> Demangled;

1688

Demangled.reset(llvm::itaniumDemangle(Str,

false

));

1697 if

(!isa<FunctionDecl>(ND) && !isa<VarDecl>(ND))

1699 if

(MC->shouldMangleDeclName(ND)) {

1700

llvm::raw_svector_ostream Out(Name);

1704

Name = ND->getIdentifier()->getName();

1718 const auto

*FD = cast<FunctionDecl>(

);

1720

(AL.

(), diag::err_alias_is_definition) << FD << 1;

1734

(AL.

(), diag::err_alias_not_supported_on_darwin);

1742

(AL.

(), diag::err_alias_not_supported_on_nvptx);

1746 if

(

const auto

*FD = dyn_cast<FunctionDecl>(

)) {

1748

(AL.

(), diag::err_alias_is_definition) << FD << 0;

1752 const auto

*VD = cast<VarDecl>(

);

1753 if

(VD->isThisDeclarationADefinition() && VD->isExternallyVisible()) {

1754

(AL.

(), diag::err_alias_is_definition) << VD << 0;

1771 if

(Model !=

"global-dynamic"

&& Model !=

"local-dynamic" 1772

&& Model !=

"initial-exec"

&& Model !=

"local-exec"

) {

1773

(LiteralLoc, diag::err_attr_tlsmodel_arg);

1787

(AL.

(), diag::warn_attribute_return_pointers_only)

1795 if

(checkAttrMutualExclusion<CPUSpecificAttr>(S,

, AL))

1798 if

(

const auto

<CPUDispatchAttr>()) {

1799

(AL.

(), diag::err_disallowed_duplicate_attribute) << AL;

1800

(

->getLocation(), diag::note_conflicting_attribute);

1803

}

else if

(AL.

getParsedKind

() == ParsedAttr::AT_CPUSpecific) {

1804 if

(checkAttrMutualExclusion<CPUDispatchAttr>(S,

, AL))

1807 if

(

const auto

<CPUSpecificAttr>()) {

1808

(AL.

(), diag::err_disallowed_duplicate_attribute) << AL;

1809

(

->getLocation(), diag::note_conflicting_attribute);

1816 if

(

const auto

*MD = dyn_cast<CXXMethodDecl>(

)) {

1817 if

(MD->getParent()->isLambda()) {

1818

(AL.

(), diag::err_attribute_dll_lambda) << AL;

1829

(AL.

(), diag::err_attribute_argument_type)

1835

StringRef CPUName = CPUArg->

().trim();

1838

(CPUArg->

, diag::err_invalid_cpu_specific_dispatch_value)

1839

<< CPUName << (AL.

() == ParsedAttr::AT_CPUDispatch);

1845 return Target

.CPUSpecificManglingCharacter(CPUName) ==

1848

(AL.

(), diag::warn_multiversion_duplicate_entries);

1851

CPUs.push_back(CPUArg->

);

1855 if

(AL.

() == ParsedAttr::AT_CPUSpecific)

1857

CPUSpecificAttr(S.

, AL, CPUs.data(), CPUs.size()));

1860

CPUDispatchAttr(S.

, AL, CPUs.data(), CPUs.size()));

1865

(AL.

(), diag::err_attribute_not_supported_in_lang)

1876 const auto

&Arch = Triple.getArch();

1877 if

(Arch != llvm::Triple::x86 &&

1878

(Arch != llvm::Triple::arm && Arch != llvm::Triple::thumb)) {

1879

(AL.

(), diag::err_attribute_not_supported_on_arch)

1880

<< AL << Triple.getArchName();

1886 if

(S.

().MSVCCompat && isa<CXXMethodDecl>(

)) {

1887

(AL.

(), diag::err_attribute_wrong_decl_type)

1899 if

(!isa<ObjCMethodDecl>(

)) {

1900

(Attrs.

(), diag::warn_attribute_wrong_decl_type)

1926

(Attrs.

(), diag::warn_nocf_check_attribute_ignored);

1928

handleSimpleAttribute<AnyX86NoCfCheckAttr>(S,

, Attrs);

1944

? diag::err_keyword_not_supported_on_target

1945

: diag::warn_unknown_attribute_ignored)

1963

? diag::err_attribute_wrong_decl_type

1964

: diag::warn_attribute_wrong_decl_type)

2000 if

(VecReturnAttr *A =

<VecReturnAttr>()) {

2001

(AL.

(), diag::err_repeat_attribute) << A;

2005 const auto

*R = cast<RecordDecl>(

);

2008 if

(!isa<CXXRecordDecl>(R)) {

2009

(AL.

(), diag::err_attribute_vecreturn_only_vector_member);

2013 if

(!cast<CXXRecordDecl>(R)->isPOD()) {

2014

(AL.

(), diag::err_attribute_vecreturn_only_pod_record);

2018 for

(

const auto

*I : R->fields()) {

2019 if

((count == 1) || !I->getType()->isVectorType()) {

2020

(AL.

(), diag::err_attribute_vecreturn_only_vector_member);

2031 if

(isa<ParmVarDecl>(

)) {

2036

diag::err_carries_dependency_param_not_function_decl);

2049 if

(!S.

().CPlusPlus17 && IsCXX17Attr)

2050

(AL.

(), diag::ext_cxx17_attr) << AL;

2056

uint32_t priority = ConstructorAttr::DefaultPriority;

2058

(AL.

(), diag::err_hlsl_init_priority_unsupported);

2069

uint32_t priority = DestructorAttr::DefaultPriority;

2077template

typename

AttrTy>

2089

VersionTuple Introduced,

2090

VersionTuple Deprecated,

2091

VersionTuple Obsoleted) {

2092

StringRef PlatformName

2093

= AvailabilityAttr::getPrettyPlatformName(Platform->

());

2094 if

(PlatformName.empty())

2095

PlatformName = Platform->

();

2099 if

(!Introduced.empty() && !Deprecated.empty() &&

2100

!(Introduced <= Deprecated)) {

2102

<< 1 << PlatformName << Deprecated.getAsString()

2103

<< 0 << Introduced.getAsString();

2107 if

(!Introduced.empty() && !Obsoleted.empty() &&

2108

!(Introduced <= Obsoleted)) {

2110

<< 2 << PlatformName << Obsoleted.getAsString()

2111

<< 0 << Introduced.getAsString();

2115 if

(!Deprecated.empty() && !Obsoleted.empty() &&

2116

!(Deprecated <= Obsoleted)) {

2118

<< 2 << PlatformName << Obsoleted.getAsString()

2119

<< 1 << Deprecated.getAsString();

2131 bool

BeforeIsOkay) {

2132 if

(

.empty() || Y.empty())

2138 if

(BeforeIsOkay &&

< Y)

2146 bool Implicit

, VersionTuple Introduced, VersionTuple Deprecated,

2147

VersionTuple Obsoleted,

bool

IsUnavailable, StringRef Message,

2150

VersionTuple MergedIntroduced = Introduced;

2151

VersionTuple MergedDeprecated = Deprecated;

2152

VersionTuple MergedObsoleted = Obsoleted;

2153 bool

FoundAny =

false

;

2154 bool

OverrideOrImpl =

false

;

2158

OverrideOrImpl =

false

;

2164

OverrideOrImpl =

true

;

2170 for

(

unsigned

i = 0, e = Attrs.size(); i != e;) {

2171 const auto

*OldAA = dyn_cast<AvailabilityAttr>(Attrs[i]);

2178 if

(OldPlatform != Platform) {

2184 if

(OldEnvironment != Environment) {

2192 if

(OldAA->getPriority() <

Priority

)

2198 if

(OldAA->getPriority() >

Priority

) {

2199

Attrs.erase(Attrs.begin() + i);

2205

VersionTuple OldIntroduced = OldAA->getIntroduced();

2206

VersionTuple OldDeprecated = OldAA->getDeprecated();

2207

VersionTuple OldObsoleted = OldAA->getObsoleted();

2208 bool

OldIsUnavailable = OldAA->getUnavailable();

2210 if

(OldIntroduced, Introduced, OverrideOrImpl) ||

2211

(Deprecated, OldDeprecated, OverrideOrImpl) ||

2212

(Obsoleted, OldObsoleted, OverrideOrImpl) ||

2213

!(OldIsUnavailable == IsUnavailable ||

2214

(OverrideOrImpl && !OldIsUnavailable && IsUnavailable))) {

2215 if

(OverrideOrImpl) {

2217

VersionTuple FirstVersion;

2218

VersionTuple SecondVersion;

2219 if

(OldIntroduced, Introduced, OverrideOrImpl)) {

2221

FirstVersion = OldIntroduced;

2222

SecondVersion = Introduced;

2223

}

else if

(Deprecated, OldDeprecated, OverrideOrImpl)) {

2225

FirstVersion = Deprecated;

2226

SecondVersion = OldDeprecated;

2227

}

else if

(Obsoleted, OldObsoleted, OverrideOrImpl)) {

2229

FirstVersion = Obsoleted;

2230

SecondVersion = OldObsoleted;

2234 Diag

(OldAA->getLocation(),

2235

diag::warn_mismatched_availability_override_unavail)

2236

<< AvailabilityAttr::getPrettyPlatformName(Platform->

())

2247 Diag

(OldAA->getLocation(),

2248

diag::warn_mismatched_availability_override)

2250

<< AvailabilityAttr::getPrettyPlatformName(Platform->

())

2251

<< FirstVersion.getAsString() << SecondVersion.getAsString()

2255 Diag

(CI.

(), diag::note_overridden_method);

2257 Diag

(CI.

(), diag::note_protocol_method);

2259 Diag

(OldAA->getLocation(), diag::warn_mismatched_availability);

2260 Diag

(CI.

(), diag::note_previous_attribute);

2263

Attrs.erase(Attrs.begin() + i);

2268

VersionTuple MergedIntroduced2 = MergedIntroduced;

2269

VersionTuple MergedDeprecated2 = MergedDeprecated;

2270

VersionTuple MergedObsoleted2 = MergedObsoleted;

2272 if

(MergedIntroduced2.empty())

2273

MergedIntroduced2 = OldIntroduced;

2274 if

(MergedDeprecated2.empty())

2275

MergedDeprecated2 = OldDeprecated;

2276 if

(MergedObsoleted2.empty())

2277

MergedObsoleted2 = OldObsoleted;

2280

MergedIntroduced2, MergedDeprecated2,

2281

MergedObsoleted2)) {

2282

Attrs.erase(Attrs.begin() + i);

2287

MergedIntroduced = MergedIntroduced2;

2288

MergedDeprecated = MergedDeprecated2;

2289

MergedObsoleted = MergedObsoleted2;

2295

MergedIntroduced == Introduced &&

2296

MergedDeprecated == Deprecated &&

2297

MergedObsoleted == Obsoleted)

2303

MergedDeprecated, MergedObsoleted) &&

2305 auto

*Avail = ::new (

) AvailabilityAttr(

2306 Context

, CI, Platform, Introduced, Deprecated, Obsoleted, IsUnavailable,

2307

Message, IsStrict, Replacement,

Priority

, Environment);

2315 if

(isa<UsingDecl, UnresolvedUsingTypenameDecl, UnresolvedUsingValueDecl>(

2327 if

(AvailabilityAttr::getPrettyPlatformName(II->

()).empty())

2328

(Platform->

, diag::warn_availability_unknown_platform)

2329

<< Platform->

;

2331 auto

*ND = dyn_cast<NamedDecl>(

);

2341 if

(

const auto

*SE = dyn_cast_if_present<StringLiteral>(AL.

getMessageExpr

()))

2342

Str = SE->getString();

2343

StringRef Replacement;

2344 if

(

const auto

*SE =

2346

Replacement = SE->getString();

2348 if

(II->

isStr

(

"swift"

)) {

2350

(!IsUnavailable && !Deprecated.

isValid

())) {

2352

diag::warn_availability_swift_unavailable_deprecated_only);

2357 if

(II->

isStr

(

"fuchsia"

)) {

2358

std::optional<unsigned>

Min

, Sub;

2359 if

((

Min

= Introduced.

.getMinor()) ||

2360

(Sub = Introduced.

.getSubminor())) {

2361

(AL.

(), diag::warn_availability_fuchsia_unavailable_minor);

2376 if

(EnvironmentLoc) {

2378

IIEnvironment = EnvironmentLoc->

;

2379 if

(AvailabilityAttr::getEnvironmentType(

2381

llvm::Triple::EnvironmentType::UnknownEnvironment)

2382

(EnvironmentLoc->

, diag::warn_availability_unknown_environment)

2383

<< EnvironmentLoc->

;

2385

(EnvironmentLoc->

, diag::err_availability_unexpected_parameter)

2386

"environment"

2392

Obsoleted.

, IsUnavailable, Str, IsStrict, Replacement,

2401 if

(II->

() ==

"ios"

)

2403 else if

(II->

() ==

"ios_app_extension"

)

2408 const auto

*IOSToWatchOSMapping =

2413 auto

adjustWatchOSVersion =

2414

[IOSToWatchOSMapping](VersionTuple Version) -> VersionTuple {

2415 if

(Version.empty())

2417 auto

MinimumWatchOSVersion = VersionTuple(2, 0);

2419 if

(IOSToWatchOSMapping) {

2420 if

(

auto

MappedVersion = IOSToWatchOSMapping->map(

2421

Version, MinimumWatchOSVersion, std::nullopt)) {

2422 return

*MappedVersion;

2426 auto

Major = Version.getMajor();

2427 auto

NewMajor = Major >= 9 ? Major - 7 : 0;

2428 if

(NewMajor >= 2) {

2429 if

(Version.getMinor()) {

2430 if

(Version.getSubminor())

2431 return

VersionTuple(NewMajor, *Version.getMinor(),

2432

*Version.getSubminor());

2434 return

VersionTuple(NewMajor, *Version.getMinor());

2436 return

VersionTuple(NewMajor);

2439 return

MinimumWatchOSVersion;

2442 auto

NewIntroduced = adjustWatchOSVersion(Introduced.

);

2443 auto

NewDeprecated = adjustWatchOSVersion(Deprecated.

);

2444 auto

NewObsoleted = adjustWatchOSVersion(Obsoleted.

);

2447

ND, AL, NewII,

true

, NewIntroduced, NewDeprecated,

2448

NewObsoleted, IsUnavailable, Str, IsStrict, Replacement,

2458 if

(II->

() ==

"ios"

)

2460 else if

(II->

() ==

"ios_app_extension"

)

2465 const auto

*IOSToTvOSMapping =

2470 auto

AdjustTvOSVersion =

2471

[IOSToTvOSMapping](VersionTuple Version) -> VersionTuple {

2472 if

(Version.empty())

2475 if

(IOSToTvOSMapping) {

2476 if

(

auto

MappedVersion = IOSToTvOSMapping->map(

2477

Version, VersionTuple(0, 0), std::nullopt)) {

2478 return

*MappedVersion;

2484 auto

NewIntroduced = AdjustTvOSVersion(Introduced.

);

2485 auto

NewDeprecated = AdjustTvOSVersion(Deprecated.

);

2486 auto

NewObsoleted = AdjustTvOSVersion(Obsoleted.

);

2489

ND, AL, NewII,

true

, NewIntroduced, NewDeprecated,

2490

NewObsoleted, IsUnavailable, Str, IsStrict, Replacement,

2497

llvm::Triple::IOS &&

2499 auto

GetSDKInfo = [&]() {

2506 if

(II->

() ==

"ios"

)

2508 else if

(II->

() ==

"ios_app_extension"

)

2511 auto

MinMacCatalystVersion = [](

const

VersionTuple &

) {

2514 if

(

.getMajor() < 13 ||

2515

(

.getMajor() == 13 &&

.getMinor() && *

.getMinor() < 1))

2516 return

VersionTuple(13, 1);

2520

ND, AL, NewII,

true

2521

MinMacCatalystVersion(Introduced.

2522

MinMacCatalystVersion(Deprecated.

2523

MinMacCatalystVersion(Obsoleted.

), IsUnavailable, Str,

2528

}

else if

(II->

() ==

"macos"

&& GetSDKInfo() &&

2529

(!Introduced.

.empty() || !Deprecated.

.empty() ||

2530

!Obsoleted.

.empty())) {

2531 if

(

const auto

*MacOStoMacCatalystMapping =

2532

GetSDKInfo()->getVersionMapping(

2539 auto

RemapMacOSVersion =

2540

[&](

const

VersionTuple &

) -> std::optional<VersionTuple> {

2542 return

std::nullopt;

2544 if

(

.getMajor() == 100000)

2545 return

VersionTuple(100000);

2547 return

MacOStoMacCatalystMapping->map(

, VersionTuple(13, 1),

2550

std::optional<VersionTuple> NewIntroduced =

2551

RemapMacOSVersion(Introduced.

2553

RemapMacOSVersion(Deprecated.

2555

RemapMacOSVersion(Obsoleted.

);

2556 if

(NewIntroduced || NewDeprecated || NewObsoleted) {

2557 auto

VersionOrEmptyVersion =

2558

[](

const

std::optional<VersionTuple> &

) -> VersionTuple {

2559 return V

? *

: VersionTuple();

2562

ND, AL, NewII,

true

2563

VersionOrEmptyVersion(NewIntroduced),

2564

VersionOrEmptyVersion(NewDeprecated),

2565

VersionOrEmptyVersion(NewObsoleted),

false

, Str,

2584 if

(

const auto

*SE = dyn_cast_if_present<StringLiteral>(AL.

(0)))

2586

StringRef DefinedIn;

2587 if

(

const auto

*SE = dyn_cast_if_present<StringLiteral>(AL.

(1)))

2588

DefinedIn = SE->getString();

2589 bool

IsGeneratedDeclaration = AL.

getArgAsIdent

(2) !=

nullptr

;

2591 if

(

const auto

*SE = dyn_cast_if_present<StringLiteral>(AL.

(3)))

2592

USR = SE->getString();

2600 typename

T::VisibilityType value) {

2603 typename

T::VisibilityType existingValue = existingAttr->

getVisibility

();

2604 if

(existingValue == value)

2606

(existingAttr->getLocation(), diag::err_mismatched_visibility);

2607

(CI.

(), diag::note_previous_attribute);

2615

VisibilityAttr::VisibilityType Vis) {

2616

return ::mergeVisibilityAttr<VisibilityAttr>(*

this

, CI, Vis);

2619

TypeVisibilityAttr *

2621

TypeVisibilityAttr::VisibilityType Vis) {

2622

return ::mergeVisibilityAttr<TypeVisibilityAttr>(*

this

, CI, Vis);

2626 bool

isTypeVisibility) {

2628 if

(isa<TypedefNameDecl>(

)) {

2634 if

(isTypeVisibility && !(isa<TagDecl>(

) || isa<ObjCInterfaceDecl>(

) ||

2635

isa<NamespaceDecl>(

))) {

2647

VisibilityAttr::VisibilityType

;

2648 if

(!VisibilityAttr::ConvertStrToVisibilityType(TypeStr,

)) {

2649

(LiteralLoc, diag::warn_attribute_type_not_supported) << AL

2656 if

(

== VisibilityAttr::Protected &&

2658

(AL.

(), diag::warn_attribute_protected_visibility);

2659 type

= VisibilityAttr::Default;

2663 if

(isTypeVisibility) {

2665 D

, AL, (TypeVisibilityAttr::VisibilityType)

);

2674 unsigned

sentinel = (

)SentinelAttr::DefaultSentinel;

2677

std::optional<llvm::APSInt> Idx = llvm::APSInt(32);

2679

(AL.

(), diag::err_attribute_argument_n_type)

2684 if

(Idx->isSigned() && Idx->isNegative()) {

2685

(AL.

(), diag::err_attribute_sentinel_less_than_zero)

2690

sentinel = Idx->getZExtValue();

2693 unsigned

nullPos = (

)SentinelAttr::DefaultNullPos;

2696

std::optional<llvm::APSInt> Idx = llvm::APSInt(32);

2698

(AL.

(), diag::err_attribute_argument_n_type)

2702

nullPos = Idx->getZExtValue();

2704 if

((Idx->isSigned() && Idx->isNegative()) || nullPos > 1) {

2707

(AL.

(), diag::err_attribute_sentinel_not_zero_or_one)

2713 if

(

const auto

*FD = dyn_cast<FunctionDecl>(

)) {

2715 if

(isa<FunctionNoProtoType>(FT)) {

2716

(AL.

(), diag::warn_attribute_sentinel_named_arguments);

2720 if

(!cast<FunctionProtoType>(FT)->isVariadic()) {

2721

(AL.

(), diag::warn_attribute_sentinel_not_variadic) << 0;

2724

}

else if

(

const auto

*MD = dyn_cast<ObjCMethodDecl>(

)) {

2725 if

(!MD->isVariadic()) {

2726

(AL.

(), diag::warn_attribute_sentinel_not_variadic) << 0;

2729

}

else if

(

const auto

*BD = dyn_cast<BlockDecl>(

)) {

2730 if

(!BD->isVariadic()) {

2731

(AL.

(), diag::warn_attribute_sentinel_not_variadic) << 1;

2734

}

else if

(

const auto

= dyn_cast<VarDecl>(

)) {

2742 if

(!cast<FunctionProtoType>(FT)->isVariadic()) {

2744

(AL.

(), diag::warn_attribute_sentinel_not_variadic) << m;

2748

(AL.

(), diag::warn_attribute_wrong_decl_type)

2754

(AL.

(), diag::warn_attribute_wrong_decl_type)

2765

!isa<CXXConstructorDecl>(

)) {

2766

(AL.

(), diag::warn_attribute_void_function_method) << AL << 0;

2769 if

(

const auto

*MD = dyn_cast<ObjCMethodDecl>(

))

2770 if

(MD->getReturnType()->isVoidType()) {

2771

(AL.

(), diag::warn_attribute_void_function_method) << AL << 1;

2779 if

(isa<VarDecl>(

))

2780

(AL.

(), diag::warn_attribute_wrong_decl_type)

2791 if

(LO.CPlusPlus && !LO.CPlusPlus20)

2792

(AL.

(), diag::ext_cxx20_attr) << AL;

2800

}

else if

(LO.CPlusPlus && !LO.CPlusPlus17)

2801

(AL.

(), diag::ext_cxx17_attr) << AL;

2806

isa<TypedefNameDecl>(

)) {

2807

(AL.

(), diag::warn_unused_result_typedef_unsupported_spelling)

2817 bool

isDef =

false

;

2820

(AL.

(), diag::warn_attribute_invalid_on_definition)

2822 else if

(isa<ObjCPropertyDecl>(

) || isa<ObjCMethodDecl>(

) ||

2824

(isa<ObjCInterfaceDecl>(

) || isa<EnumDecl>(

)))) {

2827

(AL.

(), diag::warn_attribute_wrong_decl_type)

2837template

typename

WorkGroupAttr>

2840 for

(

unsigned

i = 0; i < 3; ++i) {

2845 if

(WGSize[i] == 0) {

2846

(AL.

(), diag::err_attribute_argument_is_zero)

2852

WorkGroupAttr *Existing =

<WorkGroupAttr>();

2853 if

(Existing && !(Existing->getXDim() == WGSize[0] &&

2854

Existing->getYDim() == WGSize[1] &&

2855

Existing->getZDim() == WGSize[2]))

2856

(AL.

(), diag::warn_duplicate_attribute) << AL;

2859

WorkGroupAttr(S.

, AL, WGSize[0], WGSize[1], WGSize[2]));

2864

(AL.

(), diag::err_attribute_wrong_number_arguments) << AL << 1;

2870

assert(ParmTSI &&

"no type source info for attribute argument"

);

2875

(AL.

(), diag::err_attribute_invalid_argument) << 2 << AL;

2879 if

(VecTypeHintAttr *A =

<VecTypeHintAttr>()) {

2881

(AL.

(), diag::warn_duplicate_attribute) << AL;

2893 if

(

const auto

*FD = dyn_cast<FunctionDecl>(

)) {

2898 if

(SectionAttr *ExistingAttr =

<SectionAttr>()) {

2899 if

(ExistingAttr->getName() == Name)

2901 Diag

(ExistingAttr->getLocation(), diag::warn_mismatched_section)

2903 Diag

(CI.

(), diag::note_previous_attribute);

2911 return

llvm::Error::success();

2914

StringRef Segment, Section;

2915 unsigned

TAA, StubSize;

2917 return

llvm::MCSectionMachO::ParseSectionSpecifier(SecName, Segment, Section,

2918

TAA, HasTAA, StubSize);

2923 Diag

(LiteralLoc, diag::err_attribute_section_invalid_for_target)

2948

cast<NamedDecl>(

));

2959

llvm::CodeModel::Model CM;

2960 if

(!CodeModelAttr::ConvertStrToModel(Str, CM)) {

2961

(LiteralLoc, diag::err_attr_codemodel_arg) << Str;

2971

StringRef CodeSegName) {

2973

(LiteralLoc, diag::err_attribute_section_invalid_for_target)

2985 if

(

const auto

*FD = dyn_cast<FunctionDecl>(

)) {

2989 if

(

const auto

*ExistingAttr =

<CodeSegAttr>()) {

2990 if

(ExistingAttr->getName() == Name)

2992 Diag

(ExistingAttr->getLocation(), diag::warn_mismatched_section)

2994 Diag

(CI.

(), diag::note_previous_attribute);

3007 if

(

const auto

*ExistingAttr =

<CodeSegAttr>()) {

3008 if

(!ExistingAttr->isImplicit()) {

3010

ExistingAttr->getName() == Str

3011

? diag::warn_duplicate_codeseg_attribute

3012

: diag::err_conflicting_codeseg_attribute);

3022 enum

FirstParam { Unsupported, Duplicate,

Unknown

};

3023 enum

SecondParam {

, CPU, Tune };

3025 if

(AttrStr.contains(

"fpmath="

))

3026 return Diag

(LiteralLoc, diag::warn_unsupported_target_attribute)

3027

<< Unsupported <<

"fpmath="

;

3031

AttrStr.contains(

"tune="

))

3032 return Diag

(LiteralLoc, diag::warn_unsupported_target_attribute)

3033

<< Unsupported <<

"tune="

;

3038 if

(!ParsedAttrs.

CPU

.empty() &&

3040 return Diag

(LiteralLoc, diag::warn_unsupported_target_attribute)

3043 if

(!ParsedAttrs.

Tune

.empty() &&

3045 return Diag

(LiteralLoc, diag::warn_unsupported_target_attribute)

3050 return Diag

(LiteralLoc, diag::err_duplicate_target_attribute)

3052 for

(

const auto

&Feature : ParsedAttrs.

) {

3053

StringRef CurFeature = Feature;

3054 if

(!CurFeature.starts_with(

'+'

) && !CurFeature.starts_with(

'-'

))

3055 return Diag

(LiteralLoc, diag::warn_unsupported_target_attribute)

3056

<< Unsupported <<

<< AttrStr <<

;

3061 return Diag

(LiteralLoc, diag::warn_unsupported_target_attribute)

3064 for

(

const auto

&Feature : ParsedAttrs.

) {

3065 auto

CurFeature = StringRef(Feature).drop_front();

3067 return Diag

(LiteralLoc, diag::warn_unsupported_target_attribute)

3068

<< Unsupported <<

<< CurFeature <<

;

3077 if

(DiagMsg.empty())

3078 return Diag

(LiteralLoc, diag::warn_unsupported_target_attribute)

3079

<< Unsupported <<

"branch-protection"

;

3080 return Diag

(LiteralLoc, diag::err_invalid_branch_protection_spec)

3083 if

(!DiagMsg.empty())

3084 Diag

(LiteralLoc, diag::warn_unsupported_branch_protection_spec) << DiagMsg;

3090

StringRef AttrStr) {

3091 enum

FirstParam { Unsupported };

3092 enum

SecondParam {

};

3097

AttrStr.split(AttrStrs,

';'

);

3099 bool

HasArch =

false

;

3100 bool

HasPriority =

false

;

3101 bool

HasDefault =

false

;

3102 bool

DuplicateAttr =

false

;

3103 for

(

auto

&AttrStr : AttrStrs) {

3105 if

(AttrStr.starts_with(

"arch=+"

)) {

3107

DuplicateAttr =

true

;

3112 if

(TargetAttr.

.empty() ||

3113

llvm::any_of(TargetAttr.

, [&](

const

StringRef Ext) {

3114

return !RISCV().isValidFMVExtension(Ext);

3116 return Diag

(LiteralLoc, diag::warn_unsupported_target_attribute)

3118

}

else if

(AttrStr.starts_with(

"default"

)) {

3120

DuplicateAttr =

true

;

3122

}

else if

(AttrStr.consume_front(

"priority="

)) {

3124

DuplicateAttr =

true

;

3125

HasPriority =

true

;

3127 if

(AttrStr.getAsInteger(0, Digit))

3128 return Diag

(LiteralLoc, diag::warn_unsupported_target_attribute)

3131 return Diag

(LiteralLoc, diag::warn_unsupported_target_attribute)

3136 if

(((HasPriority || HasArch) && HasDefault) || DuplicateAttr ||

3137

(HasPriority && !HasArch))

3138 return Diag

(LiteralLoc, diag::warn_unsupported_target_attribute)

3143

AttrStr.split(Features,

"+"

);

3144 for

(

auto

&CurFeature : Features) {

3145

CurFeature = CurFeature.trim();

3146 if

(CurFeature ==

"default"

)

3149 return Diag

(LiteralLoc, diag::warn_unsupported_target_attribute)

3161

TargetVersionAttr *NewAttr =

3173

TargetAttr *NewAttr = ::new (S.

) TargetAttr(S.

, AL, Str);

3179 Decl

bool

&HasDefault,

bool

&HasCommas,

bool

&HasNotDefault,

3181 enum

FirstParam { Unsupported, Duplicate,

Unknown

};

3182 enum

SecondParam {

, CPU, Tune };

3184

HasCommas = HasCommas || Str.contains(

','

);

3187 if

(Str.size() == 0)

3188 return Diag

(LiteralLoc, diag::warn_unsupported_target_attribute)

3191

std::pair<StringRef, StringRef> Parts = {{}, Str};

3192 while

(!Parts.second.empty()) {

3193

Parts = Parts.second.split(

','

);

3194

StringRef Cur = Parts.first.trim();

3196

Literal->getLocationOfByte(Cur.data() - Literal->getString().data(),

3199 bool

DefaultIsDupe =

false

;

3200 bool

HasCodeGenImpact =

false

;

3202 return Diag

(CurLoc, diag::warn_unsupported_target_attribute)

3207 if

(Cur ==

"default"

) {

3208

DefaultIsDupe = HasDefault;

3210 if

(llvm::is_contained(StringsBuffer, Cur) || DefaultIsDupe)

3211 Diag

(CurLoc, diag::warn_target_clone_duplicate_options);

3213

StringsBuffer.push_back(Cur);

3215

std::pair<StringRef, StringRef> CurParts = {{}, Cur};

3217 while

(!CurParts.second.empty()) {

3218

CurParts = CurParts.second.split(

'+'

);

3219

StringRef CurFeature = CurParts.first.trim();

3221 Diag

(CurLoc, diag::warn_unsupported_target_attribute)

3226

HasCodeGenImpact =

true

;

3227

CurFeatures.push_back(CurFeature);

3230

llvm::sort(CurFeatures);

3232 for

(

auto

&CurFeat : CurFeatures) {

3235

Res.append(CurFeat);

3237 if

(llvm::is_contained(StringsBuffer, Res) || DefaultIsDupe)

3238 Diag

(CurLoc, diag::warn_target_clone_duplicate_options);

3239 else if

(!HasCodeGenImpact)

3242 Diag

(CurLoc, diag::warn_target_clone_no_impact_options);

3243 else if

(!Res.empty()) {

3244

StringsBuffer.push_back(Res);

3245

HasNotDefault =

true

;

3248

}

else if

(TInfo.

getTriple

().isRISCV()) {

3254 if

(!Str.starts_with(Cur))

3258

Str.split(AttrStrs,

";"

);

3260 bool

IsPriority =

false

;

3261 bool

IsDefault =

false

;

3262 for

(

auto

&AttrStr : AttrStrs) {

3264 if

(AttrStr.starts_with(

"arch=+"

)) {

3268 if

(TargetAttr.

.empty() ||

3269

llvm::any_of(TargetAttr.

, [&](

const

StringRef Ext) {

3270

return !RISCV().isValidFMVExtension(Ext);

3272 return Diag

(CurLoc, diag::warn_unsupported_target_attribute)

3274

}

else if

(AttrStr.starts_with(

"default"

)) {

3276

DefaultIsDupe = HasDefault;

3278

}

else if

(AttrStr.consume_front(

"priority="

)) {

3281 if

(AttrStr.getAsInteger(0, Digit))

3282 return Diag

(CurLoc, diag::warn_unsupported_target_attribute)

3285 return Diag

(CurLoc, diag::warn_unsupported_target_attribute)

3290 if

(IsPriority && IsDefault)

3291 return Diag

(CurLoc, diag::warn_unsupported_target_attribute)

3294 if

(llvm::is_contained(StringsBuffer, Str) || DefaultIsDupe)

3295 Diag

(CurLoc, diag::warn_target_clone_duplicate_options);

3296

StringsBuffer.push_back(Str);

3299 if

(Cur.starts_with(

"arch="

)) {

3301

Cur.drop_front(

sizeof

(

"arch="

) - 1)))

3302 return Diag

(CurLoc, diag::warn_unsupported_target_attribute)

3303

<< Unsupported << CPU << Cur.drop_front(

sizeof

(

"arch="

) - 1)

3305

}

else if

(Cur ==

"default"

) {

3306

DefaultIsDupe = HasDefault;

3310 return Diag

(CurLoc, diag::warn_unsupported_target_attribute)

3312 if

(llvm::is_contained(StringsBuffer, Cur) || DefaultIsDupe)

3313 Diag

(CurLoc, diag::warn_target_clone_duplicate_options);

3315

StringsBuffer.push_back(Cur);

3318 if

(Str.rtrim().ends_with(

","

))

3319 return Diag

(LiteralLoc, diag::warn_unsupported_target_attribute)

3331 if

(

const auto

<TargetClonesAttr>()) {

3332

(AL.

(), diag::err_disallowed_duplicate_attribute) << AL;

3333

(

->getLocation(), diag::note_conflicting_attribute);

3336 if

(checkAttrMutualExclusion<TargetClonesAttr>(S,

, AL))

3341 bool

HasCommas =

false

, HasDefault =

false

, HasNotDefault =

false

;

3343 for

(

unsigned

I = 0,

= AL.

(); I !=

; ++I) {

3350

HasDefault, HasCommas, HasNotDefault, StringsBuffer))

3353 for

(

auto

&SmallStr : StringsBuffer)

3354

Strings.push_back(SmallStr.str());

3357

(AL.

(), diag::warn_target_clone_mixed_values);

3362

Strings.push_back(

"default"

);

3366

(AL.

(), diag::err_target_clone_must_have_default);

3372 if

(

const auto

*MD = dyn_cast<CXXMethodDecl>(

)) {

3373 if

(MD->getParent()->isLambda()) {

3385

cast<FunctionDecl>(

)->setIsMultiVersion();

3386

TargetClonesAttr *NewAttr = ::new (S.

)

3387

TargetClonesAttr(S.

, AL, Strings.data(), Strings.size());

3399

MinVectorWidthAttr *Existing =

<MinVectorWidthAttr>();

3400 if

(Existing && Existing->getVectorWidth() != VecWidth) {

3401

(AL.

(), diag::warn_duplicate_attribute) << AL;

3416 if

(

auto

*DRE = dyn_cast<DeclRefExpr>(

)) {

3418

(

, diag::warn_cleanup_ext);

3419

FD = dyn_cast<FunctionDecl>(DRE->

());

3422

(

, diag::err_attribute_cleanup_arg_not_function) << 1

3426

}

else if

(

auto

*ULE = dyn_cast<UnresolvedLookupExpr>(

)) {

3427 if

(ULE->hasExplicitTemplateArgs())

3428

(

, diag::warn_cleanup_ext);

3430

NI = ULE->getNameInfo();

3432

(

, diag::err_attribute_cleanup_arg_not_function) << 2

3439

(

, diag::err_attribute_cleanup_arg_not_function) << 0;

3444

(

, diag::err_attribute_cleanup_func_must_take_one_arg)

3455

(

, diag::err_attribute_cleanup_func_arg_incompatible_type)

3456

<< NI.

() << ParamTy << Ty;

3470

, VariableReference, UnaryOperatorKind::UO_AddrOf,

3490

(AL.

(), diag::err_attribute_argument_n_type)

3495

EnumExtensibilityAttr::Kind ExtensibilityKind;

3497 if

(!EnumExtensibilityAttr::ConvertStrToKind(II->

(),

3498

ExtensibilityKind)) {

3499

(AL.

(), diag::warn_attribute_type_not_supported) << AL << II;

3504

EnumExtensibilityAttr(S.

, AL, ExtensibilityKind));

3522

(AL.

(), diag::err_format_attribute_not)

3530 if

(

auto

*OMD = dyn_cast<ObjCMethodDecl>(

))

3531 if

(

auto

Interface

= OMD->getClassInterface())

3538

(AL.

(), diag::err_format_attribute_result_not)

3539

<< (NotNSStringTy ?

"string type"

"NSString"

)

3559 return

llvm::StringSwitch<FormatAttrKind>(Format)

3566

.Cases(

"scanf"

"printf"

"printf0"

"strfmon"

SupportedFormat

)

3573

.Cases(

"gcc_diag"

"gcc_cdiag"

"gcc_cxxdiag"

"gcc_tdiag"

IgnoredFormat

)

3581

(AL.

(), diag::warn_attribute_ignored) << AL;

3586

(AL.

(), diag::err_hlsl_init_priority_unsupported);

3591

(AL.

(), diag::err_init_priority_object_attr);

3599

(AL.

(), diag::err_init_priority_object_attr);

3605

uint32_t prioritynum;

3614 if

((prioritynum < 101 || prioritynum > 65535) &&

3616

(AL.

(), diag::err_attribute_argument_out_of_range)

3625

StringRef NewUserDiagnostic) {

3626 if

(

const auto

*EA =

<ErrorAttr>()) {

3628

assert((NewAttr ==

"error"

|| NewAttr ==

"warning"

) &&

3629 "unexpected normalized full name"

);

3630 bool

Match = (EA->isError() && NewAttr ==

"error"

) ||

3631

(EA->isWarning() && NewAttr ==

"warning"

);

3633 Diag

(EA->getLocation(), diag::err_attributes_are_not_compatible)

3636

EA->isRegularKeywordAttribute());

3637 Diag

(CI.

(), diag::note_conflicting_attribute);

3640 if

(EA->getUserDiagnostic() != NewUserDiagnostic) {

3641 Diag

(CI.

(), diag::warn_duplicate_attribute) << EA;

3642 Diag

(EA->getLoc(), diag::note_previous_attribute);

3646

return ::new (

) ErrorAttr(

, CI, NewUserDiagnostic);

3654 if

(F->getType() == Format &&

3655

F->getFormatIdx() == FormatIdx &&

3656

F->getFirstArg() == FirstArg) {

3659 if

(F->getLocation().isInvalid())

3665

return ::new (

) FormatAttr(

, CI, Format, FormatIdx, FirstArg);

3672

(AL.

(), diag::err_attribute_argument_n_type)

3683

StringRef Format = II->

();

3697

(AL.

(), diag::warn_attribute_type_not_supported)

3708 if

(Idx < 1 || Idx > NumArgs) {

3709

(AL.

(), diag::err_attribute_argument_out_of_bounds)

3715 unsigned

ArgIdx = Idx - 1;

3717 if

(HasImplicitThisParam) {

3720

diag::err_format_attribute_implicit_this_format_string)

3733

(AL.

(), diag::err_format_attribute_not)

3745 if

(FirstArg != 0) {

3749

(AL.

(), diag::err_format_strftime_third_parameter)

3757 if

(FirstArg != NumArgs + 1) {

3758

(AL.

(), diag::err_attribute_argument_out_of_bounds)

3761

std::to_string(NumArgs + 1));

3766

(

getLocation

(), diag::warn_gcc_requires_variadic_function) << AL;

3767 if

(FirstArg <= Idx) {

3771

(AL.

(), diag::err_attribute_argument_out_of_bounds)

3787

(AL.

(), diag::err_callback_attribute_no_callee)

3796

assert(FD &&

"Expected a function declaration!"

);

3798

llvm::StringMap<int> NameIdxMapping;

3799

NameIdxMapping[

"__"

] = -1;

3801

NameIdxMapping[

"this"

] = 0;

3805

NameIdxMapping[PVD->getName()] = Idx++;

3807 auto

UnknownName = NameIdxMapping.end();

3810 for

(

unsigned

I = 0,

= AL.

(); I <

; ++I) {

3816 auto

It = NameIdxMapping.find(IdLoc->

());

3817 if

(It == UnknownName) {

3818

(AL.

(), diag::err_callback_attribute_argument_unknown)

3824

ArgIdx = It->second;

3831

(AL.

(), diag::err_attribute_argument_out_of_bounds)

3837 if

(ArgIdx < -1 || ArgIdx > NumArgs) {

3838

(AL.

(), diag::err_attribute_argument_out_of_bounds)

3845

llvm_unreachable(

"Unexpected ParsedAttr argument type!"

);

3848 if

(ArgIdx == 0 && !HasImplicitThisParam) {

3849

(AL.

(), diag::err_callback_implicit_this_not_available)

3856 if

(!HasImplicitThisParam && ArgIdx > 0)

3859

EncodingIndices.push_back(ArgIdx);

3862 int

CalleeIdx = EncodingIndices.front();

3866 if

(CalleeIdx < (

int

)HasImplicitThisParam) {

3867

(AL.

(), diag::err_callback_attribute_invalid_callee)

3874 const Type

*CalleeType =

3878

(AL.

(), diag::err_callback_callee_no_function_type)

3883 const Type

*CalleeFnType =

3888 const auto

*CalleeFnProtoType = dyn_cast<FunctionProtoType>(CalleeFnType);

3889 if

(!CalleeFnProtoType) {

3890

(AL.

(), diag::err_callback_callee_no_function_type)

3895 if

(CalleeFnProtoType->getNumParams() > EncodingIndices.size() - 1) {

3896

(AL.

(), diag::err_attribute_wrong_number_arguments)

3897

<< AL << (

)(EncodingIndices.size() - 1);

3901 if

(CalleeFnProtoType->getNumParams() < EncodingIndices.size() - 1) {

3902

(AL.

(), diag::err_attribute_wrong_number_arguments)

3903

<< AL << (

unsigned

)(EncodingIndices.size() - 1);

3907 if

(CalleeFnProtoType->isVariadic()) {

3913 if

(

<CallbackAttr>()) {

3919

, AL, EncodingIndices.data(), EncodingIndices.size()));

3923

StringRef ParamName) {

3926 Diag

(AL.

(), diag::err_capture_by_attribute_no_entity)

3935 bool

IsValid =

true

;

3936 for

(

unsigned

I = 0; I < N; ++I) {

3939 Diag

(

getExprLoc

(), diag::err_capture_by_attribute_argument_unknown)

3947 Diag

(IdLoc->

, diag::err_capture_by_references_itself) << IdLoc->

;

3951

ParamIdents[I] = IdLoc->

;

3952

ParamLocs[I] = IdLoc->

;

3958

LifetimeCaptureByAttr::Create(

, FakeParamIndices.data(), N, AL);

3959

CapturedBy->setArgs(ParamIdents, ParamLocs);

3966 if

(

<LifetimeCaptureByAttr>()) {

3967

(AL.

(), diag::err_capture_by_attribute_multiple)

3971 auto

*PVD = dyn_cast<ParmVarDecl>(

);

3982 if

(

auto

*A = PVD->getAttr<LifetimeCaptureByAttr>())

3984 if

(HasImplicitThisParam) {

3992 if

(

auto

*A = ATL.

getAttrAs

<LifetimeCaptureByAttr>())

3993

Attrs.push_back(

const_cast<

LifetimeCaptureByAttr *

>

(A));

3998

llvm::StringMap<int> NameIdxMapping = {

3999

{

"global"

, LifetimeCaptureByAttr::GLOBAL},

4000

{

"unknown"

, LifetimeCaptureByAttr::UNKNOWN}};

4002 if

(HasImplicitThisParam) {

4003

NameIdxMapping[

"this"

] = 0;

4007

NameIdxMapping[PVD->getName()] = Idx++;

4008 auto

DisallowReservedParams = [&](StringRef Reserved) {

4010 if

(PVD->getName() == Reserved)

4011 Diag

(PVD->getLocation(), diag::err_capture_by_param_uses_reserved_name)

4012

<< (PVD->getName() ==

"unknown"

);

4014 for

(

auto

*CapturedBy : Attrs) {

4015 const auto

&Entities = CapturedBy->getArgIdents();

4016 for

(

size_t

I = 0; I < Entities.size(); ++I) {

4017

StringRef Name = Entities[I]->getName();

4018 auto

It = NameIdxMapping.find(Name);

4019 if

(It == NameIdxMapping.end()) {

4020 auto Loc

= CapturedBy->getArgLocs()[I];

4021 if

(!HasImplicitThisParam && Name ==

"this"

)

4022 Diag

(

, diag::err_capture_by_implicit_this_not_available) <<

;

4024 Diag

(

, diag::err_capture_by_attribute_argument_unknown)

4025

<< Entities[I] <<

;

4028 if

(Name ==

"unknown"

|| Name ==

"global"

)

4029

DisallowReservedParams(Name);

4030

CapturedBy->setParamIdx(I, It->second);

4045 QualType T

= cast<ParmVarDecl>(

)->getType();

4048

(AL.

(), diag::err_called_once_attribute_wrong_type);

4058 const auto

*TD = dyn_cast<TypedefNameDecl>(

);

4059 if

(TD && TD->getUnderlyingType()->isUnionType())

4060

RD = TD->getUnderlyingType()->getAsUnionType()->getDecl();

4062

RD = dyn_cast<RecordDecl>(

);

4064 if

(!RD || !RD->

isUnion

()) {

4065

(AL.

(), diag::warn_attribute_wrong_decl_type)

4073

diag::warn_transparent_union_attribute_not_definition);

4079 if

(Field == FieldEnd) {

4080

(AL.

(), diag::warn_transparent_union_attribute_zero_fields);

4088

diag::warn_transparent_union_attribute_floating)

4097 for

(; Field != FieldEnd; ++Field) {

4098 QualType

FieldType = Field->getType();

4112

(Field->getLocation(),

4113

diag::warn_transparent_union_attribute_field_size_align)

4114

<< isSize << *Field << FieldBits;

4115 unsigned

FirstBits = isSize ? FirstSize : FirstAlign;

4117

diag::note_transparent_union_first_field_size_align)

4118

<< isSize << FirstBits;

4138

AlignValueAttr TmpAttr(

, CI,

);

4142 if

(

const auto

*TD = dyn_cast<TypedefNameDecl>(

))

4143 T

= TD->getUnderlyingType();

4144 else if

(

const auto

*VD = dyn_cast<ValueDecl>(

))

4147

llvm_unreachable(

"Unknown decl type for align_value"

);

4151 Diag

(AttrLoc, diag::warn_attribute_pointer_or_reference_only)

4157

llvm::APSInt Alignment;

4159 E

, &Alignment, diag::err_align_value_attribute_argument_not_int);

4163 if

(!Alignment.isPowerOf2()) {

4164 Diag

(AttrLoc, diag::err_alignment_not_power_of_two)

4186

diag::err_pack_expansion_without_parameter_packs);

4201

(AL.

(), diag::err_attribute_wrong_number_arguments) << AL << 1;

4213

diag::err_pack_expansion_without_parameter_packs);

4240 const

AlignedAttr &

Attr

4243 if

(isa<ParmVarDecl>(

)) {

4245

}

else if

(

const auto

*VD = dyn_cast<VarDecl>(

)) {

4248 if

(VD->isExceptionVariable())

4250

}

else if

(

const auto

*FD = dyn_cast<FieldDecl>(

)) {

4251 if

(FD->isBitField())

4253

}

else if

(

const auto

*ED = dyn_cast<EnumDecl>(

)) {

4254 if

(ED->getLangOpts().CPlusPlus)

4256

}

else if

(!isa<TagDecl>(

)) {

4257 return

(AttrLoc, diag::err_attribute_wrong_decl_type)

4262 if

(DiagKind != -1) {

4263 return

(AttrLoc, diag::err_alignas_attribute_wrong_decl_type)

4264

<< &

Attr

<< DiagKind;

4270 bool

IsPackExpansion) {

4271

AlignedAttr TmpAttr(

, CI,

true

);

4275 if

(TmpAttr.isAlignas() &&

4283 if

(

const auto

*TND = dyn_cast<TypedefNameDecl>(

)) {

4284 if

(!TND->getUnderlyingType()->isDependentType()) {

4285 Diag

(AttrLoc, diag::err_alignment_dependent_typedef_name)

4292

AlignedAttr *AA = ::new (

) AlignedAttr(

, CI,

true

);

4293

AA->setPackExpansion(IsPackExpansion);

4299

llvm::APSInt Alignment;

4301 E

, &Alignment, diag::err_aligned_attribute_argument_not_int);

4309 Diag

(AttrLoc, diag::err_attribute_aligned_too_great)

4314

uint64_t AlignVal = Alignment.getZExtValue();

4320 if

(!(TmpAttr.isAlignas() && !Alignment)) {

4321 if

(!llvm::isPowerOf2_64(AlignVal)) {

4322 Diag

(AttrLoc, diag::err_alignment_not_power_of_two)

4328 const auto

*VD = dyn_cast<VarDecl>(

);

4330 unsigned

MaxTLSAlign =

4333 if

(MaxTLSAlign && AlignVal > MaxTLSAlign &&

4335 Diag

(VD->getLocation(), diag::err_tls_var_aligned_over_maximum)

4336

<< (

)AlignVal << VD << MaxTLSAlign;

4344 const Type

*Ty = VD->getType().getTypePtr();

4346 Diag

(VD->getLocation(), diag::warn_aligned_attr_underaligned)

4347

<< VD->getType() << 16;

4352

AlignedAttr *AA = ::new (

) AlignedAttr(

, CI,

true

, ICE.

get

());

4353

AA->setPackExpansion(IsPackExpansion);

4354

AA->setCachedAlignmentValue(

4361

AlignedAttr TmpAttr(

, CI,

false

, TS);

4365 if

(TmpAttr.isAlignas() &&

4373 if

(

const auto

*TND = dyn_cast<TypedefNameDecl>(

)) {

4374 if

(!TND->getUnderlyingType()->isDependentType()) {

4375 Diag

(AttrLoc, diag::err_alignment_dependent_typedef_name)

4381

AlignedAttr *AA = ::new (

) AlignedAttr(

, CI,

false

, TS);

4382

AA->setPackExpansion(IsPackExpansion);

4387 const auto

*VD = dyn_cast<VarDecl>(

);

4388 unsigned

AlignVal = TmpAttr.getAlignment(

);

4392 const Type

*Ty = VD->getType().getTypePtr();

4395 Diag

(VD->getLocation(), diag::warn_aligned_attr_underaligned)

4396

<< VD->getType() << 16;

4401

AlignedAttr *AA = ::new (

) AlignedAttr(

, CI,

false

, TS);

4402

AA->setPackExpansion(IsPackExpansion);

4403

AA->setCachedAlignmentValue(AlignVal);

4408

assert(

hasAttrs

() &&

"no attributes on decl"

);

4411 if

(

const auto

*VD = dyn_cast<ValueDecl>(

)) {

4412

UnderlyingTy = DiagTy = VD->getType();

4415 if

(

const auto

*ED = dyn_cast<EnumDecl>(

))

4416

UnderlyingTy = ED->getIntegerType();

4425

AlignedAttr *AlignasAttr =

nullptr

;

4426

AlignedAttr *LastAlignedAttr =

nullptr

;

4429 if

(I->isAlignmentDependent())

4433

Align = std::max(Align, I->getAlignment(

));

4434

LastAlignedAttr = I;

4438 Diag

(LastAlignedAttr->getLocation(), diag::err_attribute_sizeless_type)

4439

<< LastAlignedAttr << DiagTy;

4440

}

else if

(AlignasAttr && Align) {

4443 if

(NaturalAlign > RequestedAlign)

4444 Diag

(AlignasAttr->getLocation(), diag::err_alignas_underaligned)

4480 bool

&IntegerMode,

bool

&ComplexMode,

4482

IntegerMode =

true

;

4483

ComplexMode =

false

;

4485 switch

(Str.size()) {

4505

DestWidth = Str[1] ==

'I'

? 0 : 128;

4513

DestWidth = Str[1] ==

'I'

? 0 : 128;

4516 if

(Str[1] ==

'F'

) {

4517

IntegerMode =

false

;

4518

}

else if

(Str[1] ==

'C'

) {

4519

IntegerMode =

false

;

4520

ComplexMode =

true

;

4521

}

else if

(Str[1] !=

'I'

) {

4530 else if

(Str ==

"byte"

)

4534 if

(Str ==

"pointer"

)

4538 if

(Str ==

"unwind_word"

)

4554

(AL.

(), diag::err_attribute_argument_type)

4566

StringRef Str = Name->getName();

4570 unsigned

DestWidth = 0;

4571 bool

IntegerMode =

true

;

4572 bool

ComplexMode =

false

;

4574

llvm::APInt VectorSize(64, 0);

4575 if

(Str.size() >= 4 && Str[0] ==

'V'

) {

4577 size_t

StrSize = Str.size();

4578 size_t

VectorStringLength = 0;

4579 while

((VectorStringLength + 1) < StrSize &&

4580

isdigit(Str[VectorStringLength + 1]))

4581

++VectorStringLength;

4582 if

(VectorStringLength &&

4583

!Str.substr(1, VectorStringLength).getAsInteger(10, VectorSize) &&

4584

VectorSize.isPowerOf2()) {

4586

IntegerMode, ComplexMode, ExplicitType);

4588 if

(!InInstantiation)

4589 Diag

(AttrLoc, diag::warn_vector_mode_deprecated);

4604 Diag

(AttrLoc, diag::err_machine_mode) << 0

<< Name;

4609 if

(

const auto

*TD = dyn_cast<TypedefNameDecl>(

))

4610

OldTy = TD->getUnderlyingType();

4611 else if

(

const auto

*ED = dyn_cast<EnumDecl>(

)) {

4614

OldTy = ED->getIntegerType();

4618

OldTy = cast<ValueDecl>(

)->getType();

4629

OldElemTy = VT->getElementType();

4635

VectorSize.getBoolValue()) {

4636 Diag

(AttrLoc, diag::err_enum_mode_vector_type) << Name << CI.

getRange

();

4644

!IntegralOrAnyEnumType)

4645 Diag

(AttrLoc, diag::err_mode_not_primitive);

4646 else if

(IntegerMode) {

4647 if

(!IntegralOrAnyEnumType)

4648 Diag

(AttrLoc, diag::err_mode_wrong_type);

4649

}

else if

(ComplexMode) {

4651 Diag

(AttrLoc, diag::err_mode_wrong_type);

4654 Diag

(AttrLoc, diag::err_mode_wrong_type);

4665 if

(NewElemTy.

isNull

()) {

4667 if

(!(DestWidth == 128 &&

().CUDAIsDevice))

4668 Diag

(AttrLoc, diag::err_machine_mode) << 1

<< Name;

4677 if

(VectorSize.getBoolValue()) {

4683 Diag

(AttrLoc, diag::err_complex_mode_vector_type);

4687

OldVT->getNumElements() /

4694 Diag

(AttrLoc, diag::err_mode_wrong_type);

4699 if

(

auto

*TD = dyn_cast<TypedefNameDecl>(

))

4700

TD->setModedTypeSourceInfo(TD->getTypeSourceInfo(), NewTy);

4701 else if

(

auto

*ED = dyn_cast<EnumDecl>(

))

4702

ED->setIntegerType(NewTy);

4704

cast<ValueDecl>(

)->setType(NewTy);

4716 if

(OptimizeNoneAttr *Optnone =

<OptimizeNoneAttr>()) {

4717 Diag

(CI.

(), diag::warn_attribute_ignored) << Ident;

4718 Diag

(Optnone->getLocation(), diag::note_conflicting_attribute);

4722 if

(

<AlwaysInlineAttr>())

4730 if

(

const auto

*VD = dyn_cast<VarDecl>(

)) {

4733 if

(VD->getKind() != Decl::Var) {

4734 Diag

(AL.

(), diag::warn_attribute_wrong_decl_type)

4741 if

(VD->hasLocalStorage()) {

4742 Diag

(VD->getLocation(), diag::warn_internal_linkage_local_storage);

4749

InternalLinkageAttr *

4751 if

(

const auto

*VD = dyn_cast<VarDecl>(

)) {

4754 if

(VD->getKind() != Decl::Var) {

4755 Diag

(AL.getLocation(), diag::warn_attribute_wrong_decl_type)

4756

<< &AL << AL.isRegularKeywordAttribute()

4762 if

(VD->hasLocalStorage()) {

4763 Diag

(VD->getLocation(), diag::warn_internal_linkage_local_storage);

4772 if

(OptimizeNoneAttr *Optnone =

<OptimizeNoneAttr>()) {

4773 Diag

(CI.

(), diag::warn_attribute_ignored) <<

"'minsize'"

;

4774 Diag

(Optnone->getLocation(), diag::note_conflicting_attribute);

4786 if

(AlwaysInlineAttr *Inline =

<AlwaysInlineAttr>()) {

4787 Diag

(Inline->getLocation(), diag::warn_attribute_ignored) << Inline;

4788 Diag

(CI.

(), diag::note_conflicting_attribute);

4791 if

(MinSizeAttr *MinSize =

<MinSizeAttr>()) {

4792 Diag

(MinSize->getLocation(), diag::warn_attribute_ignored) << MinSize;

4793 Diag

(CI.

(), diag::note_conflicting_attribute);

4797 if

(

<OptimizeNoneAttr>())

4804 if

(AlwaysInlineAttr *Inline =

4820 const auto

*VD = cast<VarDecl>(

);

4821 if

(VD->hasLocalStorage()) {

4822

(AL.

(), diag::err_cuda_nonstatic_constdev);

4827 if

(

auto

*A =

<CUDAConstantAttr>()) {

4828 if

(!A->isImplicit())

4836 const auto

*VD = cast<VarDecl>(

);

4839 if

(!S.

().GPURelocatableDeviceCode && VD->hasExternalStorage() &&

4840

!isa<IncompleteArrayType>(VD->getType())) {

4841

(AL.

(), diag::err_cuda_extern_shared) << VD;

4844 if

(S.

().CUDA && VD->hasLocalStorage() &&

4852 const auto

*FD = cast<FunctionDecl>(

);

4863 if

(

const auto

*Method = dyn_cast<CXXMethodDecl>(FD)) {

4864 if

(Method->isInstance()) {

4865

(Method->getBeginLoc(), diag::err_kern_is_nonstatic_method)

4869

(Method->getBeginLoc(), diag::warn_kern_is_method) << Method;

4875 if

(AL.

() == ParsedAttr::AT_NVPTXKernel)

4888 if

(

const auto

*VD = dyn_cast<VarDecl>(

)) {

4889 if

(VD->hasLocalStorage()) {

4890

(AL.

(), diag::err_cuda_nonstatic_constdev);

4895 if

(

auto

*A =

<CUDADeviceAttr>()) {

4896 if

(!A->isImplicit())

4904 if

(

const auto

*VD = dyn_cast<VarDecl>(

)) {

4905 if

(VD->hasLocalStorage()) {

4906

(AL.

(), diag::err_cuda_nonstatic_constdev);

4910 if

<HIPManagedAttr>())

4912 if

<CUDADeviceAttr>())

4926 const auto

*Fn = cast<FunctionDecl>(

);

4927 if

(!Fn->isInlineSpecified()) {

4928

(AL.

(), diag::warn_gnu_inline_attribute_requires_inline);

4933

(AL.

(), diag::warn_gnu_inline_cplusplus_without_extern);

4949 if

(!isa<ObjCMethodDecl>(

)) {

4950

(AL.

(), diag::warn_attribute_wrong_decl_type)

4956 case

ParsedAttr::AT_FastCall:

4959 case

ParsedAttr::AT_StdCall:

4962 case

ParsedAttr::AT_ThisCall:

4965 case

ParsedAttr::AT_CDecl:

4968 case

ParsedAttr::AT_Pascal:

4971 case

ParsedAttr::AT_SwiftCall:

4974 case

ParsedAttr::AT_SwiftAsyncCall:

4977 case

ParsedAttr::AT_VectorCall:

4980 case

ParsedAttr::AT_MSABI:

4983 case

ParsedAttr::AT_SysVABI:

4986 case

ParsedAttr::AT_RegCall:

4989 case

ParsedAttr::AT_Pcs: {

4990

PcsAttr::PCSType PCS;

4993

PCS = PcsAttr::AAPCS;

4996

PCS = PcsAttr::AAPCS_VFP;

4999

llvm_unreachable(

"unexpected calling convention in pcs attribute"

);

5005 case

ParsedAttr::AT_AArch64VectorPcs:

5008 case

ParsedAttr::AT_AArch64SVEPcs:

5011 case

ParsedAttr::AT_AMDGPUKernelCall:

5014 case

ParsedAttr::AT_IntelOclBicc:

5017 case

ParsedAttr::AT_PreserveMost:

5020 case

ParsedAttr::AT_PreserveAll:

5023 case

ParsedAttr::AT_M68kRTD:

5026 case

ParsedAttr::AT_PreserveNone:

5029 case

ParsedAttr::AT_RISCVVectorCC:

5033

llvm_unreachable(

"unexpected attribute kind"

);

5044

std::vector<StringRef> DiagnosticIdentifiers;

5045 for

(

unsigned

I = 0,

= AL.

(); I !=

; ++I) {

5051

DiagnosticIdentifiers.push_back(RuleName);

5054

SuppressAttr(S.

, AL, DiagnosticIdentifiers.data(),

5055

DiagnosticIdentifiers.size()));

5064 unsigned

SelectIdx = ~0

;

5070 if

(SelectIdx != ~0

) {

5071

(AL.

(), diag::err_attribute_invalid_argument)

5083 if

(AL.

() == ParsedAttr::AT_Owner) {

5084 if

(checkAttrMutualExclusion<PointerAttr>(S,

, AL))

5086 if

(

const auto

*OAttr =

<OwnerAttr>()) {

5087 const Type

*ExistingDerefType = OAttr->getDerefTypeLoc()

5088

? OAttr->getDerefType().getTypePtr()

5091

(AL.

(), diag::err_attributes_are_not_compatible)

5094

OAttr->isRegularKeywordAttribute());

5095

(OAttr->getLocation(), diag::note_conflicting_attribute);

5100

Redecl->addAttr(::new (S.

) OwnerAttr(S.

, AL, DerefTypeLoc));

5103 if

(checkAttrMutualExclusion<OwnerAttr>(S,

, AL))

5105 if

(

const auto

*PAttr =

<PointerAttr>()) {

5106 const Type

*ExistingDerefType = PAttr->getDerefTypeLoc()

5107

? PAttr->getDerefType().getTypePtr()

5110

(AL.

(), diag::err_attributes_are_not_compatible)

5113

PAttr->isRegularKeywordAttribute());

5114

(PAttr->getLocation(), diag::note_conflicting_attribute);

5119

Redecl->addAttr(::new (S.

)

5120

PointerAttr(S.

, AL, DerefTypeLoc));

5126 if

(checkAttrMutualExclusion<NoRandomizeLayoutAttr>(S,

, AL))

5128 if

<RandomizeLayoutAttr>())

5134 if

(checkAttrMutualExclusion<RandomizeLayoutAttr>(S,

, AL))

5136 if

<NoRandomizeLayoutAttr>())

5151 unsigned

ReqArgs = Attrs.

() == ParsedAttr::AT_Pcs ? 1 : 0;

5159 case

ParsedAttr::AT_CDecl:

5162 case

ParsedAttr::AT_FastCall:

5165 case

ParsedAttr::AT_StdCall:

5168 case

ParsedAttr::AT_ThisCall:

5171 case

ParsedAttr::AT_Pascal:

5174 case

ParsedAttr::AT_SwiftCall:

5177 case

ParsedAttr::AT_SwiftAsyncCall:

5180 case

ParsedAttr::AT_VectorCall:

5183 case

ParsedAttr::AT_AArch64VectorPcs:

5186 case

ParsedAttr::AT_AArch64SVEPcs:

5189 case

ParsedAttr::AT_AMDGPUKernelCall:

5192 case

ParsedAttr::AT_RegCall:

5195 case

ParsedAttr::AT_MSABI:

5199 case

ParsedAttr::AT_SysVABI:

5203 case

ParsedAttr::AT_Pcs: {

5209 if

(StrRef ==

"aapcs"

) {

5212

}

else if

(StrRef ==

"aapcs-vfp"

) {

5218 Diag

(Attrs.

(), diag::err_invalid_pcs);

5221 case

ParsedAttr::AT_IntelOclBicc:

5224 case

ParsedAttr::AT_PreserveMost:

5227 case

ParsedAttr::AT_PreserveAll:

5230 case

ParsedAttr::AT_M68kRTD:

5233 case

ParsedAttr::AT_PreserveNone:

5236 case

ParsedAttr::AT_RISCVVectorCC:

5239 default

: llvm_unreachable(

"unexpected attribute kind"

);

5252 bool

CheckHost =

false

, CheckDevice =

false

;

5253 switch

(CudaTarget) {

5256

CheckDevice =

true

;

5263

CheckDevice =

true

;

5266

llvm_unreachable(

"unexpected cuda target"

);

5268 auto

*HostTI =

LangOpts

.CUDAIsDevice ? Aux : &TI;

5269 auto

*DeviceTI =

LangOpts

.CUDAIsDevice ? &TI : Aux;

5270 if

(CheckHost && HostTI)

5273

A = DeviceTI->checkCallingConvention(CC);

5291 Diag

(Attrs.

(), diag::error_cconv_unsupported)

5296 Diag

(Attrs.

(), diag::warn_cconv_unsupported)

5301 bool

IsCXXMethod =

false

, IsVariadic =

false

;

5332 Diag

(AL.

(), diag::err_attribute_regparm_wrong_platform)

5340 Diag

(AL.

(), diag::err_attribute_regparm_invalid_number)

5352

llvm_unreachable(

"getOffloadArch is only valid for NVPTX triple"

);

5362 const

CUDALaunchBoundsAttr &AL,

5363 const unsigned

Idx) {

5372

std::optional<llvm::APSInt> I = llvm::APSInt(64);

5379 if

(!I->isIntN(32)) {

5381

toString

(*I, 10,

false

) << 32 <<

5385

(

getExprLoc

(), diag::warn_attribute_argument_n_negative)

5393 "Unexpected PerformCopyInitialization() failure."

);

5398

CUDALaunchBoundsAttr *

5400 Expr

*MinBlocks,

Expr

*MaxBlocks) {

5401

CUDALaunchBoundsAttr TmpAttr(

, CI, MaxThreads, MinBlocks, MaxBlocks);

5416 Diag

(MaxBlocks->

(), diag::warn_cuda_maxclusterrank_sm_90)

5419

MaxBlocks =

nullptr

;

5428

CUDALaunchBoundsAttr(

, CI, MaxThreads, MinBlocks, MaxBlocks);

5450

(AL.

(), diag::err_attribute_argument_n_type)

5468 unsigned

ArgumentIdxAST = ArgumentIdx.

getASTIndex

();

5471

(AL.

(), diag::err_attribute_pointers_only) << AL << 0;

5482

(AL.

(), diag::err_attribute_argument_n_type)

5490 if

(!isa<VarDecl>(

)) {

5491

(AL.

(), diag::err_attribute_wrong_decl_type)

5499

assert(MatchingCTypeLoc &&

"no type source info for attribute argument"

);

5522

(AL.

(), diag::err_aix_attr_unsupported) << AL;

5525

uint32_t Count = 0, Offset = 0;

5532 if

(Count < Offset) {

5533

(S.

getAttrLoc

(AL), diag::err_attribute_argument_out_of_range)

5539

PatchableFunctionEntryAttr(S.

, AL, Count, Offset));

5544

(AL.

(), diag::err_attribute_argument_n_type)

5551

StringRef AliasName = cast<FunctionDecl>(

)->getIdentifier()->getName();

5561

(!IsAArch64 && !IsARM && !IsRISCV && !IsHLSL)) {

5562

(AL.

(), diag::err_attribute_builtin_alias) << AL;

5573 if

(

auto

*CRD = dyn_cast<CXXRecordDecl>(

);

5574

!CRD || !(CRD->isClass() || CRD->isStruct())) {

5580

handleSimpleAttribute<TypeNullableAttr>(S,

, AL);

5585

(AL.

(), diag::err_attribute_wrong_number_arguments) << AL << 1;

5591

assert(ParmTSI &&

"no type source info for attribute argument"

);

5593

diag::err_incomplete_type);

5603

StringRef UuidAsWritten,

MSGuidDecl

*GuidDecl) {

5604 if

(

const auto

*UA =

<UuidAttr>()) {

5607 if

(!UA->getGuid().empty()) {

5608 Diag

(UA->getLocation(), diag::err_mismatched_uuid);

5609 Diag

(CI.

(), diag::note_previous_uuid);

5614

return ::new (

) UuidAttr(

, CI, UuidAsWritten, GuidDecl);

5619

(AL.

(), diag::err_attribute_not_supported_in_lang)

5624

StringRef OrigStrRef;

5631

StringRef StrRef = OrigStrRef;

5632 if

(StrRef.size() == 38 && StrRef.front() ==

'{'

&& StrRef.back() ==

'}'

)

5633

StrRef = StrRef.drop_front().drop_back();

5636 if

(StrRef.size() != 36) {

5637

(LiteralLoc, diag::err_attribute_uuid_malformed_guid);

5641 for

(

unsigned

i = 0; i < 36; ++i) {

5642 if

(i == 8 || i == 13 || i == 18 || i == 23) {

5643 if

(StrRef[i] !=

'-'

) {

5644

(LiteralLoc, diag::err_attribute_uuid_malformed_guid);

5648

(LiteralLoc, diag::err_attribute_uuid_malformed_guid);

5655

StrRef.substr(0, 8).getAsInteger(16, Parsed.

Part1

);

5656

StrRef.substr(9, 4).getAsInteger(16, Parsed.

Part2

);

5657

StrRef.substr(14, 4).getAsInteger(16, Parsed.

Part3

);

5658 for

(

unsigned

i = 0; i != 8; ++i)

5659

StrRef.substr(19 + 2 * i + (i >= 2 ? 1 : 0), 2)

5660

.getAsInteger(16, Parsed.

Part4And5

[i]);

5670

(AL.

(), diag::warn_atl_uuid_deprecated);

5679

(AL.

(), diag::err_attribute_not_supported_in_lang)

5692 const auto

*VD = cast<VarDecl>(

);

5694

(AL.

(), diag::err_thread_unsupported);

5698

(AL.

(), diag::err_declspec_thread_on_thread_variable);

5701 if

(VD->hasLocalStorage()) {

5702

(AL.

(), diag::err_thread_non_global) <<

"__declspec(thread)"

;

5710

(AL.

(), diag::warn_unknown_attribute_ignored)

5714 auto

*FD = cast<FunctionDecl>(

);

5716

(AL.

(), diag::err_ms_constexpr_cannot_be_applied)

5720 if

(

auto

*MD = dyn_cast<CXXMethodDecl>(FD)) {

5721 if

(!S.

().CPlusPlus20 && MD->isVirtual()) {

5722

(AL.

(), diag::err_ms_constexpr_cannot_be_applied)

5732 for

(

unsigned

I = 0,

= AL.

(); I !=

; ++I) {

5736

Tags.push_back(Tag);

5739 if

(

const auto

*NS = dyn_cast<NamespaceDecl>(

)) {

5740 if

(!NS->isInline()) {

5741

(AL.

(), diag::warn_attr_abi_tag_namespace) << 0;

5744 if

(NS->isAnonymousNamespace()) {

5745

(AL.

(), diag::warn_attr_abi_tag_namespace) << 1;

5749

Tags.push_back(NS->getName());

5755

Tags.erase(std::unique(Tags.begin(), Tags.end()), Tags.end());

5758

AbiTagAttr(S.

, AL, Tags.data(), Tags.size()));

5763 if

(I->getBTFDeclTag() == Tag)

5782

return ::new (

) BTFDeclTagAttr(

, AL, AL.getBTFDeclTag());

5788 case

llvm::Triple::msp430:

5791 case

llvm::Triple::mipsel:

5792 case

llvm::Triple::mips:

5795 case

llvm::Triple::m68k:

5798 case

llvm::Triple::x86:

5799 case

llvm::Triple::x86_64:

5802 case

llvm::Triple::avr:

5805 case

llvm::Triple::riscv32:

5806 case

llvm::Triple::riscv64:

5823

(AL.

(), diag::err_attribute_argument_out_of_bounds)

5838 if

(

<DLLExportAttr>()) {

5839 Diag

(CI.

(), diag::warn_attribute_ignored) <<

"'dllimport'"

;

5843 if

(

<DLLImportAttr>())

5851 if

(DLLImportAttr *Import =

<DLLImportAttr>()) {

5852 Diag

(Import->getLocation(), diag::warn_attribute_ignored) << Import;

5856 if

(

<DLLExportAttr>())

5863 if

(isa<ClassTemplatePartialSpecializationDecl>(

) &&

5869 if

(

const auto

*FD = dyn_cast<FunctionDecl>(

)) {

5879 if

(

const auto

*MD = dyn_cast<CXXMethodDecl>(

)) {

5881

MD->getParent()->isLambda()) {

5887 Attr

*NewAttr = A.

() == ParsedAttr::AT_DLLExport

5898 if

(MSInheritanceAttr *IA =

<MSInheritanceAttr>()) {

5899 if

(IA->getInheritanceModel() == Model)

5901 Diag

(IA->getLocation(), diag::err_mismatched_ms_inheritance)

5903 Diag

(CI.

(), diag::note_previous_ms_inheritance);

5907 auto

*RD = cast<CXXRecordDecl>(

);

5908 if

(RD->hasDefinition()) {

5914 if

(isa<ClassTemplatePartialSpecializationDecl>(RD)) {

5915 Diag

(CI.

(), diag::warn_ignored_ms_inheritance)

5919 if

(RD->getDescribedClassTemplate()) {

5920 Diag

(CI.

(), diag::warn_ignored_ms_inheritance)

5926

return ::new (

) MSInheritanceAttr(

, CI, BestCase);

5938

StringRef N(

"mutex"

);

5940 if

(AL.

() == ParsedAttr::AT_Capability &&

5953

AssertCapabilityAttr(S.

, AL, Args.data(), Args.size()));

5958 if

(

const auto

*ParmDecl = dyn_cast<ParmVarDecl>(

);

5982 if

(

const auto

*ParmDecl = dyn_cast<ParmVarDecl>(

);

5995 if

(

const auto

*ParmDecl = dyn_cast<ParmVarDecl>(

);

6008

RequiresCapabilityAttr *RCA = ::new (S.

)

6009

RequiresCapabilityAttr(S.

, AL, Args.data(), Args.size());

6015 if

(

const auto

*NSD = dyn_cast<NamespaceDecl>(

)) {

6016 if

(NSD->isAnonymousNamespace()) {

6017

(AL.

(), diag::warn_deprecated_anonymous_namespace);

6031

StringRef Str, Replacement;

6044

(AL.

(), diag::ext_cxx14_attr) << AL;

6050 if

(

const auto

*S = dyn_cast<VarDecl>(

))

6051 return

S->hasGlobalStorage();

6056 return

Sanitizer ==

"address"

|| Sanitizer ==

"hwaddress"

6057

Sanitizer ==

"memtag"

;

6064

std::vector<StringRef> Sanitizers;

6066 for

(

unsigned

I = 0,

= AL.

(); I !=

; ++I) {

6067

StringRef SanitizerName;

6075

SanitizerName !=

"coverage"

)

6076

(LiteralLoc, diag::warn_unknown_sanitizer_ignored) << SanitizerName;

6078

(

getLocation

(), diag::warn_attribute_type_not_supported_global)

6079

<< AL << SanitizerName;

6080

Sanitizers.push_back(SanitizerName);

6084

Sanitizers.size()));

6091

StringRef SanitizerName = llvm::StringSwitch<StringRef>(AttrName)

6092

.Case(

"no_address_safety_analysis"

"address"

)

6093

.Case(

"no_sanitize_address"

"address"

)

6094

.Case(

"no_sanitize_thread"

"thread"

)

6095

.Case(

"no_sanitize_memory"

"memory"

);

6108 unsigned

TranslatedSpellingIndex = 0;

6110

TranslatedSpellingIndex = 1;

6115

NoSanitizeAttr(S.

, Info, &SanitizerName, 1));

6130

ZeroCallUsedRegsAttr::ZeroCallUsedRegsKind Kind;

6131 if

(!ZeroCallUsedRegsAttr::ConvertStrToZeroCallUsedRegsKind(KindStr, Kind)) {

6132

(LiteralLoc, diag::warn_attribute_type_not_supported)

6142 auto

*FD = dyn_cast<FieldDecl>(

);

6152 case

ParsedAttr::AT_CountedBy:

6153

CountInBytes =

false

;

6156 case

ParsedAttr::AT_CountedByOrNull:

6157

CountInBytes =

false

;

6160 case

ParsedAttr::AT_SizedBy:

6161

CountInBytes =

true

;

6164 case

ParsedAttr::AT_SizedByOrNull:

6165

CountInBytes =

true

;

6169

llvm_unreachable(

"unexpected counted_by family attribute"

);

6176

FD->

getType

(), CountExpr, CountInBytes, OrNull);

6187

FunctionReturnThunksAttr::Kind Kind;

6188 if

(!FunctionReturnThunksAttr::ConvertStrToKind(KindStr, Kind)) {

6189

(LiteralLoc, diag::warn_attribute_type_not_supported)

6196 D

dropAttr

<FunctionReturnThunksAttr>();

6197 D

addAttr

(FunctionReturnThunksAttr::Create(S.

, Kind, AL));

6202

assert(isa<TypedefNameDecl>(

) &&

"This attribute only applies to a typedef"

);

6203

handleSimpleAttribute<AvailableOnlyInDefaultEvalMethodAttr>(S,

, AL);

6207 auto

*VDecl = dyn_cast<VarDecl>(

);

6208 if

(VDecl && !VDecl->isFunctionPointerType()) {

6209

(AL.

(), diag::warn_attribute_ignored_non_function_pointer)

6221 if

(!cast<VarDecl>(

)->hasGlobalStorage()) {

6223

<< (A.

() == ParsedAttr::AT_AlwaysDestroy);

6227 if

(A.

() == ParsedAttr::AT_AlwaysDestroy)

6228

handleSimpleAttribute<AlwaysDestroyAttr>(S,

, A);

6230

handleSimpleAttribute<NoDestroyAttr>(S,

, A);

6234

assert(cast<VarDecl>(

)->getStorageDuration() ==

SD_Automatic

6235 "uninitialized is only valid on automatic duration variables"

);

6244 if

(!isa<BlockDecl>(

)) {

6246 bool

IsKernReturnT =

false

;

6248

IsKernReturnT = (TT->getDecl()->getName() ==

"kern_return_t"

);

6253

diag::warn_mig_server_routine_does_not_return_kern_return_t);

6258

handleSimpleAttribute<MIGServerRoutineAttr>(S,

, AL);

6263 if

(

auto

*FD = dyn_cast<FunctionDecl>(

)) {

6266

(AL.

(), diag::warn_declspec_allocator_nonpointer)

6272

handleSimpleAttribute<MSAllocatorAttr>(S,

, AL);

6279 if

(

const auto

*PVD = dyn_cast<ParmVarDecl>(

)) {

6280 if

(PVD->getType()->isIntegerType()) {

6281

(AL.

(), diag::err_attribute_output_parameter)

6292template

typename

Attr>

6300template

typename

Attr>

6309

(AL.

(), diag::err_attribute_argument_type)

6314

CFGuardAttr::GuardArg Arg;

6316 if

(!CFGuardAttr::ConvertStrToGuardArg(II->

(), Arg)) {

6317

(AL.

(), diag::warn_attribute_type_not_supported) << AL << II;

6325template

typename

AttrTy>

6328 auto

I = llvm::find_if(Attrs,

6329

[Name](

const

AttrTy *A) {

6330 return

A->getTCBName() == Name;

6332 return

I == Attrs.end() ? nullptr : *I;

6335template

typename

AttrTy,

typename

ConflictingAttrTy>

6342 if

(

const

ConflictingAttrTy *ConflictingAttr =

6343

findEnforceTCBAttrByName<ConflictingAttrTy>(

, Argument)) {

6346

(AL.

(), diag::err_tcb_conflicting_attributes)

6360template

typename

AttrTy,

typename

ConflictingAttrTy>

6363

StringRef TCBName = AL.getTCBName();

6364 if

(

const

ConflictingAttrTy *ConflictingAttr =

6365

findEnforceTCBAttrByName<ConflictingAttrTy>(

, TCBName)) {

6366

(ConflictingAttr->getLoc(), diag::err_tcb_conflicting_attributes)

6367

<< ConflictingAttr->getAttrName()->getName()

6368

<< AL.getAttrName()->getName() << TCBName;

6371

(AL.getLoc(), diag::note_conflicting_attribute);

6379

return ::new(Context) AttrTy(Context, AL, AL.getTCBName());

6383 return

mergeEnforceTCBAttrImpl<EnforceTCBAttr, EnforceTCBLeafAttr>(

6388 Decl

const

EnforceTCBLeafAttr &AL) {

6389 return

mergeEnforceTCBAttrImpl<EnforceTCBLeafAttr, EnforceTCBAttr>(

6398

(AL.

(), diag::err_attribute_too_many_arguments) << AL << 4;

6403

(AL.

(), diag::err_attribute_too_few_arguments) << AL;

6408 if

(

<VTablePointerAuthenticationAttr>()) {

6409

(AL.

(), diag::err_duplicated_vtable_pointer_auth) <<

Decl

;

6413 auto

KeyType = VTablePointerAuthenticationAttr::VPtrAuthKeyType::DefaultKey;

6416 if

(!VTablePointerAuthenticationAttr::ConvertStrToVPtrAuthKeyType(

6418

(IL->

, diag::err_invalid_authentication_key) << IL->

;

6421 if

(KeyType == VTablePointerAuthenticationAttr::DefaultKey &&

6423

(AL.

(), diag::err_no_default_vtable_pointer_auth) << 0;

6427

(AL.

(), diag::err_attribute_argument_type)

6432 auto

AddressDiversityMode = VTablePointerAuthenticationAttr::

6433

AddressDiscriminationMode::DefaultAddressDiscrimination;

6437 if

(!VTablePointerAuthenticationAttr::

6438

ConvertStrToAddressDiscriminationMode(IL->

(),

6439

AddressDiversityMode)) {

6440

(IL->

, diag::err_invalid_address_discrimination) << IL->

;

6443 if

(AddressDiversityMode ==

6444

VTablePointerAuthenticationAttr::DefaultAddressDiscrimination &&

6446

(IL->

, diag::err_no_default_vtable_pointer_auth) << 1;

6450

(AL.

(), diag::err_attribute_argument_type)

6455 auto

ED = VTablePointerAuthenticationAttr::ExtraDiscrimination::

6456

DefaultExtraDiscrimination;

6460 if

(!VTablePointerAuthenticationAttr::ConvertStrToExtraDiscrimination(

6462

(IL->

, diag::err_invalid_extra_discrimination) << IL->

;

6465 if

(ED == VTablePointerAuthenticationAttr::DefaultExtraDiscrimination &&

6467

(AL.

(), diag::err_no_default_vtable_pointer_auth) << 2;

6471

(AL.

(), diag::err_attribute_argument_type)

6476

uint32_t CustomDiscriminationValue = 0;

6477 if

(ED == VTablePointerAuthenticationAttr::CustomDiscrimination) {

6479

(AL.

(), diag::err_missing_custom_discrimination) << AL << 4;

6484

(AL.

(), diag::err_attribute_too_many_arguments) << AL << 4;

6489

CustomDiscriminationValue)) {

6490

(AL.

(), diag::err_invalid_custom_discrimination);

6493

}

else if

(NumArgs > 3) {

6494

(AL.

(), diag::err_attribute_too_many_arguments) << AL << 3;

6499

, AL, KeyType, AddressDiversityMode, ED,

6500

CustomDiscriminationValue));

6516 for

(

size_t

I = 0; I < std::min(AL.

(), AttrNumArgs); ++I) {

6517 bool

IsLastAttrArg = I == (AttrNumArgs - 1);

6520 if

(IsLastAttrArg && AttrHasVariadicArg)

6527 if

(isa<PackExpansionExpr>(

))

6528 return

!(IsLastAttrArg && ArgMemberCanHoldExpr);

6555

!Options.IncludeCXX11Attributes)

6565

? (

unsigned

)diag::err_keyword_not_supported_on_target

6567

? (

unsigned

)diag::warn_unhandled_ms_attribute_ignored

6568

: (

unsigned

)diag::warn_unknown_attribute_ignored)

6580 if

(MustDelayArgs) {

6590

assert(AL.

isTypeAttr

() &&

"Non-type attribute not handled"

);

6593 if

(Options.IgnoreTypeAttributes)

6611

isa<DeclaratorDecl, TypeAliasDecl>(

)) {

6616

(AL.

(), diag::warn_type_attribute_deprecated_on_decl)

6625 if

(AL.

() == ParsedAttr::AT_Regparm) {

6638 if

(AL.

() == ParsedAttr::AT_VectorSize) {

6648 if

(AL.

() == ParsedAttr::AT_NoDeref) {

6659

(AL.

(), diag::err_attribute_invalid_on_decl)

6662 case

ParsedAttr::AT_Interrupt:

6665 case

ParsedAttr::AT_X86ForceAlignArgPointer:

6668 case

ParsedAttr::AT_ReadOnlyPlacement:

6669

handleSimpleAttribute<ReadOnlyPlacementAttr>(S,

, AL);

6671 case

ParsedAttr::AT_DLLExport:

6672 case

ParsedAttr::AT_DLLImport:

6675 case

ParsedAttr::AT_AMDGPUFlatWorkGroupSize:

6678 case

ParsedAttr::AT_AMDGPUWavesPerEU:

6681 case

ParsedAttr::AT_AMDGPUNumSGPR:

6684 case

ParsedAttr::AT_AMDGPUNumVGPR:

6687 case

ParsedAttr::AT_AMDGPUMaxNumWorkGroups:

6690 case

ParsedAttr::AT_AVRSignal:

6693 case

ParsedAttr::AT_BPFPreserveAccessIndex:

6696 case

ParsedAttr::AT_BPFPreserveStaticOffset:

6697

handleSimpleAttribute<BPFPreserveStaticOffsetAttr>(S,

, AL);

6699 case

ParsedAttr::AT_BTFDeclTag:

6702 case

ParsedAttr::AT_WebAssemblyExportName:

6705 case

ParsedAttr::AT_WebAssemblyImportModule:

6708 case

ParsedAttr::AT_WebAssemblyImportName:

6711 case

ParsedAttr::AT_IBOutlet:

6714 case

ParsedAttr::AT_IBOutletCollection:

6717 case

ParsedAttr::AT_IFunc:

6720 case

ParsedAttr::AT_Alias:

6723 case

ParsedAttr::AT_Aligned:

6726 case

ParsedAttr::AT_AlignValue:

6729 case

ParsedAttr::AT_AllocSize:

6732 case

ParsedAttr::AT_AlwaysInline:

6735 case

ParsedAttr::AT_AnalyzerNoReturn:

6738 case

ParsedAttr::AT_TLSModel:

6741 case

ParsedAttr::AT_Annotate:

6744 case

ParsedAttr::AT_Availability:

6747 case

ParsedAttr::AT_CarriesDependency:

6750 case

ParsedAttr::AT_CPUDispatch:

6751 case

ParsedAttr::AT_CPUSpecific:

6754 case

ParsedAttr::AT_Common:

6757 case

ParsedAttr::AT_CUDAConstant:

6760 case

ParsedAttr::AT_PassObjectSize:

6763 case

ParsedAttr::AT_Constructor:

6766 case

ParsedAttr::AT_Deprecated:

6769 case

ParsedAttr::AT_Destructor:

6772 case

ParsedAttr::AT_EnableIf:

6775 case

ParsedAttr::AT_Error:

6778 case

ParsedAttr::AT_ExcludeFromExplicitInstantiation:

6781 case

ParsedAttr::AT_DiagnoseIf:

6784 case

ParsedAttr::AT_DiagnoseAsBuiltin:

6787 case

ParsedAttr::AT_NoBuiltin:

6790 case

ParsedAttr::AT_ExtVectorType:

6793 case

ParsedAttr::AT_ExternalSourceSymbol:

6796 case

ParsedAttr::AT_MinSize:

6799 case

ParsedAttr::AT_OptimizeNone:

6802 case

ParsedAttr::AT_EnumExtensibility:

6805 case

ParsedAttr::AT_SYCLKernel:

6808 case

ParsedAttr::AT_SYCLKernelEntryPoint:

6811 case

ParsedAttr::AT_SYCLSpecialClass:

6812

handleSimpleAttribute<SYCLSpecialClassAttr>(S,

, AL);

6814 case

ParsedAttr::AT_Format:

6817 case

ParsedAttr::AT_FormatArg:

6820 case

ParsedAttr::AT_Callback:

6823 case

ParsedAttr::AT_LifetimeCaptureBy:

6826 case

ParsedAttr::AT_CalledOnce:

6829 case

ParsedAttr::AT_NVPTXKernel:

6830 case

ParsedAttr::AT_CUDAGlobal:

6833 case

ParsedAttr::AT_CUDADevice:

6836 case

ParsedAttr::AT_CUDAGridConstant:

6839 case

ParsedAttr::AT_HIPManaged:

6842 case

ParsedAttr::AT_GNUInline:

6845 case

ParsedAttr::AT_CUDALaunchBounds:

6848 case

ParsedAttr::AT_Restrict:

6851 case

ParsedAttr::AT_Mode:

6854 case

ParsedAttr::AT_NonNull:

6855 if

(

auto

*PVD = dyn_cast<ParmVarDecl>(

))

6860 case

ParsedAttr::AT_ReturnsNonNull:

6863 case

ParsedAttr::AT_NoEscape:

6866 case

ParsedAttr::AT_MaybeUndef:

6867

handleSimpleAttribute<MaybeUndefAttr>(S,

, AL);

6869 case

ParsedAttr::AT_AssumeAligned:

6872 case

ParsedAttr::AT_AllocAlign:

6875 case

ParsedAttr::AT_Ownership:

6878 case

ParsedAttr::AT_Naked:

6881 case

ParsedAttr::AT_NoReturn:

6884 case

ParsedAttr::AT_CXX11NoReturn:

6887 case

ParsedAttr::AT_AnyX86NoCfCheck:

6890 case

ParsedAttr::AT_NoThrow:

6892

handleSimpleAttribute<NoThrowAttr>(S,

, AL);

6894 case

ParsedAttr::AT_CUDAShared:

6897 case

ParsedAttr::AT_VecReturn:

6900 case

ParsedAttr::AT_ObjCOwnership:

6903 case

ParsedAttr::AT_ObjCPreciseLifetime:

6906 case

ParsedAttr::AT_ObjCReturnsInnerPointer:

6909 case

ParsedAttr::AT_ObjCRequiresSuper:

6912 case

ParsedAttr::AT_ObjCBridge:

6915 case

ParsedAttr::AT_ObjCBridgeMutable:

6918 case

ParsedAttr::AT_ObjCBridgeRelated:

6921 case

ParsedAttr::AT_ObjCDesignatedInitializer:

6924 case

ParsedAttr::AT_ObjCRuntimeName:

6927 case

ParsedAttr::AT_ObjCBoxable:

6930 case

ParsedAttr::AT_NSErrorDomain:

6933 case

ParsedAttr::AT_CFConsumed:

6934 case

ParsedAttr::AT_NSConsumed:

6935 case

ParsedAttr::AT_OSConsumed:

6940 case

ParsedAttr::AT_OSReturnsRetainedOnZero:

6941

handleSimpleAttributeOrDiagnose<OSReturnsRetainedOnZeroAttr>(

6943

diag::warn_ns_attribute_wrong_parameter_type,

6946 case

ParsedAttr::AT_OSReturnsRetainedOnNonZero:

6947

handleSimpleAttributeOrDiagnose<OSReturnsRetainedOnNonZeroAttr>(

6949

diag::warn_ns_attribute_wrong_parameter_type,

6952 case

ParsedAttr::AT_NSReturnsAutoreleased:

6953 case

ParsedAttr::AT_NSReturnsNotRetained:

6954 case

ParsedAttr::AT_NSReturnsRetained:

6955 case

ParsedAttr::AT_CFReturnsNotRetained:

6956 case

ParsedAttr::AT_CFReturnsRetained:

6957 case

ParsedAttr::AT_OSReturnsNotRetained:

6958 case

ParsedAttr::AT_OSReturnsRetained:

6961 case

ParsedAttr::AT_WorkGroupSizeHint:

6962

handleWorkGroupSize<WorkGroupSizeHintAttr>(S,

, AL);

6964 case

ParsedAttr::AT_ReqdWorkGroupSize:

6965

handleWorkGroupSize<ReqdWorkGroupSizeAttr>(S,

, AL);

6967 case

ParsedAttr::AT_OpenCLIntelReqdSubGroupSize:

6970 case

ParsedAttr::AT_VecTypeHint:

6973 case

ParsedAttr::AT_InitPriority:

6976 case

ParsedAttr::AT_Packed:

6979 case

ParsedAttr::AT_PreferredName:

6982 case

ParsedAttr::AT_NoSpecializations:

6985 case

ParsedAttr::AT_Section:

6988 case

ParsedAttr::AT_CodeModel:

6991 case

ParsedAttr::AT_RandomizeLayout:

6994 case

ParsedAttr::AT_NoRandomizeLayout:

6997 case

ParsedAttr::AT_CodeSeg:

7000 case

ParsedAttr::AT_Target:

7003 case

ParsedAttr::AT_TargetVersion:

7006 case

ParsedAttr::AT_TargetClones:

7009 case

ParsedAttr::AT_MinVectorWidth:

7012 case

ParsedAttr::AT_Unavailable:

7013

handleAttrWithMessage<UnavailableAttr>(S,

, AL);

7015 case

ParsedAttr::AT_OMPAssume:

7018 case

ParsedAttr::AT_ObjCDirect:

7021 case

ParsedAttr::AT_ObjCDirectMembers:

7023

handleSimpleAttribute<ObjCDirectMembersAttr>(S,

, AL);

7025 case

ParsedAttr::AT_ObjCExplicitProtocolImpl:

7028 case

ParsedAttr::AT_Unused:

7031 case

ParsedAttr::AT_Visibility:

7034 case

ParsedAttr::AT_TypeVisibility:

7037 case

ParsedAttr::AT_WarnUnusedResult:

7040 case

ParsedAttr::AT_WeakRef:

7043 case

ParsedAttr::AT_WeakImport:

7046 case

ParsedAttr::AT_TransparentUnion:

7049 case

ParsedAttr::AT_ObjCMethodFamily:

7052 case

ParsedAttr::AT_ObjCNSObject:

7055 case

ParsedAttr::AT_ObjCIndependentClass:

7058 case

ParsedAttr::AT_Blocks:

7061 case

ParsedAttr::AT_Sentinel:

7064 case

ParsedAttr::AT_Cleanup:

7067 case

ParsedAttr::AT_NoDebug:

7070 case

ParsedAttr::AT_CmseNSEntry:

7073 case

ParsedAttr::AT_StdCall:

7074 case

ParsedAttr::AT_CDecl:

7075 case

ParsedAttr::AT_FastCall:

7076 case

ParsedAttr::AT_ThisCall:

7077 case

ParsedAttr::AT_Pascal:

7078 case

ParsedAttr::AT_RegCall:

7079 case

ParsedAttr::AT_SwiftCall:

7080 case

ParsedAttr::AT_SwiftAsyncCall:

7081 case

ParsedAttr::AT_VectorCall:

7082 case

ParsedAttr::AT_MSABI:

7083 case

ParsedAttr::AT_SysVABI:

7084 case

ParsedAttr::AT_Pcs:

7085 case

ParsedAttr::AT_IntelOclBicc:

7086 case

ParsedAttr::AT_PreserveMost:

7087 case

ParsedAttr::AT_PreserveAll:

7088 case

ParsedAttr::AT_AArch64VectorPcs:

7089 case

ParsedAttr::AT_AArch64SVEPcs:

7090 case

ParsedAttr::AT_AMDGPUKernelCall:

7091 case

ParsedAttr::AT_M68kRTD:

7092 case

ParsedAttr::AT_PreserveNone:

7093 case

ParsedAttr::AT_RISCVVectorCC:

7096 case

ParsedAttr::AT_Suppress:

7099 case

ParsedAttr::AT_Owner:

7100 case

ParsedAttr::AT_Pointer:

7103 case

ParsedAttr::AT_OpenCLAccess:

7106 case

ParsedAttr::AT_OpenCLNoSVM:

7109 case

ParsedAttr::AT_SwiftContext:

7112 case

ParsedAttr::AT_SwiftAsyncContext:

7115 case

ParsedAttr::AT_SwiftErrorResult:

7118 case

ParsedAttr::AT_SwiftIndirectResult:

7121 case

ParsedAttr::AT_InternalLinkage:

7124 case

ParsedAttr::AT_ZeroCallUsedRegs:

7127 case

ParsedAttr::AT_FunctionReturnThunks:

7130 case

ParsedAttr::AT_NoMerge:

7133 case

ParsedAttr::AT_NoUniqueAddress:

7137 case

ParsedAttr::AT_AvailableOnlyInDefaultEvalMethod:

7141 case

ParsedAttr::AT_CountedBy:

7142 case

ParsedAttr::AT_CountedByOrNull:

7143 case

ParsedAttr::AT_SizedBy:

7144 case

ParsedAttr::AT_SizedByOrNull:

7149 case

ParsedAttr::AT_LayoutVersion:

7152 case

ParsedAttr::AT_Uuid:

7155 case

ParsedAttr::AT_MSInheritance:

7158 case

ParsedAttr::AT_Thread:

7161 case

ParsedAttr::AT_MSConstexpr:

7164 case

ParsedAttr::AT_HybridPatchable:

7165

handleSimpleAttribute<HybridPatchableAttr>(S,

, AL);

7169 case

ParsedAttr::AT_HLSLNumThreads:

7172 case

ParsedAttr::AT_HLSLWaveSize:

7175 case

ParsedAttr::AT_HLSLSV_GroupThreadID:

7178 case

ParsedAttr::AT_HLSLSV_GroupID:

7181 case

ParsedAttr::AT_HLSLSV_GroupIndex:

7182

handleSimpleAttribute<HLSLSV_GroupIndexAttr>(S,

, AL);

7184 case

ParsedAttr::AT_HLSLGroupSharedAddressSpace:

7185

handleSimpleAttribute<HLSLGroupSharedAddressSpaceAttr>(S,

, AL);

7187 case

ParsedAttr::AT_HLSLSV_DispatchThreadID:

7190 case

ParsedAttr::AT_HLSLPackOffset:

7193 case

ParsedAttr::AT_HLSLShader:

7196 case

ParsedAttr::AT_HLSLResourceBinding:

7199 case

ParsedAttr::AT_HLSLParamModifier:

7203 case

ParsedAttr::AT_AbiTag:

7206 case

ParsedAttr::AT_CFGuard:

7211 case

ParsedAttr::AT_AssertExclusiveLock:

7214 case

ParsedAttr::AT_AssertSharedLock:

7217 case

ParsedAttr::AT_PtGuardedVar:

7220 case

ParsedAttr::AT_NoSanitize:

7223 case

ParsedAttr::AT_NoSanitizeSpecific:

7226 case

ParsedAttr::AT_GuardedBy:

7229 case

ParsedAttr::AT_PtGuardedBy:

7232 case

ParsedAttr::AT_ExclusiveTrylockFunction:

7235 case

ParsedAttr::AT_LockReturned:

7238 case

ParsedAttr::AT_LocksExcluded:

7241 case

ParsedAttr::AT_SharedTrylockFunction:

7244 case

ParsedAttr::AT_AcquiredBefore:

7247 case

ParsedAttr::AT_AcquiredAfter:

7252 case

ParsedAttr::AT_Capability:

7253 case

ParsedAttr::AT_Lockable:

7256 case

ParsedAttr::AT_RequiresCapability:

7260 case

ParsedAttr::AT_AssertCapability:

7263 case

ParsedAttr::AT_AcquireCapability:

7266 case

ParsedAttr::AT_ReleaseCapability:

7269 case

ParsedAttr::AT_TryAcquireCapability:

7274 case

ParsedAttr::AT_Consumable:

7277 case

ParsedAttr::AT_CallableWhen:

7280 case

ParsedAttr::AT_ParamTypestate:

7283 case

ParsedAttr::AT_ReturnTypestate:

7286 case

ParsedAttr::AT_SetTypestate:

7289 case

ParsedAttr::AT_TestTypestate:

7294 case

ParsedAttr::AT_ArgumentWithTypeTag:

7297 case

ParsedAttr::AT_TypeTagForDatatype:

7302 case

ParsedAttr::AT_SwiftAsyncName:

7305 case

ParsedAttr::AT_SwiftAttr:

7308 case

ParsedAttr::AT_SwiftBridge:

7311 case

ParsedAttr::AT_SwiftError:

7314 case

ParsedAttr::AT_SwiftName:

7317 case

ParsedAttr::AT_SwiftNewType:

7320 case

ParsedAttr::AT_SwiftAsync:

7323 case

ParsedAttr::AT_SwiftAsyncError:

7328 case

ParsedAttr::AT_XRayLogArgs:

7332 case

ParsedAttr::AT_PatchableFunctionEntry:

7336 case

ParsedAttr::AT_AlwaysDestroy:

7337 case

ParsedAttr::AT_NoDestroy:

7341 case

ParsedAttr::AT_Uninitialized:

7345 case

ParsedAttr::AT_ObjCExternallyRetained:

7349 case

ParsedAttr::AT_MIGServerRoutine:

7353 case

ParsedAttr::AT_MSAllocator:

7357 case

ParsedAttr::AT_ArmBuiltinAlias:

7361 case

ParsedAttr::AT_ArmLocallyStreaming:

7362

handleSimpleAttribute<ArmLocallyStreamingAttr>(S,

, AL);

7365 case

ParsedAttr::AT_ArmNew:

7369 case

ParsedAttr::AT_AcquireHandle:

7373 case

ParsedAttr::AT_ReleaseHandle:

7374

handleHandleAttr<ReleaseHandleAttr>(S,

, AL);

7377 case

ParsedAttr::AT_UnsafeBufferUsage:

7378

handleUnsafeBufferUsage<UnsafeBufferUsageAttr>(S,

, AL);

7381 case

ParsedAttr::AT_UseHandle:

7382

handleHandleAttr<UseHandleAttr>(S,

, AL);

7385 case

ParsedAttr::AT_EnforceTCB:

7386

handleEnforceTCBAttr<EnforceTCBAttr, EnforceTCBLeafAttr>(S,

, AL);

7389 case

ParsedAttr::AT_EnforceTCBLeaf:

7390

handleEnforceTCBAttr<EnforceTCBLeafAttr, EnforceTCBAttr>(S,

, AL);

7393 case

ParsedAttr::AT_BuiltinAlias:

7397 case

ParsedAttr::AT_PreferredType:

7401 case

ParsedAttr::AT_UsingIfExists:

7402

handleSimpleAttribute<UsingIfExistsAttr>(S,

, AL);

7405 case

ParsedAttr::AT_TypeNullable:

7409 case

ParsedAttr::AT_VTablePointerAuthentication:

7417 return D

<OpenCLKernelAttr>() ||

7425 if

(AttrList.

empty

())

7436 Diag

(AttrList.

begin

()->getLoc(), diag::err_attribute_weakref_without_alias)

7437

<< cast<NamedDecl>(

);

7446 if

(!(

<OpenCLKernelAttr>() ||

7447

(

<CUDAGlobalAttr>() &&

7450 if

(

const auto

*A =

<ReqdWorkGroupSizeAttr>()) {

7455

}

else if

(

const auto

*A =

<WorkGroupSizeHintAttr>()) {

7458

}

else if

(

const auto

*A =

<VecTypeHintAttr>()) {

7461

}

else if

(

const auto

*A =

<OpenCLIntelReqdSubGroupSizeAttr>()) {

7467 if

(

const auto

*A =

<AMDGPUFlatWorkGroupSizeAttr>()) {

7471

}

else if

(

const auto

*A =

<AMDGPUWavesPerEUAttr>()) {

7475

}

else if

(

const auto

*A =

<AMDGPUNumSGPRAttr>()) {

7479

}

else if

(

const auto

*A =

<AMDGPUNumVGPRAttr>()) {

7491 if

(

<ObjCDesignatedInitializerAttr>() &&

7492

cast<ObjCMethodDecl>(

)->getMethodFamily() !=

OMF_init

) {

7494 D

dropAttr

<ObjCDesignatedInitializerAttr>();

7501 if

(AL.getKind() == ParsedAttr::AT_TransparentUnion) {

7508 if

(

<BPFPreserveAccessIndexAttr>())

7515 if

(AL.getKind() == ParsedAttr::AT_Annotate) {

7519 Diag

(AL.getLoc(), diag::err_only_annotate_after_access_spec);

7531 if

(AL.isUsedAsTypeAttr() || AL.isInvalid())

7537

(AL.getLoc(), diag::warn_unknown_attribute_ignored)

7538

<< AL << AL.getRange();

7540

(AL.getLoc(), diag::warn_attribute_not_on_decl) << AL

7550 for

(

unsigned

i = 0, e =

.getNumTypeObjects(); i != e; ++i)

7556

assert(isa<FunctionDecl>(ND) || isa<VarDecl>(ND));

7558 if

(

auto

*FD = dyn_cast<FunctionDecl>(ND)) {

7580 for

(

const auto

&AI : FT->param_types()) {

7583

Params.push_back(Param);

7585

NewFD->setParams(Params);

7587

}

else if

(

auto

*VD = dyn_cast<VarDecl>(ND)) {

7589

VD->getInnerLocStart(), VD->getLocation(), II,

7590

VD->getType(), VD->getTypeSourceInfo(),

7591

VD->getStorageClass());

7592 if

(VD->getQualifier())

7593

cast<VarDecl>(NewD)->setQualifierInfo(VD->getQualifierLoc());

7626 if

(

auto

*VD = dyn_cast<VarDecl>(

))

7627 if

(VD->isExternC())

7629 if

(

auto

*FD = dyn_cast<FunctionDecl>(

))

7637 auto

&WeakInfos = I->second;

7638 for

(

const auto

&W : WeakInfos)

7640

std::remove_reference_t<

decltype

(WeakInfos)> EmptyWeakInfos;

7641

WeakInfos.swap(EmptyWeakInfos);

7653 auto

ProcessAttributesWithSliding =

7661 if

((AL.isStandardAttributeSyntax() || AL.isAlignas()) &&

7662

AL.slidesFromDeclToDeclSpecLegacyBehavior()) {

7667

AL.diagnoseAppertainsTo(*

this

);

7682

.WithIncludeCXX11Attributes(

false

)

7683

.WithIgnoreTypeAttributes(

true

));

7692

.WithIncludeCXX11Attributes(

false

)

7693

.WithIgnoreTypeAttributes(

true

));

7711

UnavailableAttr::ImplicitReason &reason) {

7715 if

(!isa<FieldDecl>(

) && !isa<ObjCPropertyDecl>(

) &&

7716

!isa<FunctionDecl>(

))

7724 if

((isa<ObjCIvarDecl>(

) || isa<ObjCPropertyDecl>(

))) {

7727

reason = UnavailableAttr::IR_ForbiddenWeak;

7736

reason = UnavailableAttr::IR_ARCForbiddenType;

7746 auto

Reason = UnavailableAttr::IR_None;

7748

assert(Reason &&

"didn't set reason?"

);

7753 if

(

const auto

*FD = dyn_cast<FunctionDecl>(

)) {

7756 if

(FD->