clang 19.0.0git
SemaDeclAttr.cpp
Go to the documentation of this file.
1//===--- SemaDeclAttr.cpp - Declaration Attribute Handling ----------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements decl-related attribute processing.
10//
11//===----------------------------------------------------------------------===//
12
17#include "clang/AST/DeclCXX.h"
18#include "clang/AST/DeclObjC.h"
20#include "clang/AST/Expr.h"
21#include "clang/AST/ExprCXX.h"
22#include "clang/AST/Mangle.h"
24#include "clang/AST/Type.h"
26#include "clang/Basic/Cuda.h"
35#include "clang/Sema/DeclSpec.h"
38#include "clang/Sema/Lookup.h"
40#include "clang/Sema/Scope.h"
43#include "llvm/ADT/STLExtras.h"
44#include "llvm/ADT/StringExtras.h"
45#include "llvm/IR/Assumptions.h"
46#include "llvm/MC/MCSectionMachO.h"
47#include "llvm/Support/Error.h"
48#include "llvm/Support/MathExtras.h"
49#include "llvm/Support/raw_ostream.h"
50#include <optional>
51
52using namespace clang;
53using namespace sema;
54
56 enum LANG {
59 ObjC
60 };
61} // end namespace AttributeLangSupport
62
63//===----------------------------------------------------------------------===//
64// Helper functions
65//===----------------------------------------------------------------------===//
66
67/// isFunctionOrMethod - Return true if the given decl has function
68/// type (function or function-typed variable) or an Objective-C
69/// method.
70static bool isFunctionOrMethod(const Decl *D) {
71 return (D->getFunctionType() != nullptr) || isa<ObjCMethodDecl>(D);
72}
73
74/// Return true if the given decl has function type (function or
75/// function-typed variable) or an Objective-C method or a block.
76static bool isFunctionOrMethodOrBlock(const Decl *D) {
77 return isFunctionOrMethod(D) || isa<BlockDecl>(D);
78}
79
80/// Return true if the given decl has a declarator that should have
81/// been processed by Sema::GetTypeForDeclarator.
82static bool hasDeclarator(const Decl *D) {
83 // In some sense, TypedefDecl really *ought* to be a DeclaratorDecl.
84 return isa<DeclaratorDecl>(D) || isa<BlockDecl>(D) || isa<TypedefNameDecl>(D) ||
85 isa<ObjCPropertyDecl>(D);
86}
87
88/// hasFunctionProto - Return true if the given decl has a argument
89/// information. This decl should have already passed
90/// isFunctionOrMethod or isFunctionOrMethodOrBlock.
91static bool hasFunctionProto(const Decl *D) {
92 if (const FunctionType *FnTy = D->getFunctionType())
93 return isa<FunctionProtoType>(FnTy);
94 return isa<ObjCMethodDecl>(D) || isa<BlockDecl>(D);
95}
96
97/// getFunctionOrMethodNumParams - Return number of function or method
98/// parameters. It is an error to call this on a K&R function (use
99/// hasFunctionProto first).
100static unsigned getFunctionOrMethodNumParams(const Decl *D) {
101 if (const FunctionType *FnTy = D->getFunctionType())
102 return cast<FunctionProtoType>(FnTy)->getNumParams();
103 if (const auto *BD = dyn_cast<BlockDecl>(D))
104 return BD->getNumParams();
105 return cast<ObjCMethodDecl>(D)->param_size();
106}
107
109 unsigned Idx) {
110 if (const auto *FD = dyn_cast<FunctionDecl>(D))
111 return FD->getParamDecl(Idx);
112 if (const auto *MD = dyn_cast<ObjCMethodDecl>(D))
113 return MD->getParamDecl(Idx);
114 if (const auto *BD = dyn_cast<BlockDecl>(D))
115 return BD->getParamDecl(Idx);
116 return nullptr;
117}
118
119static QualType getFunctionOrMethodParamType(const Decl *D, unsigned Idx) {
120 if (const FunctionType *FnTy = D->getFunctionType())
121 return cast<FunctionProtoType>(FnTy)->getParamType(Idx);
122 if (const auto *BD = dyn_cast<BlockDecl>(D))
123 return BD->getParamDecl(Idx)->getType();
124
125 return cast<ObjCMethodDecl>(D)->parameters()[Idx]->getType();
126}
127
128static SourceRange getFunctionOrMethodParamRange(const Decl *D, unsigned Idx) {
129 if (auto *PVD = getFunctionOrMethodParam(D, Idx))
130 return PVD->getSourceRange();
131 return SourceRange();
132}
133
135 if (const FunctionType *FnTy = D->getFunctionType())
136 return FnTy->getReturnType();
137 return cast<ObjCMethodDecl>(D)->getReturnType();
138}
139
141 if (const auto *FD = dyn_cast<FunctionDecl>(D))
142 return FD->getReturnTypeSourceRange();
143 if (const auto *MD = dyn_cast<ObjCMethodDecl>(D))
144 return MD->getReturnTypeSourceRange();
145 return SourceRange();
146}
147
148static bool isFunctionOrMethodVariadic(const Decl *D) {
149 if (const FunctionType *FnTy = D->getFunctionType())
150 return cast<FunctionProtoType>(FnTy)->isVariadic();
151 if (const auto *BD = dyn_cast<BlockDecl>(D))
152 return BD->isVariadic();
153 return cast<ObjCMethodDecl>(D)->isVariadic();
154}
155
156static bool isInstanceMethod(const Decl *D) {
157 if (const auto *MethodDecl = dyn_cast<CXXMethodDecl>(D))
158 return MethodDecl->isInstance();
159 return false;
160}
161
162static inline bool isNSStringType(QualType T, ASTContext &Ctx,
163 bool AllowNSAttributedString = false) {
164 const auto *PT = T->getAs<ObjCObjectPointerType>();
165 if (!PT)
166 return false;
167
168 ObjCInterfaceDecl *Cls = PT->getObjectType()->getInterface();
169 if (!Cls)
170 return false;
171
172 IdentifierInfo* ClsName = Cls->getIdentifier();
173
174 if (AllowNSAttributedString &&
175 ClsName == &Ctx.Idents.get("NSAttributedString"))
176 return true;
177 // FIXME: Should we walk the chain of classes?
178 return ClsName == &Ctx.Idents.get("NSString") ||
179 ClsName == &Ctx.Idents.get("NSMutableString");
180}
181
182static inline bool isCFStringType(QualType T, ASTContext &Ctx) {
183 const auto *PT = T->getAs<PointerType>();
184 if (!PT)
185 return false;
186
187 const auto *RT = PT->getPointeeType()->getAs<RecordType>();
188 if (!RT)
189 return false;
190
191 const RecordDecl *RD = RT->getDecl();
192 if (RD->getTagKind() != TagTypeKind::Struct)
193 return false;
194
195 return RD->getIdentifier() == &Ctx.Idents.get("__CFString");
196}
197
198static unsigned getNumAttributeArgs(const ParsedAttr &AL) {
199 // FIXME: Include the type in the argument list.
200 return AL.getNumArgs() + AL.hasParsedType();
201}
202
203/// A helper function to provide Attribute Location for the Attr types
204/// AND the ParsedAttr.
205template <typename AttrInfo>
206static std::enable_if_t<std::is_base_of_v<Attr, AttrInfo>, SourceLocation>
207getAttrLoc(const AttrInfo &AL) {
208 return AL.getLocation();
209}
210static SourceLocation getAttrLoc(const ParsedAttr &AL) { return AL.getLoc(); }
211
212/// If Expr is a valid integer constant, get the value of the integer
213/// expression and return success or failure. May output an error.
214///
215/// Negative argument is implicitly converted to unsigned, unless
216/// \p StrictlyUnsigned is true.
217template <typename AttrInfo>
218static bool checkUInt32Argument(Sema &S, const AttrInfo &AI, const Expr *Expr,
219 uint32_t &Val, unsigned Idx = UINT_MAX,
220 bool StrictlyUnsigned = false) {
221 std::optional<llvm::APSInt> I = llvm::APSInt(32);
222 if (Expr->isTypeDependent() ||
224 if (Idx != UINT_MAX)
225 S.Diag(getAttrLoc(AI), diag::err_attribute_argument_n_type)
226 << &AI << Idx << AANT_ArgumentIntegerConstant
227 << Expr->getSourceRange();
228 else
229 S.Diag(getAttrLoc(AI), diag::err_attribute_argument_type)
231 return false;
232 }
233
234 if (!I->isIntN(32)) {
235 S.Diag(Expr->getExprLoc(), diag::err_ice_too_large)
236 << toString(*I, 10, false) << 32 << /* Unsigned */ 1;
237 return false;
238 }
239
240 if (StrictlyUnsigned && I->isSigned() && I->isNegative()) {
241 S.Diag(getAttrLoc(AI), diag::err_attribute_requires_positive_integer)
242 << &AI << /*non-negative*/ 1;
243 return false;
244 }
245
246 Val = (uint32_t)I->getZExtValue();
247 return true;
248}
249
250/// Wrapper around checkUInt32Argument, with an extra check to be sure
251/// that the result will fit into a regular (signed) int. All args have the same
252/// purpose as they do in checkUInt32Argument.
253template <typename AttrInfo>
254static bool checkPositiveIntArgument(Sema &S, const AttrInfo &AI, const Expr *Expr,
255 int &Val, unsigned Idx = UINT_MAX) {
256 uint32_t UVal;
257 if (!checkUInt32Argument(S, AI, Expr, UVal, Idx))
258 return false;
259
260 if (UVal > (uint32_t)std::numeric_limits<int>::max()) {
261 llvm::APSInt I(32); // for toString
262 I = UVal;
263 S.Diag(Expr->getExprLoc(), diag::err_ice_too_large)
264 << toString(I, 10, false) << 32 << /* Unsigned */ 0;
265 return false;
266 }
267
268 Val = UVal;
269 return true;
270}
271
272/// Diagnose mutually exclusive attributes when present on a given
273/// declaration. Returns true if diagnosed.
274template <typename AttrTy>
275static bool checkAttrMutualExclusion(Sema &S, Decl *D, const ParsedAttr &AL) {
276 if (const auto *A = D->getAttr<AttrTy>()) {
277 S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible)
278 << AL << A
279 << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
280 S.Diag(A->getLocation(), diag::note_conflicting_attribute);
281 return true;
282 }
283 return false;
284}
285
286template <typename AttrTy>
287static bool checkAttrMutualExclusion(Sema &S, Decl *D, const Attr &AL) {
288 if (const auto *A = D->getAttr<AttrTy>()) {
289 S.Diag(AL.getLocation(), diag::err_attributes_are_not_compatible)
290 << &AL << A
291 << (AL.isRegularKeywordAttribute() || A->isRegularKeywordAttribute());
292 S.Diag(A->getLocation(), diag::note_conflicting_attribute);
293 return true;
294 }
295 return false;
296}
297
298/// Check if IdxExpr is a valid parameter index for a function or
299/// instance method D. May output an error.
300///
301/// \returns true if IdxExpr is a valid index.
302template <typename AttrInfo>
304 Sema &S, const Decl *D, const AttrInfo &AI, unsigned AttrArgNum,
305 const Expr *IdxExpr, ParamIdx &Idx, bool CanIndexImplicitThis = false) {
306 assert(isFunctionOrMethodOrBlock(D));
307
308 // In C++ the implicit 'this' function parameter also counts.
309 // Parameters are counted from one.
310 bool HP = hasFunctionProto(D);
311 bool HasImplicitThisParam = isInstanceMethod(D);
312 bool IV = HP && isFunctionOrMethodVariadic(D);
313 unsigned NumParams =
314 (HP ? getFunctionOrMethodNumParams(D) : 0) + HasImplicitThisParam;
315
316 std::optional<llvm::APSInt> IdxInt;
317 if (IdxExpr->isTypeDependent() ||
318 !(IdxInt = IdxExpr->getIntegerConstantExpr(S.Context))) {
319 S.Diag(getAttrLoc(AI), diag::err_attribute_argument_n_type)
320 << &AI << AttrArgNum << AANT_ArgumentIntegerConstant
321 << IdxExpr->getSourceRange();
322 return false;
323 }
324
325 unsigned IdxSource = IdxInt->getLimitedValue(UINT_MAX);
326 if (IdxSource < 1 || (!IV && IdxSource > NumParams)) {
327 S.Diag(getAttrLoc(AI), diag::err_attribute_argument_out_of_bounds)
328 << &AI << AttrArgNum << IdxExpr->getSourceRange();
329 return false;
330 }
331 if (HasImplicitThisParam && !CanIndexImplicitThis) {
332 if (IdxSource == 1) {
333 S.Diag(getAttrLoc(AI), diag::err_attribute_invalid_implicit_this_argument)
334 << &AI << IdxExpr->getSourceRange();
335 return false;
336 }
337 }
338
339 Idx = ParamIdx(IdxSource, D);
340 return true;
341}
342
343/// Check if the argument \p E is a ASCII string literal. If not emit an error
344/// and return false, otherwise set \p Str to the value of the string literal
345/// and return true.
347 const Expr *E, StringRef &Str,
348 SourceLocation *ArgLocation) {
349 const auto *Literal = dyn_cast<StringLiteral>(E->IgnoreParenCasts());
350 if (ArgLocation)
351 *ArgLocation = E->getBeginLoc();
352
353 if (!Literal || (!Literal->isUnevaluated() && !Literal->isOrdinary())) {
354 Diag(E->getBeginLoc(), diag::err_attribute_argument_type)
355 << CI << AANT_ArgumentString;
356 return false;
357 }
358
359 Str = Literal->getString();
360 return true;
361}
362
363/// Check if the argument \p ArgNum of \p Attr is a ASCII string literal.
364/// If not emit an error and return false. If the argument is an identifier it
365/// will emit an error with a fixit hint and treat it as if it was a string
366/// literal.
367bool Sema::checkStringLiteralArgumentAttr(const ParsedAttr &AL, unsigned ArgNum,
368 StringRef &Str,
369 SourceLocation *ArgLocation) {
370 // Look for identifiers. If we have one emit a hint to fix it to a literal.
371 if (AL.isArgIdent(ArgNum)) {
372 IdentifierLoc *Loc = AL.getArgAsIdent(ArgNum);
373 Diag(Loc->Loc, diag::err_attribute_argument_type)
374 << AL << AANT_ArgumentString
375 << FixItHint::CreateInsertion(Loc->Loc, "\"")
377 Str = Loc->Ident->getName();
378 if (ArgLocation)
379 *ArgLocation = Loc->Loc;
380 return true;
381 }
382
383 // Now check for an actual string literal.
384 Expr *ArgExpr = AL.getArgAsExpr(ArgNum);
385 const auto *Literal = dyn_cast<StringLiteral>(ArgExpr->IgnoreParenCasts());
386 if (ArgLocation)
387 *ArgLocation = ArgExpr->getBeginLoc();
388
389 if (!Literal || (!Literal->isUnevaluated() && !Literal->isOrdinary())) {
390 Diag(ArgExpr->getBeginLoc(), diag::err_attribute_argument_type)
391 << AL << AANT_ArgumentString;
392 return false;
393 }
394 Str = Literal->getString();
395 return checkStringLiteralArgumentAttr(AL, ArgExpr, Str, ArgLocation);
396}
397
398/// Applies the given attribute to the Decl without performing any
399/// additional semantic checking.
400template <typename AttrType>
401static void handleSimpleAttribute(Sema &S, Decl *D,
402 const AttributeCommonInfo &CI) {
403 D->addAttr(::new (S.Context) AttrType(S.Context, CI));
404}
405
406template <typename... DiagnosticArgs>
407static const Sema::SemaDiagnosticBuilder&
409 return Bldr;
410}
411
412template <typename T, typename... DiagnosticArgs>
413static const Sema::SemaDiagnosticBuilder&
415 DiagnosticArgs &&... ExtraArgs) {
416 return appendDiagnostics(Bldr << std::forward<T>(ExtraArg),
417 std::forward<DiagnosticArgs>(ExtraArgs)...);
418}
419
420/// Add an attribute @c AttrType to declaration @c D, provided that
421/// @c PassesCheck is true.
422/// Otherwise, emit diagnostic @c DiagID, passing in all parameters
423/// specified in @c ExtraArgs.
424template <typename AttrType, typename... DiagnosticArgs>
426 const AttributeCommonInfo &CI,
427 bool PassesCheck, unsigned DiagID,
428 DiagnosticArgs &&... ExtraArgs) {
429 if (!PassesCheck) {
430 Sema::SemaDiagnosticBuilder DB = S.Diag(D->getBeginLoc(), DiagID);
431 appendDiagnostics(DB, std::forward<DiagnosticArgs>(ExtraArgs)...);
432 return;
433 }
434 handleSimpleAttribute<AttrType>(S, D, CI);
435}
436
437/// Check if the passed-in expression is of type int or bool.
438static bool isIntOrBool(Expr *Exp) {
439 QualType QT = Exp->getType();
440 return QT->isBooleanType() || QT->isIntegerType();
441}
442
443
444// Check to see if the type is a smart pointer of some kind. We assume
445// it's a smart pointer if it defines both operator-> and operator*.
447 auto IsOverloadedOperatorPresent = [&S](const RecordDecl *Record,
450 Record->lookup(S.Context.DeclarationNames.getCXXOperatorName(Op));
451 return !Result.empty();
452 };
453
454 const RecordDecl *Record = RT->getDecl();
455 bool foundStarOperator = IsOverloadedOperatorPresent(Record, OO_Star);
456 bool foundArrowOperator = IsOverloadedOperatorPresent(Record, OO_Arrow);
457 if (foundStarOperator && foundArrowOperator)
458 return true;
459
460 const CXXRecordDecl *CXXRecord = dyn_cast<CXXRecordDecl>(Record);
461 if (!CXXRecord)
462 return false;
463
464 for (const auto &BaseSpecifier : CXXRecord->bases()) {
465 if (!foundStarOperator)
466 foundStarOperator = IsOverloadedOperatorPresent(
467 BaseSpecifier.getType()->getAsRecordDecl(), OO_Star);
468 if (!foundArrowOperator)
469 foundArrowOperator = IsOverloadedOperatorPresent(
470 BaseSpecifier.getType()->getAsRecordDecl(), OO_Arrow);
471 }
472
473 if (foundStarOperator && foundArrowOperator)
474 return true;
475
476 return false;
477}
478
479/// Check if passed in Decl is a pointer type.
480/// Note that this function may produce an error message.
481/// \return true if the Decl is a pointer type; false otherwise
482static bool threadSafetyCheckIsPointer(Sema &S, const Decl *D,
483 const ParsedAttr &AL) {
484 const auto *VD = cast<ValueDecl>(D);
485 QualType QT = VD->getType();
486 if (QT->isAnyPointerType())
487 return true;
488
489 if (const auto *RT = QT->getAs<RecordType>()) {
490 // If it's an incomplete type, it could be a smart pointer; skip it.
491 // (We don't want to force template instantiation if we can avoid it,
492 // since that would alter the order in which templates are instantiated.)
493 if (RT->isIncompleteType())
494 return true;
495
497 return true;
498 }
499
500 S.Diag(AL.getLoc(), diag::warn_thread_attribute_decl_not_pointer) << AL << QT;
501 return false;
502}
503
504/// Checks that the passed in QualType either is of RecordType or points
505/// to RecordType. Returns the relevant RecordType, null if it does not exit.
507 if (const auto *RT = QT->getAs<RecordType>())
508 return RT;
509
510 // Now check if we point to record type.
511 if (const auto *PT = QT->getAs<PointerType>())
512 return PT->getPointeeType()->getAs<RecordType>();
513
514 return nullptr;
515}
516
517template <typename AttrType>
518static bool checkRecordDeclForAttr(const RecordDecl *RD) {
519 // Check if the record itself has the attribute.
520 if (RD->hasAttr<AttrType>())
521 return true;
522
523 // Else check if any base classes have the attribute.
524 if (const auto *CRD = dyn_cast<CXXRecordDecl>(RD)) {
525 if (!CRD->forallBases([](const CXXRecordDecl *Base) {
526 return !Base->hasAttr<AttrType>();
527 }))
528 return true;
529 }
530 return false;
531}
532
534 const RecordType *RT = getRecordType(Ty);
535
536 if (!RT)
537 return false;
538
539 // Don't check for the capability if the class hasn't been defined yet.
540 if (RT->isIncompleteType())
541 return true;
542
543 // Allow smart pointers to be used as capability objects.
544 // FIXME -- Check the type that the smart pointer points to.
546 return true;
547
548 return checkRecordDeclForAttr<CapabilityAttr>(RT->getDecl());
549}
550
552 const auto *TD = Ty->getAs<TypedefType>();
553 if (!TD)
554 return false;
555
556 TypedefNameDecl *TN = TD->getDecl();
557 if (!TN)
558 return false;
559
560 return TN->hasAttr<CapabilityAttr>();
561}
562
563static bool typeHasCapability(Sema &S, QualType Ty) {
565 return true;
566
568 return true;
569
570 return false;
571}
572
573static bool isCapabilityExpr(Sema &S, const Expr *Ex) {
574 // Capability expressions are simple expressions involving the boolean logic
575 // operators &&, || or !, a simple DeclRefExpr, CastExpr or a ParenExpr. Once
576 // a DeclRefExpr is found, its type should be checked to determine whether it
577 // is a capability or not.
578
579 if (const auto *E = dyn_cast<CastExpr>(Ex))
580 return isCapabilityExpr(S, E->getSubExpr());
581 else if (const auto *E = dyn_cast<ParenExpr>(Ex))
582 return isCapabilityExpr(S, E->getSubExpr());
583 else if (const auto *E = dyn_cast<UnaryOperator>(Ex)) {
584 if (E->getOpcode() == UO_LNot || E->getOpcode() == UO_AddrOf ||
585 E->getOpcode() == UO_Deref)
586 return isCapabilityExpr(S, E->getSubExpr());
587 return false;
588 } else if (const auto *E = dyn_cast<BinaryOperator>(Ex)) {
589 if (E->getOpcode() == BO_LAnd || E->getOpcode() == BO_LOr)
590 return isCapabilityExpr(S, E->getLHS()) &&
591 isCapabilityExpr(S, E->getRHS());
592 return false;
593 }
594
595 return typeHasCapability(S, Ex->getType());
596}
597
598/// Checks that all attribute arguments, starting from Sidx, resolve to
599/// a capability object.
600/// \param Sidx The attribute argument index to start checking with.
601/// \param ParamIdxOk Whether an argument can be indexing into a function
602/// parameter list.
604 const ParsedAttr &AL,
606 unsigned Sidx = 0,
607 bool ParamIdxOk = false) {
608 if (Sidx == AL.getNumArgs()) {
609 // If we don't have any capability arguments, the attribute implicitly
610 // refers to 'this'. So we need to make sure that 'this' exists, i.e. we're
611 // a non-static method, and that the class is a (scoped) capability.
612 const auto *MD = dyn_cast<const CXXMethodDecl>(D);
613 if (MD && !MD->isStatic()) {
614 const CXXRecordDecl *RD = MD->getParent();
615 // FIXME -- need to check this again on template instantiation
616 if (!checkRecordDeclForAttr<CapabilityAttr>(RD) &&
617 !checkRecordDeclForAttr<ScopedLockableAttr>(RD))
618 S.Diag(AL.getLoc(),
619 diag::warn_thread_attribute_not_on_capability_member)
620 << AL << MD->getParent();
621 } else {
622 S.Diag(AL.getLoc(), diag::warn_thread_attribute_not_on_non_static_member)
623 << AL;
624 }
625 }
626
627 for (unsigned Idx = Sidx; Idx < AL.getNumArgs(); ++Idx) {
628 Expr *ArgExp = AL.getArgAsExpr(Idx);
629
630 if (ArgExp->isTypeDependent()) {
631 // FIXME -- need to check this again on template instantiation
632 Args.push_back(ArgExp);
633 continue;
634 }
635
636 if (const auto *StrLit = dyn_cast<StringLiteral>(ArgExp)) {
637 if (StrLit->getLength() == 0 ||
638 (StrLit->isOrdinary() && StrLit->getString() == StringRef("*"))) {
639 // Pass empty strings to the analyzer without warnings.
640 // Treat "*" as the universal lock.
641 Args.push_back(ArgExp);
642 continue;
643 }
644
645 // We allow constant strings to be used as a placeholder for expressions
646 // that are not valid C++ syntax, but warn that they are ignored.
647 S.Diag(AL.getLoc(), diag::warn_thread_attribute_ignored) << AL;
648 Args.push_back(ArgExp);
649 continue;
650 }
651
652 QualType ArgTy = ArgExp->getType();
653
654 // A pointer to member expression of the form &MyClass::mu is treated
655 // specially -- we need to look at the type of the member.
656 if (const auto *UOp = dyn_cast<UnaryOperator>(ArgExp))
657 if (UOp->getOpcode() == UO_AddrOf)
658 if (const auto *DRE = dyn_cast<DeclRefExpr>(UOp->getSubExpr()))
659 if (DRE->getDecl()->isCXXInstanceMember())
660 ArgTy = DRE->getDecl()->getType();
661
662 // First see if we can just cast to record type, or pointer to record type.
663 const RecordType *RT = getRecordType(ArgTy);
664
665 // Now check if we index into a record type function param.
666 if(!RT && ParamIdxOk) {
667 const auto *FD = dyn_cast<FunctionDecl>(D);
668 const auto *IL = dyn_cast<IntegerLiteral>(ArgExp);
669 if(FD && IL) {
670 unsigned int NumParams = FD->getNumParams();
671 llvm::APInt ArgValue = IL->getValue();
672 uint64_t ParamIdxFromOne = ArgValue.getZExtValue();
673 uint64_t ParamIdxFromZero = ParamIdxFromOne - 1;
674 if (!ArgValue.isStrictlyPositive() || ParamIdxFromOne > NumParams) {
675 S.Diag(AL.getLoc(),
676 diag::err_attribute_argument_out_of_bounds_extra_info)
677 << AL << Idx + 1 << NumParams;
678 continue;
679 }
680 ArgTy = FD->getParamDecl(ParamIdxFromZero)->getType();
681 }
682 }
683
684 // If the type does not have a capability, see if the components of the
685 // expression have capabilities. This allows for writing C code where the
686 // capability may be on the type, and the expression is a capability
687 // boolean logic expression. Eg) requires_capability(A || B && !C)
688 if (!typeHasCapability(S, ArgTy) && !isCapabilityExpr(S, ArgExp))
689 S.Diag(AL.getLoc(), diag::warn_thread_attribute_argument_not_lockable)
690 << AL << ArgTy;
691
692 Args.push_back(ArgExp);
693 }
694}
695
696//===----------------------------------------------------------------------===//
697// Attribute Implementations
698//===----------------------------------------------------------------------===//
699
700static void handlePtGuardedVarAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
701 if (!threadSafetyCheckIsPointer(S, D, AL))
702 return;
703
704 D->addAttr(::new (S.Context) PtGuardedVarAttr(S.Context, AL));
705}
706
707static bool checkGuardedByAttrCommon(Sema &S, Decl *D, const ParsedAttr &AL,
708 Expr *&Arg) {
710 // check that all arguments are lockable objects
711 checkAttrArgsAreCapabilityObjs(S, D, AL, Args);
712 unsigned Size = Args.size();
713 if (Size != 1)
714 return false;
715
716 Arg = Args[0];
717
718 return true;
719}
720
721static void handleGuardedByAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
722 Expr *Arg = nullptr;
723 if (!checkGuardedByAttrCommon(S, D, AL, Arg))
724 return;
725
726 D->addAttr(::new (S.Context) GuardedByAttr(S.Context, AL, Arg));
727}
728
729static void handlePtGuardedByAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
730 Expr *Arg = nullptr;
731 if (!checkGuardedByAttrCommon(S, D, AL, Arg))
732 return;
733
734 if (!threadSafetyCheckIsPointer(S, D, AL))
735 return;
736
737 D->addAttr(::new (S.Context) PtGuardedByAttr(S.Context, AL, Arg));
738}
739
740static bool checkAcquireOrderAttrCommon(Sema &S, Decl *D, const ParsedAttr &AL,
742 if (!AL.checkAtLeastNumArgs(S, 1))
743 return false;
744
745 // Check that this attribute only applies to lockable types.
746 QualType QT = cast<ValueDecl>(D)->getType();
747 if (!QT->isDependentType() && !typeHasCapability(S, QT)) {
748 S.Diag(AL.getLoc(), diag::warn_thread_attribute_decl_not_lockable) << AL;
749 return false;
750 }
751
752 // Check that all arguments are lockable objects.
753 checkAttrArgsAreCapabilityObjs(S, D, AL, Args);
754 if (Args.empty())
755 return false;
756
757 return true;
758}
759
760static void handleAcquiredAfterAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
762 if (!checkAcquireOrderAttrCommon(S, D, AL, Args))
763 return;
764
765 Expr **StartArg = &Args[0];
766 D->addAttr(::new (S.Context)
767 AcquiredAfterAttr(S.Context, AL, StartArg, Args.size()));
768}
769
770static void handleAcquiredBeforeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
772 if (!checkAcquireOrderAttrCommon(S, D, AL, Args))
773 return;
774
775 Expr **StartArg = &Args[0];
776 D->addAttr(::new (S.Context)
777 AcquiredBeforeAttr(S.Context, AL, StartArg, Args.size()));
778}
779
780static bool checkLockFunAttrCommon(Sema &S, Decl *D, const ParsedAttr &AL,
782 // zero or more arguments ok
783 // check that all arguments are lockable objects
784 checkAttrArgsAreCapabilityObjs(S, D, AL, Args, 0, /*ParamIdxOk=*/true);
785
786 return true;
787}
788
789static void handleAssertSharedLockAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
791 if (!checkLockFunAttrCommon(S, D, AL, Args))
792 return;
793
794 unsigned Size = Args.size();
795 Expr **StartArg = Size == 0 ? nullptr : &Args[0];
796 D->addAttr(::new (S.Context)
797 AssertSharedLockAttr(S.Context, AL, StartArg, Size));
798}
799
801 const ParsedAttr &AL) {
803 if (!checkLockFunAttrCommon(S, D, AL, Args))
804 return;
805
806 unsigned Size = Args.size();
807 Expr **StartArg = Size == 0 ? nullptr : &Args[0];
808 D->addAttr(::new (S.Context)
809 AssertExclusiveLockAttr(S.Context, AL, StartArg, Size));
810}
811
812/// Checks to be sure that the given parameter number is in bounds, and
813/// is an integral type. Will emit appropriate diagnostics if this returns
814/// false.
815///
816/// AttrArgNo is used to actually retrieve the argument, so it's base-0.
817template <typename AttrInfo>
818static bool checkParamIsIntegerType(Sema &S, const Decl *D, const AttrInfo &AI,
819 unsigned AttrArgNo) {
820 assert(AI.isArgExpr(AttrArgNo) && "Expected expression argument");
821 Expr *AttrArg = AI.getArgAsExpr(AttrArgNo);
822 ParamIdx Idx;
823 if (!checkFunctionOrMethodParameterIndex(S, D, AI, AttrArgNo + 1, AttrArg,
824 Idx))
825 return false;
826
828 if (!ParamTy->isIntegerType() && !ParamTy->isCharType()) {
829 SourceLocation SrcLoc = AttrArg->getBeginLoc();
830 S.Diag(SrcLoc, diag::err_attribute_integers_only)
832 return false;
833 }
834 return true;
835}
836
837static void handleAllocSizeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
838 if (!AL.checkAtLeastNumArgs(S, 1) || !AL.checkAtMostNumArgs(S, 2))
839 return;
840
841 assert(isFunctionOrMethod(D) && hasFunctionProto(D));
842
844 if (!RetTy->isPointerType()) {
845 S.Diag(AL.getLoc(), diag::warn_attribute_return_pointers_only) << AL;
846 return;
847 }
848
849 const Expr *SizeExpr = AL.getArgAsExpr(0);
850 int SizeArgNoVal;
851 // Parameter indices are 1-indexed, hence Index=1
852 if (!checkPositiveIntArgument(S, AL, SizeExpr, SizeArgNoVal, /*Idx=*/1))
853 return;
854 if (!checkParamIsIntegerType(S, D, AL, /*AttrArgNo=*/0))
855 return;
856 ParamIdx SizeArgNo(SizeArgNoVal, D);
857
858 ParamIdx NumberArgNo;
859 if (AL.getNumArgs() == 2) {
860 const Expr *NumberExpr = AL.getArgAsExpr(1);
861 int Val;
862 // Parameter indices are 1-based, hence Index=2
863 if (!checkPositiveIntArgument(S, AL, NumberExpr, Val, /*Idx=*/2))
864 return;
865 if (!checkParamIsIntegerType(S, D, AL, /*AttrArgNo=*/1))
866 return;
867 NumberArgNo = ParamIdx(Val, D);
868 }
869
870 D->addAttr(::new (S.Context)
871 AllocSizeAttr(S.Context, AL, SizeArgNo, NumberArgNo));
872}
873
874static bool checkTryLockFunAttrCommon(Sema &S, Decl *D, const ParsedAttr &AL,
876 if (!AL.checkAtLeastNumArgs(S, 1))
877 return false;
878
879 if (!isIntOrBool(AL.getArgAsExpr(0))) {
880 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
881 << AL << 1 << AANT_ArgumentIntOrBool;
882 return false;
883 }
884
885 // check that all arguments are lockable objects
886 checkAttrArgsAreCapabilityObjs(S, D, AL, Args, 1);
887
888 return true;
889}
890
892 const ParsedAttr &AL) {
894 if (!checkTryLockFunAttrCommon(S, D, AL, Args))
895 return;
896
897 D->addAttr(::new (S.Context) SharedTrylockFunctionAttr(
898 S.Context, AL, AL.getArgAsExpr(0), Args.data(), Args.size()));
899}
900
902 const ParsedAttr &AL) {
904 if (!checkTryLockFunAttrCommon(S, D, AL, Args))
905 return;
906
907 D->addAttr(::new (S.Context) ExclusiveTrylockFunctionAttr(
908 S.Context, AL, AL.getArgAsExpr(0), Args.data(), Args.size()));
909}
910
911static void handleLockReturnedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
912 // check that the argument is lockable object
914 checkAttrArgsAreCapabilityObjs(S, D, AL, Args);
915 unsigned Size = Args.size();
916 if (Size == 0)
917 return;
918
919 D->addAttr(::new (S.Context) LockReturnedAttr(S.Context, AL, Args[0]));
920}
921
922static void handleLocksExcludedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
923 if (!AL.checkAtLeastNumArgs(S, 1))
924 return;
925
926 // check that all arguments are lockable objects
928 checkAttrArgsAreCapabilityObjs(S, D, AL, Args);
929 unsigned Size = Args.size();
930 if (Size == 0)
931 return;
932 Expr **StartArg = &Args[0];
933
934 D->addAttr(::new (S.Context)
935 LocksExcludedAttr(S.Context, AL, StartArg, Size));
936}
937
938static bool checkFunctionConditionAttr(Sema &S, Decl *D, const ParsedAttr &AL,
939 Expr *&Cond, StringRef &Msg) {
940 Cond = AL.getArgAsExpr(0);
941 if (!Cond->isTypeDependent()) {
943 if (Converted.isInvalid())
944 return false;
945 Cond = Converted.get();
946 }
947
948 if (!S.checkStringLiteralArgumentAttr(AL, 1, Msg))
949 return false;
950
951 if (Msg.empty())
952 Msg = "<no message provided>";
953
955 if (isa<FunctionDecl>(D) && !Cond->isValueDependent() &&
956 !Expr::isPotentialConstantExprUnevaluated(Cond, cast<FunctionDecl>(D),
957 Diags)) {
958 S.Diag(AL.getLoc(), diag::err_attr_cond_never_constant_expr) << AL;
959 for (const PartialDiagnosticAt &PDiag : Diags)
960 S.Diag(PDiag.first, PDiag.second);
961 return false;
962 }
963 return true;
964}
965
966static void handleEnableIfAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
967 S.Diag(AL.getLoc(), diag::ext_clang_enable_if);
968
969 Expr *Cond;
970 StringRef Msg;
971 if (checkFunctionConditionAttr(S, D, AL, Cond, Msg))
972 D->addAttr(::new (S.Context) EnableIfAttr(S.Context, AL, Cond, Msg));
973}
974
975static void handleErrorAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
976 StringRef NewUserDiagnostic;
977 if (!S.checkStringLiteralArgumentAttr(AL, 0, NewUserDiagnostic))
978 return;
979 if (ErrorAttr *EA = S.mergeErrorAttr(D, AL, NewUserDiagnostic))
980 D->addAttr(EA);
981}
982
983namespace {
984/// Determines if a given Expr references any of the given function's
985/// ParmVarDecls, or the function's implicit `this` parameter (if applicable).
986class ArgumentDependenceChecker
987 : public RecursiveASTVisitor<ArgumentDependenceChecker> {
988#ifndef NDEBUG
989 const CXXRecordDecl *ClassType;
990#endif
992 bool Result;
993
994public:
995 ArgumentDependenceChecker(const FunctionDecl *FD) {
996#ifndef NDEBUG
997 if (const auto *MD = dyn_cast<CXXMethodDecl>(FD))
998 ClassType = MD->getParent();
999 else
1000 ClassType = nullptr;
1001#endif
1002 Parms.insert(FD->param_begin(), FD->param_end());
1003 }
1004
1005 bool referencesArgs(Expr *E) {
1006 Result = false;
1007 TraverseStmt(E);
1008 return Result;
1009 }
1010
1011 bool VisitCXXThisExpr(CXXThisExpr *E) {
1012 assert(E->getType()->getPointeeCXXRecordDecl() == ClassType &&
1013 "`this` doesn't refer to the enclosing class?");
1014 Result = true;
1015 return false;
1016 }
1017
1018 bool VisitDeclRefExpr(DeclRefExpr *DRE) {
1019 if (const auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl()))
1020 if (Parms.count(PVD)) {
1021 Result = true;
1022 return false;
1023 }
1024 return true;
1025 }
1026};
1027}
1028
1030 const ParsedAttr &AL) {
1031 const auto *DeclFD = cast<FunctionDecl>(D);
1032
1033 if (const auto *MethodDecl = dyn_cast<CXXMethodDecl>(DeclFD))
1034 if (!MethodDecl->isStatic()) {
1035 S.Diag(AL.getLoc(), diag::err_attribute_no_member_function) << AL;
1036 return;
1037 }
1038
1039 auto DiagnoseType = [&](unsigned Index, AttributeArgumentNType T) {
1040 SourceLocation Loc = [&]() {
1041 auto Union = AL.getArg(Index - 1);
1042 if (Union.is<Expr *>())
1043 return Union.get<Expr *>()->getBeginLoc();
1044 return Union.get<IdentifierLoc *>()->Loc;
1045 }();
1046
1047 S.Diag(Loc, diag::err_attribute_argument_n_type) << AL << Index << T;
1048 };
1049
1050 FunctionDecl *AttrFD = [&]() -> FunctionDecl * {
1051 if (!AL.isArgExpr(0))
1052 return nullptr;
1053 auto *F = dyn_cast_if_present<DeclRefExpr>(AL.getArgAsExpr(0));
1054 if (!F)
1055 return nullptr;
1056 return dyn_cast_if_present<FunctionDecl>(F->getFoundDecl());
1057 }();
1058
1059 if (!AttrFD || !AttrFD->getBuiltinID(true)) {
1060 DiagnoseType(1, AANT_ArgumentBuiltinFunction);
1061 return;
1062 }
1063
1064 if (AttrFD->getNumParams() != AL.getNumArgs() - 1) {
1065 S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments_for)
1066 << AL << AttrFD << AttrFD->getNumParams();
1067 return;
1068 }
1069
1071
1072 for (unsigned I = 1; I < AL.getNumArgs(); ++I) {
1073 if (!AL.isArgExpr(I)) {
1074 DiagnoseType(I + 1, AANT_ArgumentIntegerConstant);
1075 return;
1076 }
1077
1078 const Expr *IndexExpr = AL.getArgAsExpr(I);
1079 uint32_t Index;
1080
1081 if (!checkUInt32Argument(S, AL, IndexExpr, Index, I + 1, false))
1082 return;
1083
1084 if (Index > DeclFD->getNumParams()) {
1085 S.Diag(AL.getLoc(), diag::err_attribute_bounds_for_function)
1086 << AL << Index << DeclFD << DeclFD->getNumParams();
1087 return;
1088 }
1089
1090 QualType T1 = AttrFD->getParamDecl(I - 1)->getType();
1091 QualType T2 = DeclFD->getParamDecl(Index - 1)->getType();
1092
1095 S.Diag(IndexExpr->getBeginLoc(), diag::err_attribute_parameter_types)
1096 << AL << Index << DeclFD << T2 << I << AttrFD << T1;
1097 return;
1098 }
1099
1100 Indices.push_back(Index - 1);
1101 }
1102
1103 D->addAttr(::new (S.Context) DiagnoseAsBuiltinAttr(
1104 S.Context, AL, AttrFD, Indices.data(), Indices.size()));
1105}
1106
1107static void handleDiagnoseIfAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1108 S.Diag(AL.getLoc(), diag::ext_clang_diagnose_if);
1109
1110 Expr *Cond;
1111 StringRef Msg;
1112 if (!checkFunctionConditionAttr(S, D, AL, Cond, Msg))
1113 return;
1114
1115 StringRef DiagTypeStr;
1116 if (!S.checkStringLiteralArgumentAttr(AL, 2, DiagTypeStr))
1117 return;
1118
1119 DiagnoseIfAttr::DiagnosticType DiagType;
1120 if (!DiagnoseIfAttr::ConvertStrToDiagnosticType(DiagTypeStr, DiagType)) {
1121 S.Diag(AL.getArgAsExpr(2)->getBeginLoc(),
1122 diag::err_diagnose_if_invalid_diagnostic_type);
1123 return;
1124 }
1125
1126 bool ArgDependent = false;
1127 if (const auto *FD = dyn_cast<FunctionDecl>(D))
1128 ArgDependent = ArgumentDependenceChecker(FD).referencesArgs(Cond);
1129 D->addAttr(::new (S.Context) DiagnoseIfAttr(
1130 S.Context, AL, Cond, Msg, DiagType, ArgDependent, cast<NamedDecl>(D)));
1131}
1132
1133static void handleNoBuiltinAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1134 static constexpr const StringRef kWildcard = "*";
1135
1137 bool HasWildcard = false;
1138
1139 const auto AddBuiltinName = [&Names, &HasWildcard](StringRef Name) {
1140 if (Name == kWildcard)
1141 HasWildcard = true;
1142 Names.push_back(Name);
1143 };
1144
1145 // Add previously defined attributes.
1146 if (const auto *NBA = D->getAttr<NoBuiltinAttr>())
1147 for (StringRef BuiltinName : NBA->builtinNames())
1148 AddBuiltinName(BuiltinName);
1149
1150 // Add current attributes.
1151 if (AL.getNumArgs() == 0)
1152 AddBuiltinName(kWildcard);
1153 else
1154 for (unsigned I = 0, E = AL.getNumArgs(); I != E; ++I) {
1155 StringRef BuiltinName;
1156 SourceLocation LiteralLoc;
1157 if (!S.checkStringLiteralArgumentAttr(AL, I, BuiltinName, &LiteralLoc))
1158 return;
1159
1160 if (Builtin::Context::isBuiltinFunc(BuiltinName))
1161 AddBuiltinName(BuiltinName);
1162 else
1163 S.Diag(LiteralLoc, diag::warn_attribute_no_builtin_invalid_builtin_name)
1164 << BuiltinName << AL;
1165 }
1166
1167 // Repeating the same attribute is fine.
1168 llvm::sort(Names);
1169 Names.erase(std::unique(Names.begin(), Names.end()), Names.end());
1170
1171 // Empty no_builtin must be on its own.
1172 if (HasWildcard && Names.size() > 1)
1173 S.Diag(D->getLocation(),
1174 diag::err_attribute_no_builtin_wildcard_or_builtin_name)
1175 << AL;
1176
1177 if (D->hasAttr<NoBuiltinAttr>())
1178 D->dropAttr<NoBuiltinAttr>();
1179 D->addAttr(::new (S.Context)
1180 NoBuiltinAttr(S.Context, AL, Names.data(), Names.size()));
1181}
1182
1183static void handlePassObjectSizeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1184 if (D->hasAttr<PassObjectSizeAttr>()) {
1185 S.Diag(D->getBeginLoc(), diag::err_attribute_only_once_per_parameter) << AL;
1186 return;
1187 }
1188
1189 Expr *E = AL.getArgAsExpr(0);
1190 uint32_t Type;
1191 if (!checkUInt32Argument(S, AL, E, Type, /*Idx=*/1))
1192 return;
1193
1194 // pass_object_size's argument is passed in as the second argument of
1195 // __builtin_object_size. So, it has the same constraints as that second
1196 // argument; namely, it must be in the range [0, 3].
1197 if (Type > 3) {
1198 S.Diag(E->getBeginLoc(), diag::err_attribute_argument_out_of_range)
1199 << AL << 0 << 3 << E->getSourceRange();
1200 return;
1201 }
1202
1203 // pass_object_size is only supported on constant pointer parameters; as a
1204 // kindness to users, we allow the parameter to be non-const for declarations.
1205 // At this point, we have no clue if `D` belongs to a function declaration or
1206 // definition, so we defer the constness check until later.
1207 if (!cast<ParmVarDecl>(D)->getType()->isPointerType()) {
1208 S.Diag(D->getBeginLoc(), diag::err_attribute_pointers_only) << AL << 1;
1209 return;
1210 }
1211
1212 D->addAttr(::new (S.Context) PassObjectSizeAttr(S.Context, AL, (int)Type));
1213}
1214
1215static void handleConsumableAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1216 ConsumableAttr::ConsumedState DefaultState;
1217
1218 if (AL.isArgIdent(0)) {
1219 IdentifierLoc *IL = AL.getArgAsIdent(0);
1220 if (!ConsumableAttr::ConvertStrToConsumedState(IL->Ident->getName(),
1221 DefaultState)) {
1222 S.Diag(IL->Loc, diag::warn_attribute_type_not_supported) << AL
1223 << IL->Ident;
1224 return;
1225 }
1226 } else {
1227 S.Diag(AL.getLoc(), diag::err_attribute_argument_type)
1228 << AL << AANT_ArgumentIdentifier;
1229 return;
1230 }
1231
1232 D->addAttr(::new (S.Context) ConsumableAttr(S.Context, AL, DefaultState));
1233}
1234
1236 const ParsedAttr &AL) {
1238
1239 if (const CXXRecordDecl *RD = ThisType->getAsCXXRecordDecl()) {
1240 if (!RD->hasAttr<ConsumableAttr>()) {
1241 S.Diag(AL.getLoc(), diag::warn_attr_on_unconsumable_class) << RD;
1242
1243 return false;
1244 }
1245 }
1246
1247 return true;
1248}
1249
1250static void handleCallableWhenAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1251 if (!AL.checkAtLeastNumArgs(S, 1))
1252 return;
1253
1254 if (!checkForConsumableClass(S, cast<CXXMethodDecl>(D), AL))
1255 return;
1256
1258 for (unsigned ArgIndex = 0; ArgIndex < AL.getNumArgs(); ++ArgIndex) {
1259 CallableWhenAttr::ConsumedState CallableState;
1260
1261 StringRef StateString;
1262 SourceLocation Loc;
1263 if (AL.isArgIdent(ArgIndex)) {
1264 IdentifierLoc *Ident = AL.getArgAsIdent(ArgIndex);
1265 StateString = Ident->Ident->getName();
1266 Loc = Ident->Loc;
1267 } else {
1268 if (!S.checkStringLiteralArgumentAttr(AL, ArgIndex, StateString, &Loc))
1269 return;
1270 }
1271
1272 if (!CallableWhenAttr::ConvertStrToConsumedState(StateString,
1273 CallableState)) {
1274 S.Diag(Loc, diag::warn_attribute_type_not_supported) << AL << StateString;
1275 return;
1276 }
1277
1278 States.push_back(CallableState);
1279 }
1280
1281 D->addAttr(::new (S.Context)
1282 CallableWhenAttr(S.Context, AL, States.data(), States.size()));
1283}
1284
1285static void handleParamTypestateAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1286 ParamTypestateAttr::ConsumedState ParamState;
1287
1288 if (AL.isArgIdent(0)) {
1289 IdentifierLoc *Ident = AL.getArgAsIdent(0);
1290 StringRef StateString = Ident->Ident->getName();
1291
1292 if (!ParamTypestateAttr::ConvertStrToConsumedState(StateString,
1293 ParamState)) {
1294 S.Diag(Ident->Loc, diag::warn_attribute_type_not_supported)
1295 << AL << StateString;
1296 return;
1297 }
1298 } else {
1299 S.Diag(AL.getLoc(), diag::err_attribute_argument_type)
1300 << AL << AANT_ArgumentIdentifier;
1301 return;
1302 }
1303
1304 // FIXME: This check is currently being done in the analysis. It can be
1305 // enabled here only after the parser propagates attributes at
1306 // template specialization definition, not declaration.
1307 //QualType ReturnType = cast<ParmVarDecl>(D)->getType();
1308 //const CXXRecordDecl *RD = ReturnType->getAsCXXRecordDecl();
1309 //
1310 //if (!RD || !RD->hasAttr<ConsumableAttr>()) {
1311 // S.Diag(AL.getLoc(), diag::warn_return_state_for_unconsumable_type) <<
1312 // ReturnType.getAsString();
1313 // return;
1314 //}
1315
1316 D->addAttr(::new (S.Context) ParamTypestateAttr(S.Context, AL, ParamState));
1317}
1318
1319static void handleReturnTypestateAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1320 ReturnTypestateAttr::ConsumedState ReturnState;
1321
1322 if (AL.isArgIdent(0)) {
1323 IdentifierLoc *IL = AL.getArgAsIdent(0);
1324 if (!ReturnTypestateAttr::ConvertStrToConsumedState(IL->Ident->getName(),
1325 ReturnState)) {
1326 S.Diag(IL->Loc, diag::warn_attribute_type_not_supported) << AL
1327 << IL->Ident;
1328 return;
1329 }
1330 } else {
1331 S.Diag(AL.getLoc(), diag::err_attribute_argument_type)
1332 << AL << AANT_ArgumentIdentifier;
1333 return;
1334 }
1335
1336 // FIXME: This check is currently being done in the analysis. It can be
1337 // enabled here only after the parser propagates attributes at
1338 // template specialization definition, not declaration.
1339 // QualType ReturnType;
1340 //
1341 // if (const ParmVarDecl *Param = dyn_cast<ParmVarDecl>(D)) {
1342 // ReturnType = Param->getType();
1343 //
1344 //} else if (const CXXConstructorDecl *Constructor =
1345 // dyn_cast<CXXConstructorDecl>(D)) {
1346 // ReturnType = Constructor->getFunctionObjectParameterType();
1347 //
1348 //} else {
1349 //
1350 // ReturnType = cast<FunctionDecl>(D)->getCallResultType();
1351 //}
1352 //
1353 // const CXXRecordDecl *RD = ReturnType->getAsCXXRecordDecl();
1354 //
1355 // if (!RD || !RD->hasAttr<ConsumableAttr>()) {
1356 // S.Diag(Attr.getLoc(), diag::warn_return_state_for_unconsumable_type) <<
1357 // ReturnType.getAsString();
1358 // return;
1359 //}
1360
1361 D->addAttr(::new (S.Context) ReturnTypestateAttr(S.Context, AL, ReturnState));
1362}
1363
1364static void handleSetTypestateAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1365 if (!checkForConsumableClass(S, cast<CXXMethodDecl>(D), AL))
1366 return;
1367
1368 SetTypestateAttr::ConsumedState NewState;
1369 if (AL.isArgIdent(0)) {
1370 IdentifierLoc *Ident = AL.getArgAsIdent(0);
1371 StringRef Param = Ident->Ident->getName();
1372 if (!SetTypestateAttr::ConvertStrToConsumedState(Param, NewState)) {
1373 S.Diag(Ident->Loc, diag::warn_attribute_type_not_supported) << AL
1374 << Param;
1375 return;
1376 }
1377 } else {
1378 S.Diag(AL.getLoc(), diag::err_attribute_argument_type)
1379 << AL << AANT_ArgumentIdentifier;
1380 return;
1381 }
1382
1383 D->addAttr(::new (S.Context) SetTypestateAttr(S.Context, AL, NewState));
1384}
1385
1386static void handleTestTypestateAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1387 if (!checkForConsumableClass(S, cast<CXXMethodDecl>(D), AL))
1388 return;
1389
1390 TestTypestateAttr::ConsumedState TestState;
1391 if (AL.isArgIdent(0)) {
1392 IdentifierLoc *Ident = AL.getArgAsIdent(0);
1393 StringRef Param = Ident->Ident->getName();
1394 if (!TestTypestateAttr::ConvertStrToConsumedState(Param, TestState)) {
1395 S.Diag(Ident->Loc, diag::warn_attribute_type_not_supported) << AL
1396 << Param;
1397 return;
1398 }
1399 } else {
1400 S.Diag(AL.getLoc(), diag::err_attribute_argument_type)
1401 << AL << AANT_ArgumentIdentifier;
1402 return;
1403 }
1404
1405 D->addAttr(::new (S.Context) TestTypestateAttr(S.Context, AL, TestState));
1406}
1407
1408static void handleExtVectorTypeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1409 // Remember this typedef decl, we will need it later for diagnostics.
1410 S.ExtVectorDecls.push_back(cast<TypedefNameDecl>(D));
1411}
1412
1413static void handlePackedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1414 if (auto *TD = dyn_cast<TagDecl>(D))
1415 TD->addAttr(::new (S.Context) PackedAttr(S.Context, AL));
1416 else if (auto *FD = dyn_cast<FieldDecl>(D)) {
1417 bool BitfieldByteAligned = (!FD->getType()->isDependentType() &&
1418 !FD->getType()->isIncompleteType() &&
1419 FD->isBitField() &&
1420 S.Context.getTypeAlign(FD->getType()) <= 8);
1421
1422 if (S.getASTContext().getTargetInfo().getTriple().isPS()) {
1423 if (BitfieldByteAligned)
1424 // The PS4/PS5 targets need to maintain ABI backwards compatibility.
1425 S.Diag(AL.getLoc(), diag::warn_attribute_ignored_for_field_of_type)
1426 << AL << FD->getType();
1427 else
1428 FD->addAttr(::new (S.Context) PackedAttr(S.Context, AL));
1429 } else {
1430 // Report warning about changed offset in the newer compiler versions.
1431 if (BitfieldByteAligned)
1432 S.Diag(AL.getLoc(), diag::warn_attribute_packed_for_bitfield);
1433
1434 FD->addAttr(::new (S.Context) PackedAttr(S.Context, AL));
1435 }
1436
1437 } else
1438 S.Diag(AL.getLoc(), diag::warn_attribute_ignored) << AL;
1439}
1440
1441static void handlePreferredName(Sema &S, Decl *D, const ParsedAttr &AL) {
1442 auto *RD = cast<CXXRecordDecl>(D);
1443 ClassTemplateDecl *CTD = RD->getDescribedClassTemplate();
1444 assert(CTD && "attribute does not appertain to this declaration");
1445
1446 ParsedType PT = AL.getTypeArg();
1447 TypeSourceInfo *TSI = nullptr;
1448 QualType T = S.GetTypeFromParser(PT, &TSI);
1449 if (!TSI)
1450 TSI = S.Context.getTrivialTypeSourceInfo(T, AL.getLoc());
1451
1452 if (!T.hasQualifiers() && T->isTypedefNameType()) {
1453 // Find the template name, if this type names a template specialization.
1454 const TemplateDecl *Template = nullptr;
1455 if (const auto *CTSD = dyn_cast_if_present<ClassTemplateSpecializationDecl>(
1456 T->getAsCXXRecordDecl())) {
1457 Template = CTSD->getSpecializedTemplate();
1458 } else if (const auto *TST = T->getAs<TemplateSpecializationType>()) {
1459 while (TST && TST->isTypeAlias())
1460 TST = TST->getAliasedType()->getAs<TemplateSpecializationType>();
1461 if (TST)
1462 Template = TST->getTemplateName().getAsTemplateDecl();
1463 }
1464
1465 if (Template && declaresSameEntity(Template, CTD)) {
1466 D->addAttr(::new (S.Context) PreferredNameAttr(S.Context, AL, TSI));
1467 return;
1468 }
1469 }
1470
1471 S.Diag(AL.getLoc(), diag::err_attribute_preferred_name_arg_invalid)
1472 << T << CTD;
1473 if (const auto *TT = T->getAs<TypedefType>())
1474 S.Diag(TT->getDecl()->getLocation(), diag::note_entity_declared_at)
1475 << TT->getDecl();
1476}
1477
1478static bool checkIBOutletCommon(Sema &S, Decl *D, const ParsedAttr &AL) {
1479 // The IBOutlet/IBOutletCollection attributes only apply to instance
1480 // variables or properties of Objective-C classes. The outlet must also
1481 // have an object reference type.
1482 if (const auto *VD = dyn_cast<ObjCIvarDecl>(D)) {
1483 if (!VD->getType()->getAs<ObjCObjectPointerType>()) {
1484 S.Diag(AL.getLoc(), diag::warn_iboutlet_object_type)
1485 << AL << VD->getType() << 0;
1486 return false;
1487 }
1488 }
1489 else if (const auto *PD = dyn_cast<ObjCPropertyDecl>(D)) {
1490 if (!PD->getType()->getAs<ObjCObjectPointerType>()) {
1491 S.Diag(AL.getLoc(), diag::warn_iboutlet_object_type)
1492 << AL << PD->getType() << 1;
1493 return false;
1494 }
1495 }
1496 else {
1497 S.Diag(AL.getLoc(), diag::warn_attribute_iboutlet) << AL;
1498 return false;
1499 }
1500
1501 return true;
1502}
1503
1504static void handleIBOutlet(Sema &S, Decl *D, const ParsedAttr &AL) {
1505 if (!checkIBOutletCommon(S, D, AL))
1506 return;
1507
1508 D->addAttr(::new (S.Context) IBOutletAttr(S.Context, AL));
1509}
1510
1511static void handleIBOutletCollection(Sema &S, Decl *D, const ParsedAttr &AL) {
1512
1513 // The iboutletcollection attribute can have zero or one arguments.
1514 if (AL.getNumArgs() > 1) {
1515 S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) << AL << 1;
1516 return;
1517 }
1518
1519 if (!checkIBOutletCommon(S, D, AL))
1520 return;
1521
1522 ParsedType PT;
1523
1524 if (AL.hasParsedType())
1525 PT = AL.getTypeArg();
1526 else {
1527 PT = S.getTypeName(S.Context.Idents.get("NSObject"), AL.getLoc(),
1529 if (!PT) {
1530 S.Diag(AL.getLoc(), diag::err_iboutletcollection_type) << "NSObject";
1531 return;
1532 }
1533 }
1534
1535 TypeSourceInfo *QTLoc = nullptr;
1536 QualType QT = S.GetTypeFromParser(PT, &QTLoc);
1537 if (!QTLoc)
1538 QTLoc = S.Context.getTrivialTypeSourceInfo(QT, AL.getLoc());
1539
1540 // Diagnose use of non-object type in iboutletcollection attribute.
1541 // FIXME. Gnu attribute extension ignores use of builtin types in
1542 // attributes. So, __attribute__((iboutletcollection(char))) will be
1543 // treated as __attribute__((iboutletcollection())).
1544 if (!QT->isObjCIdType() && !QT->isObjCObjectType()) {
1545 S.Diag(AL.getLoc(),
1546 QT->isBuiltinType() ? diag::err_iboutletcollection_builtintype
1547 : diag::err_iboutletcollection_type) << QT;
1548 return;
1549 }
1550
1551 D->addAttr(::new (S.Context) IBOutletCollectionAttr(S.Context, AL, QTLoc));
1552}
1553
1555 if (RefOkay) {
1556 if (T->isReferenceType())
1557 return true;
1558 } else {
1559 T = T.getNonReferenceType();
1560 }
1561
1562 // The nonnull attribute, and other similar attributes, can be applied to a
1563 // transparent union that contains a pointer type.
1564 if (const RecordType *UT = T->getAsUnionType()) {
1565 if (UT && UT->getDecl()->hasAttr<TransparentUnionAttr>()) {
1566 RecordDecl *UD = UT->getDecl();
1567 for (const auto *I : UD->fields()) {
1568 QualType QT = I->getType();
1569 if (QT->isAnyPointerType() || QT->isBlockPointerType())
1570 return true;
1571 }
1572 }
1573 }
1574
1575 return T->isAnyPointerType() || T->isBlockPointerType();
1576}
1577
1578static bool attrNonNullArgCheck(Sema &S, QualType T, const ParsedAttr &AL,
1579 SourceRange AttrParmRange,
1580 SourceRange TypeRange,
1581 bool isReturnValue = false) {
1582 if (!S.isValidPointerAttrType(T)) {
1583 if (isReturnValue)
1584 S.Diag(AL.getLoc(), diag::warn_attribute_return_pointers_only)
1585 << AL << AttrParmRange << TypeRange;
1586 else
1587 S.Diag(AL.getLoc(), diag::warn_attribute_pointers_only)
1588 << AL << AttrParmRange << TypeRange << 0;
1589 return false;
1590 }
1591 return true;
1592}
1593
1594static void handleNonNullAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1595 SmallVector<ParamIdx, 8> NonNullArgs;
1596 for (unsigned I = 0; I < AL.getNumArgs(); ++I) {
1597 Expr *Ex = AL.getArgAsExpr(I);
1598 ParamIdx Idx;
1599 if (!checkFunctionOrMethodParameterIndex(S, D, AL, I + 1, Ex, Idx))
1600 return;
1601
1602 // Is the function argument a pointer type?
1606 Ex->getSourceRange(),
1608 continue;
1609
1610 NonNullArgs.push_back(Idx);
1611 }
1612
1613 // If no arguments were specified to __attribute__((nonnull)) then all pointer
1614 // arguments have a nonnull attribute; warn if there aren't any. Skip this
1615 // check if the attribute came from a macro expansion or a template
1616 // instantiation.
1617 if (NonNullArgs.empty() && AL.getLoc().isFileID() &&
1619 bool AnyPointers = isFunctionOrMethodVariadic(D);
1620 for (unsigned I = 0, E = getFunctionOrMethodNumParams(D);
1621 I != E && !AnyPointers; ++I) {
1623 if (T->isDependentType() || S.isValidPointerAttrType(T))
1624 AnyPointers = true;
1625 }
1626
1627 if (!AnyPointers)
1628 S.Diag(AL.getLoc(), diag::warn_attribute_nonnull_no_pointers);
1629 }
1630
1631 ParamIdx *Start = NonNullArgs.data();
1632 unsigned Size = NonNullArgs.size();
1633 llvm::array_pod_sort(Start, Start + Size);
1634 D->addAttr(::new (S.Context) NonNullAttr(S.Context, AL, Start, Size));
1635}
1636
1638 const ParsedAttr &AL) {
1639 if (AL.getNumArgs() > 0) {
1640 if (D->getFunctionType()) {
1641 handleNonNullAttr(S, D, AL);
1642 } else {
1643 S.Diag(AL.getLoc(), diag::warn_attribute_nonnull_parm_no_args)
1644 << D->getSourceRange();
1645 }
1646 return;
1647 }
1648
1649 // Is the argument a pointer type?
1650 if (!attrNonNullArgCheck(S, D->getType(), AL, SourceRange(),
1651 D->getSourceRange()))
1652 return;
1653
1654 D->addAttr(::new (S.Context) NonNullAttr(S.Context, AL, nullptr, 0));
1655}
1656
1657static void handleReturnsNonNullAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1660 if (!attrNonNullArgCheck(S, ResultType, AL, SourceRange(), SR,
1661 /* isReturnValue */ true))
1662 return;
1663
1664 D->addAttr(::new (S.Context) ReturnsNonNullAttr(S.Context, AL));
1665}
1666
1667static void handleNoEscapeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1668 if (D->isInvalidDecl())
1669 return;
1670
1671 // noescape only applies to pointer types.
1672 QualType T = cast<ParmVarDecl>(D)->getType();
1673 if (!S.isValidPointerAttrType(T, /* RefOkay */ true)) {
1674 S.Diag(AL.getLoc(), diag::warn_attribute_pointers_only)
1675 << AL << AL.getRange() << 0;
1676 return;
1677 }
1678
1679 D->addAttr(::new (S.Context) NoEscapeAttr(S.Context, AL));
1680}
1681
1682static void handleAssumeAlignedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1683 Expr *E = AL.getArgAsExpr(0),
1684 *OE = AL.getNumArgs() > 1 ? AL.getArgAsExpr(1) : nullptr;
1685 S.AddAssumeAlignedAttr(D, AL, E, OE);
1686}
1687
1688static void handleAllocAlignAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1689 S.AddAllocAlignAttr(D, AL, AL.getArgAsExpr(0));
1690}
1691
1693 Expr *OE) {
1696
1697 AssumeAlignedAttr TmpAttr(Context, CI, E, OE);
1698 SourceLocation AttrLoc = TmpAttr.getLocation();
1699
1700 if (!isValidPointerAttrType(ResultType, /* RefOkay */ true)) {
1701 Diag(AttrLoc, diag::warn_attribute_return_pointers_refs_only)
1702 << &TmpAttr << TmpAttr.getRange() << SR;
1703 return;
1704 }
1705
1706 if (!E->isValueDependent()) {
1707 std::optional<llvm::APSInt> I = llvm::APSInt(64);
1708 if (!(I = E->getIntegerConstantExpr(Context))) {
1709 if (OE)
1710 Diag(AttrLoc, diag::err_attribute_argument_n_type)
1711 << &TmpAttr << 1 << AANT_ArgumentIntegerConstant
1712 << E->getSourceRange();
1713 else
1714 Diag(AttrLoc, diag::err_attribute_argument_type)
1715 << &TmpAttr << AANT_ArgumentIntegerConstant
1716 << E->getSourceRange();
1717 return;
1718 }
1719
1720 if (!I->isPowerOf2()) {
1721 Diag(AttrLoc, diag::err_alignment_not_power_of_two)
1722 << E->getSourceRange();
1723 return;
1724 }
1725
1726 if (*I > Sema::MaximumAlignment)
1727 Diag(CI.getLoc(), diag::warn_assume_aligned_too_great)
1729 }
1730
1731 if (OE && !OE->isValueDependent() && !OE->isIntegerConstantExpr(Context)) {
1732 Diag(AttrLoc, diag::err_attribute_argument_n_type)
1733 << &TmpAttr << 2 << AANT_ArgumentIntegerConstant
1734 << OE->getSourceRange();
1735 return;
1736 }
1737
1738 D->addAttr(::new (Context) AssumeAlignedAttr(Context, CI, E, OE));
1739}
1740
1742 Expr *ParamExpr) {
1744
1745 AllocAlignAttr TmpAttr(Context, CI, ParamIdx());
1746 SourceLocation AttrLoc = CI.getLoc();
1747
1748 if (!ResultType->isDependentType() &&
1749 !isValidPointerAttrType(ResultType, /* RefOkay */ true)) {
1750 Diag(AttrLoc, diag::warn_attribute_return_pointers_refs_only)
1751 << &TmpAttr << CI.getRange() << getFunctionOrMethodResultSourceRange(D);
1752 return;
1753 }
1754
1755 ParamIdx Idx;
1756 const auto *FuncDecl = cast<FunctionDecl>(D);
1757 if (!checkFunctionOrMethodParameterIndex(*this, FuncDecl, TmpAttr,
1758 /*AttrArgNum=*/1, ParamExpr, Idx))
1759 return;
1760
1762 if (!Ty->isDependentType() && !Ty->isIntegralType(Context) &&
1763 !Ty->isAlignValT()) {
1764 Diag(ParamExpr->getBeginLoc(), diag::err_attribute_integers_only)
1765 << &TmpAttr
1766 << FuncDecl->getParamDecl(Idx.getASTIndex())->getSourceRange();
1767 return;
1768 }
1769
1770 D->addAttr(::new (Context) AllocAlignAttr(Context, CI, Idx));
1771}
1772
1773/// Check if \p AssumptionStr is a known assumption and warn if not.
1775 StringRef AssumptionStr) {
1776 if (llvm::KnownAssumptionStrings.count(AssumptionStr))
1777 return;
1778
1779 unsigned BestEditDistance = 3;
1780 StringRef Suggestion;
1781 for (const auto &KnownAssumptionIt : llvm::KnownAssumptionStrings) {
1782 unsigned EditDistance =
1783 AssumptionStr.edit_distance(KnownAssumptionIt.getKey());
1784 if (EditDistance < BestEditDistance) {
1785 Suggestion = KnownAssumptionIt.getKey();
1786 BestEditDistance = EditDistance;
1787 }
1788 }
1789
1790 if (!Suggestion.empty())
1791 S.Diag(Loc, diag::warn_assume_attribute_string_unknown_suggested)
1792 << AssumptionStr << Suggestion;
1793 else
1794 S.Diag(Loc, diag::warn_assume_attribute_string_unknown) << AssumptionStr;
1795}
1796
1797static void handleAssumumptionAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1798 // Handle the case where the attribute has a text message.
1799 StringRef Str;
1800 SourceLocation AttrStrLoc;
1801 if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &AttrStrLoc))
1802 return;
1803
1804 checkAssumptionAttr(S, AttrStrLoc, Str);
1805
1806 D->addAttr(::new (S.Context) AssumptionAttr(S.Context, AL, Str));
1807}
1808
1809/// Normalize the attribute, __foo__ becomes foo.
1810/// Returns true if normalization was applied.
1811static bool normalizeName(StringRef &AttrName) {
1812 if (AttrName.size() > 4 && AttrName.starts_with("__") &&
1813 AttrName.ends_with("__")) {
1814 AttrName = AttrName.drop_front(2).drop_back(2);
1815 return true;
1816 }
1817 return false;
1818}
1819
1820static void handleOwnershipAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1821 // This attribute must be applied to a function declaration. The first
1822 // argument to the attribute must be an identifier, the name of the resource,
1823 // for example: malloc. The following arguments must be argument indexes, the
1824 // arguments must be of integer type for Returns, otherwise of pointer type.
1825 // The difference between Holds and Takes is that a pointer may still be used
1826 // after being held. free() should be __attribute((ownership_takes)), whereas
1827 // a list append function may well be __attribute((ownership_holds)).
1828
1829 if (!AL.isArgIdent(0)) {
1830 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
1831 << AL << 1 << AANT_ArgumentIdentifier;
1832 return;
1833 }
1834
1835 // Figure out our Kind.
1836 OwnershipAttr::OwnershipKind K =
1837 OwnershipAttr(S.Context, AL, nullptr, nullptr, 0).getOwnKind();
1838
1839 // Check arguments.
1840 switch (K) {
1841 case OwnershipAttr::Takes:
1842 case OwnershipAttr::Holds:
1843 if (AL.getNumArgs() < 2) {
1844 S.Diag(AL.getLoc(), diag::err_attribute_too_few_arguments) << AL << 2;
1845 return;
1846 }
1847 break;
1848 case OwnershipAttr::Returns:
1849 if (AL.getNumArgs() > 2) {
1850 S.Diag(AL.getLoc(), diag::err_attribute_too_many_arguments) << AL << 1;
1851 return;
1852 }
1853 break;
1854 }
1855
1857
1858 StringRef ModuleName = Module->getName();
1859 if (normalizeName(ModuleName)) {
1860 Module = &S.PP.getIdentifierTable().get(ModuleName);
1861 }
1862
1863 SmallVector<ParamIdx, 8> OwnershipArgs;
1864 for (unsigned i = 1; i < AL.getNumArgs(); ++i) {
1865 Expr *Ex = AL.getArgAsExpr(i);
1866 ParamIdx Idx;
1867 if (!checkFunctionOrMethodParameterIndex(S, D, AL, i, Ex, Idx))
1868 return;
1869
1870 // Is the function argument a pointer type?
1872 int Err = -1; // No error
1873 switch (K) {
1874 case OwnershipAttr::Takes:
1875 case OwnershipAttr::Holds:
1876 if (!T->isAnyPointerType() && !T->isBlockPointerType())
1877 Err = 0;
1878 break;
1879 case OwnershipAttr::Returns:
1880 if (!T->isIntegerType())
1881 Err = 1;
1882 break;
1883 }
1884 if (-1 != Err) {
1885 S.Diag(AL.getLoc(), diag::err_ownership_type) << AL << Err
1886 << Ex->getSourceRange();
1887 return;
1888 }
1889
1890 // Check we don't have a conflict with another ownership attribute.
1891 for (const auto *I : D->specific_attrs<OwnershipAttr>()) {
1892 // Cannot have two ownership attributes of different kinds for the same
1893 // index.
1894 if (I->getOwnKind() != K && llvm::is_contained(I->args(), Idx)) {
1895 S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible)
1896 << AL << I
1897 << (AL.isRegularKeywordAttribute() ||
1898 I->isRegularKeywordAttribute());
1899 return;
1900 } else if (K == OwnershipAttr::Returns &&
1901 I->getOwnKind() == OwnershipAttr::Returns) {
1902 // A returns attribute conflicts with any other returns attribute using
1903 // a different index.
1904 if (!llvm::is_contained(I->args(), Idx)) {
1905 S.Diag(I->getLocation(), diag::err_ownership_returns_index_mismatch)
1906 << I->args_begin()->getSourceIndex();
1907 if (I->args_size())
1908 S.Diag(AL.getLoc(), diag::note_ownership_returns_index_mismatch)
1909 << Idx.getSourceIndex() << Ex->getSourceRange();
1910 return;
1911 }
1912 }
1913 }
1914 OwnershipArgs.push_back(Idx);
1915 }
1916
1917 ParamIdx *Start = OwnershipArgs.data();
1918 unsigned Size = OwnershipArgs.size();
1919 llvm::array_pod_sort(Start, Start + Size);
1920 D->addAttr(::new (S.Context)
1921 OwnershipAttr(S.Context, AL, Module, Start, Size));
1922}
1923
1924static void handleWeakRefAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1925 // Check the attribute arguments.
1926 if (AL.getNumArgs() > 1) {
1927 S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) << AL << 1;
1928 return;
1929 }
1930
1931 // gcc rejects
1932 // class c {
1933 // static int a __attribute__((weakref ("v2")));
1934 // static int b() __attribute__((weakref ("f3")));
1935 // };
1936 // and ignores the attributes of
1937 // void f(void) {
1938 // static int a __attribute__((weakref ("v2")));
1939 // }
1940 // we reject them
1941 const DeclContext *Ctx = D->getDeclContext()->getRedeclContext();
1942 if (!Ctx->isFileContext()) {
1943 S.Diag(AL.getLoc(), diag::err_attribute_weakref_not_global_context)
1944 << cast<NamedDecl>(D);
1945 return;
1946 }
1947
1948 // The GCC manual says
1949 //
1950 // At present, a declaration to which `weakref' is attached can only
1951 // be `static'.
1952 //
1953 // It also says
1954 //
1955 // Without a TARGET,
1956 // given as an argument to `weakref' or to `alias', `weakref' is
1957 // equivalent to `weak'.
1958 //
1959 // gcc 4.4.1 will accept
1960 // int a7 __attribute__((weakref));
1961 // as
1962 // int a7 __attribute__((weak));
1963 // This looks like a bug in gcc. We reject that for now. We should revisit
1964 // it if this behaviour is actually used.
1965
1966 // GCC rejects
1967 // static ((alias ("y"), weakref)).
1968 // Should we? How to check that weakref is before or after alias?
1969
1970 // FIXME: it would be good for us to keep the WeakRefAttr as-written instead
1971 // of transforming it into an AliasAttr. The WeakRefAttr never uses the
1972 // StringRef parameter it was given anyway.
1973 StringRef Str;
1974 if (AL.getNumArgs() && S.checkStringLiteralArgumentAttr(AL, 0, Str))
1975 // GCC will accept anything as the argument of weakref. Should we
1976 // check for an existing decl?
1977 D->addAttr(::new (S.Context) AliasAttr(S.Context, AL, Str));
1978
1979 D->addAttr(::new (S.Context) WeakRefAttr(S.Context, AL));
1980}
1981
1982static void handleIFuncAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1983 StringRef Str;
1984 if (!S.checkStringLiteralArgumentAttr(AL, 0, Str))
1985 return;
1986
1987 // Aliases should be on declarations, not definitions.
1988 const auto *FD = cast<FunctionDecl>(D);
1989 if (FD->isThisDeclarationADefinition()) {
1990 S.Diag(AL.getLoc(), diag::err_alias_is_definition) << FD << 1;
1991 return;
1992 }
1993
1994 D->addAttr(::new (S.Context) IFuncAttr(S.Context, AL, Str));
1995}
1996
1997static void handleAliasAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1998 StringRef Str;
1999 if (!S.checkStringLiteralArgumentAttr(AL, 0, Str))
2000 return;
2001
2002 if (S.Context.getTargetInfo().getTriple().isOSDarwin()) {
2003 S.Diag(AL.getLoc(), diag::err_alias_not_supported_on_darwin);
2004 return;
2005 }
2006
2007 if (S.Context.getTargetInfo().getTriple().isNVPTX()) {
2008 CudaVersion Version =
2010 if (Version != CudaVersion::UNKNOWN && Version < CudaVersion::CUDA_100)
2011 S.Diag(AL.getLoc(), diag::err_alias_not_supported_on_nvptx);
2012 }
2013
2014 // Aliases should be on declarations, not definitions.
2015 if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
2016 if (FD->isThisDeclarationADefinition()) {
2017 S.Diag(AL.getLoc(), diag::err_alias_is_definition) << FD << 0;
2018 return;
2019 }
2020 } else {
2021 const auto *VD = cast<VarDecl>(D);
2022 if (VD->isThisDeclarationADefinition() && VD->isExternallyVisible()) {
2023 S.Diag(AL.getLoc(), diag::err_alias_is_definition) << VD << 0;
2024 return;
2025 }
2026 }
2027
2028 // Mark target used to prevent unneeded-internal-declaration warnings.
2029 if (!S.LangOpts.CPlusPlus) {
2030 // FIXME: demangle Str for C++, as the attribute refers to the mangled
2031 // linkage name, not the pre-mangled identifier.
2032 const DeclarationNameInfo target(&S.Context.Idents.get(Str), AL.getLoc());
2035 for (NamedDecl *ND : LR)
2036 ND->markUsed(S.Context);
2037 }
2038
2039 D->addAttr(::new (S.Context) AliasAttr(S.Context, AL, Str));
2040}
2041
2042static void handleTLSModelAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2043 StringRef Model;
2044 SourceLocation LiteralLoc;
2045 // Check that it is a string.
2046 if (!S.checkStringLiteralArgumentAttr(AL, 0, Model, &LiteralLoc))
2047 return;
2048
2049 // Check that the value.
2050 if (Model != "global-dynamic" && Model != "local-dynamic"
2051 && Model != "initial-exec" && Model != "local-exec") {
2052 S.Diag(LiteralLoc, diag::err_attr_tlsmodel_arg);
2053 return;
2054 }
2055
2056 if (S.Context.getTargetInfo().getTriple().isOSAIX() &&
2057 Model == "local-dynamic") {
2058 S.Diag(LiteralLoc, diag::err_aix_attr_unsupported_tls_model) << Model;
2059 return;
2060 }
2061
2062 D->addAttr(::new (S.Context) TLSModelAttr(S.Context, AL, Model));
2063}
2064
2065static void handleRestrictAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2067 if (ResultType->isAnyPointerType() || ResultType->isBlockPointerType()) {
2068 D->addAttr(::new (S.Context) RestrictAttr(S.Context, AL));
2069 return;
2070 }
2071
2072 S.Diag(AL.getLoc(), diag::warn_attribute_return_pointers_only)
2074}
2075
2076static void handleCPUSpecificAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2077 // Ensure we don't combine these with themselves, since that causes some
2078 // confusing behavior.
2079 if (AL.getParsedKind() == ParsedAttr::AT_CPUDispatch) {
2080 if (checkAttrMutualExclusion<CPUSpecificAttr>(S, D, AL))
2081 return;
2082
2083 if (const auto *Other = D->getAttr<CPUDispatchAttr>()) {
2084 S.Diag(AL.getLoc(), diag::err_disallowed_duplicate_attribute) << AL;
2085 S.Diag(Other->getLocation(), diag::note_conflicting_attribute);
2086 return;
2087 }
2088 } else if (AL.getParsedKind() == ParsedAttr::AT_CPUSpecific) {
2089 if (checkAttrMutualExclusion<CPUDispatchAttr>(S, D, AL))
2090 return;
2091
2092 if (const auto *Other = D->getAttr<CPUSpecificAttr>()) {
2093 S.Diag(AL.getLoc(), diag::err_disallowed_duplicate_attribute) << AL;
2094 S.Diag(Other->getLocation(), diag::note_conflicting_attribute);
2095 return;
2096 }
2097 }
2098
2099 FunctionDecl *FD = cast<FunctionDecl>(D);
2100
2101 if (const auto *MD = dyn_cast<CXXMethodDecl>(D)) {
2102 if (MD->getParent()->isLambda()) {
2103 S.Diag(AL.getLoc(), diag::err_attribute_dll_lambda) << AL;
2104 return;
2105 }
2106 }
2107
2108 if (!AL.checkAtLeastNumArgs(S, 1))
2109 return;
2110
2112 for (unsigned ArgNo = 0; ArgNo < getNumAttributeArgs(AL); ++ArgNo) {
2113 if (!AL.isArgIdent(ArgNo)) {
2114 S.Diag(AL.getLoc(), diag::err_attribute_argument_type)
2115 << AL << AANT_ArgumentIdentifier;
2116 return;
2117 }
2118
2119 IdentifierLoc *CPUArg = AL.getArgAsIdent(ArgNo);
2120 StringRef CPUName = CPUArg->Ident->getName().trim();
2121
2123 S.Diag(CPUArg->Loc, diag::err_invalid_cpu_specific_dispatch_value)
2124 << CPUName << (AL.getKind() == ParsedAttr::AT_CPUDispatch);
2125 return;
2126 }
2127
2129 if (llvm::any_of(CPUs, [CPUName, &Target](const IdentifierInfo *Cur) {
2130 return Target.CPUSpecificManglingCharacter(CPUName) ==
2131 Target.CPUSpecificManglingCharacter(Cur->getName());
2132 })) {
2133 S.Diag(AL.getLoc(), diag::warn_multiversion_duplicate_entries);
2134 return;
2135 }
2136 CPUs.push_back(CPUArg->Ident);
2137 }
2138
2139 FD->setIsMultiVersion(true);
2140 if (AL.getKind() == ParsedAttr::AT_CPUSpecific)
2141 D->addAttr(::new (S.Context)
2142 CPUSpecificAttr(S.Context, AL, CPUs.data(), CPUs.size()));
2143 else
2144 D->addAttr(::new (S.Context)
2145 CPUDispatchAttr(S.Context, AL, CPUs.data(), CPUs.size()));
2146}
2147
2148static void handleCommonAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2149 if (S.LangOpts.CPlusPlus) {
2150 S.Diag(AL.getLoc(), diag::err_attribute_not_supported_in_lang)
2152 return;
2153 }
2154
2155 D->addAttr(::new (S.Context) CommonAttr(S.Context, AL));
2156}
2157
2158static void handleCmseNSEntryAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2159 if (S.LangOpts.CPlusPlus && !D->getDeclContext()->isExternCContext()) {
2160 S.Diag(AL.getLoc(), diag::err_attribute_not_clinkage) << AL;
2161 return;
2162 }
2163
2164 const auto *FD = cast<FunctionDecl>(D);
2165 if (!FD->isExternallyVisible()) {
2166 S.Diag(AL.getLoc(), diag::warn_attribute_cmse_entry_static);
2167 return;
2168 }
2169
2170 D->addAttr(::new (S.Context) CmseNSEntryAttr(S.Context, AL));
2171}
2172
2173static void handleNakedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2174 if (AL.isDeclspecAttribute()) {
2175 const auto &Triple = S.getASTContext().getTargetInfo().getTriple();
2176 const auto &Arch = Triple.getArch();
2177 if (Arch != llvm::Triple::x86 &&
2178 (Arch != llvm::Triple::arm && Arch != llvm::Triple::thumb)) {
2179 S.Diag(AL.getLoc(), diag::err_attribute_not_supported_on_arch)
2180 << AL << Triple.getArchName();
2181 return;
2182 }
2183
2184 // This form is not allowed to be written on a member function (static or
2185 // nonstatic) when in Microsoft compatibility mode.
2186 if (S.getLangOpts().MSVCCompat && isa<CXXMethodDecl>(D)) {
2187 S.Diag(AL.getLoc(), diag::err_attribute_wrong_decl_type_str)
2188 << AL << AL.isRegularKeywordAttribute() << "non-member functions";
2189 return;
2190 }
2191 }
2192
2193 D->addAttr(::new (S.Context) NakedAttr(S.Context, AL));
2194}
2195
2196static void handleNoReturnAttr(Sema &S, Decl *D, const ParsedAttr &Attrs) {
2197 if (hasDeclarator(D)) return;
2198
2199 if (!isa<ObjCMethodDecl>(D)) {
2200 S.Diag(Attrs.getLoc(), diag::warn_attribute_wrong_decl_type)
2201 << Attrs << Attrs.isRegularKeywordAttribute()
2203 return;
2204 }
2205
2206 D->addAttr(::new (S.Context) NoReturnAttr(S.Context, Attrs));
2207}
2208
2209static void handleStandardNoReturnAttr(Sema &S, Decl *D, const ParsedAttr &A) {
2210 // The [[_Noreturn]] spelling is deprecated in C23, so if that was used,
2211 // issue an appropriate diagnostic. However, don't issue a diagnostic if the
2212 // attribute name comes from a macro expansion. We don't want to punish users
2213 // who write [[noreturn]] after including <stdnoreturn.h> (where 'noreturn'
2214 // is defined as a macro which expands to '_Noreturn').
2215 if (!S.getLangOpts().CPlusPlus &&
2216 A.getSemanticSpelling() == CXX11NoReturnAttr::C23_Noreturn &&
2217 !(A.getLoc().isMacroID() &&
2219 S.Diag(A.getLoc(), diag::warn_deprecated_noreturn_spelling) << A.getRange();
2220
2221 D->addAttr(::new (S.Context) CXX11NoReturnAttr(S.Context, A));
2222}
2223
2224static void handleNoCfCheckAttr(Sema &S, Decl *D, const ParsedAttr &Attrs) {
2225 if (!S.getLangOpts().CFProtectionBranch)
2226 S.Diag(Attrs.getLoc(), diag::warn_nocf_check_attribute_ignored);
2227 else
2228 handleSimpleAttribute<AnyX86NoCfCheckAttr>(S, D, Attrs);
2229}
2230
2232 if (!Attrs.checkExactlyNumArgs(*this, 0)) {
2233 Attrs.setInvalid();
2234 return true;
2235 }
2236
2237 return false;
2238}
2239
2241 // Check whether the attribute is valid on the current target.
2244 ? diag::err_keyword_not_supported_on_target
2245 : diag::warn_unknown_attribute_ignored)
2246 << AL << AL.getRange();
2247 AL.setInvalid();
2248 return true;
2249 }
2250
2251 return false;
2252}
2253
2254static void handleAnalyzerNoReturnAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2255
2256 // The checking path for 'noreturn' and 'analyzer_noreturn' are different
2257 // because 'analyzer_noreturn' does not impact the type.
2258 if (!isFunctionOrMethodOrBlock(D)) {
2259 ValueDecl *VD = dyn_cast<ValueDecl>(D);
2260 if (!VD || (!VD->getType()->isBlockPointerType() &&
2261 !VD->getType()->isFunctionPointerType())) {
2263 ? diag::err_attribute_wrong_decl_type
2264 : diag::warn_attribute_wrong_decl_type)
2265 << AL << AL.isRegularKeywordAttribute()
2267 return;
2268 }
2269 }
2270
2271 D->addAttr(::new (S.Context) AnalyzerNoReturnAttr(S.Context, AL));
2272}
2273
2274// PS3 PPU-specific.
2275static void handleVecReturnAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2276 /*
2277 Returning a Vector Class in Registers
2278
2279 According to the PPU ABI specifications, a class with a single member of
2280 vector type is returned in memory when used as the return value of a
2281 function.
2282 This results in inefficient code when implementing vector classes. To return
2283 the value in a single vector register, add the vecreturn attribute to the
2284 class definition. This attribute is also applicable to struct types.
2285
2286 Example:
2287
2288 struct Vector
2289 {
2290 __vector float xyzw;
2291 } __attribute__((vecreturn));
2292
2293 Vector Add(Vector lhs, Vector rhs)
2294 {
2295 Vector result;
2296 result.xyzw = vec_add(lhs.xyzw, rhs.xyzw);
2297 return result; // This will be returned in a register
2298 }
2299 */
2300 if (VecReturnAttr *A = D->getAttr<VecReturnAttr>()) {
2301 S.Diag(AL.getLoc(), diag::err_repeat_attribute) << A;
2302 return;
2303 }
2304
2305 const auto *R = cast<RecordDecl>(D);
2306 int count = 0;
2307
2308 if (!isa<CXXRecordDecl>(R)) {
2309 S.Diag(AL.getLoc(), diag::err_attribute_vecreturn_only_vector_member);
2310 return;
2311 }
2312
2313 if (!cast<CXXRecordDecl>(R)->isPOD()) {
2314 S.Diag(AL.getLoc(), diag::err_attribute_vecreturn_only_pod_record);
2315 return;
2316 }
2317
2318 for (const auto *I : R->fields()) {
2319 if ((count == 1) || !I->getType()->isVectorType()) {
2320 S.Diag(AL.getLoc(), diag::err_attribute_vecreturn_only_vector_member);
2321 return;
2322 }
2323 count++;
2324 }
2325
2326 D->addAttr(::new (S.Context) VecReturnAttr(S.Context, AL));
2327}
2328
2330 const ParsedAttr &AL) {
2331 if (isa<ParmVarDecl>(D)) {
2332 // [[carries_dependency]] can only be applied to a parameter if it is a
2333 // parameter of a function declaration or lambda.
2335 S.Diag(AL.getLoc(),
2336 diag::err_carries_dependency_param_not_function_decl);
2337 return;
2338 }
2339 }
2340
2341 D->addAttr(::new (S.Context) CarriesDependencyAttr(S.Context, AL));
2342}
2343
2344static void handleUnusedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2345 bool IsCXX17Attr = AL.isCXX11Attribute() && !AL.getScopeName();
2346
2347 // If this is spelled as the standard C++17 attribute, but not in C++17, warn
2348 // about using it as an extension.
2349 if (!S.getLangOpts().CPlusPlus17 && IsCXX17Attr)
2350 S.Diag(AL.getLoc(), diag::ext_cxx17_attr) << AL;
2351
2352 D->addAttr(::new (S.Context) UnusedAttr(S.Context, AL));
2353}
2354
2355static void handleConstructorAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2356 uint32_t priority = ConstructorAttr::DefaultPriority;
2357 if (S.getLangOpts().HLSL && AL.getNumArgs()) {
2358 S.Diag(AL.getLoc(), diag::err_hlsl_init_priority_unsupported);
2359 return;
2360 }
2361 if (AL.getNumArgs() &&
2362 !checkUInt32Argument(S, AL, AL.getArgAsExpr(0), priority))
2363 return;
2364
2365 D->addAttr(::new (S.Context) ConstructorAttr(S.Context, AL, priority));
2366}
2367
2368static void handleDestructorAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2369 uint32_t priority = DestructorAttr::DefaultPriority;
2370 if (AL.getNumArgs() &&
2371 !checkUInt32Argument(S, AL, AL.getArgAsExpr(0), priority))
2372 return;
2373
2374 D->addAttr(::new (S.Context) DestructorAttr(S.Context, AL, priority));
2375}
2376
2377template <typename AttrTy>
2378static void handleAttrWithMessage(Sema &S, Decl *D, const ParsedAttr &AL) {
2379 // Handle the case where the attribute has a text message.
2380 StringRef Str;
2381 if (AL.getNumArgs() == 1 && !S.checkStringLiteralArgumentAttr(AL, 0, Str))
2382 return;
2383
2384 D->addAttr(::new (S.Context) AttrTy(S.Context, AL, Str));
2385}
2386
2388 const ParsedAttr &AL) {
2389 if (!cast<ObjCProtocolDecl>(D)->isThisDeclarationADefinition()) {
2390 S.Diag(AL.getLoc(), diag::err_objc_attr_protocol_requires_definition)
2391 << AL << AL.getRange();
2392 return;
2393 }
2394
2395 D->addAttr(::new (S.Context) ObjCExplicitProtocolImplAttr(S.Context, AL));
2396}
2397
2399 IdentifierInfo *Platform,
2400 VersionTuple Introduced,
2401 VersionTuple Deprecated,
2402 VersionTuple Obsoleted) {
2403 StringRef PlatformName
2404 = AvailabilityAttr::getPrettyPlatformName(Platform->getName());
2405 if (PlatformName.empty())
2406 PlatformName = Platform->getName();
2407
2408 // Ensure that Introduced <= Deprecated <= Obsoleted (although not all
2409 // of these steps are needed).
2410 if (!Introduced.empty() && !Deprecated.empty() &&
2411 !(Introduced <= Deprecated)) {
2412 S.Diag(Range.getBegin(), diag::warn_availability_version_ordering)
2413 << 1 << PlatformName << Deprecated.getAsString()
2414 << 0 << Introduced.getAsString();
2415 return true;
2416 }
2417
2418 if (!Introduced.empty() && !Obsoleted.empty() &&
2419 !(Introduced <= Obsoleted)) {
2420 S.Diag(Range.getBegin(), diag::warn_availability_version_ordering)
2421 << 2 << PlatformName << Obsoleted.getAsString()
2422 << 0 << Introduced.getAsString();
2423 return true;
2424 }
2425
2426 if (!Deprecated.empty() && !Obsoleted.empty() &&
2427 !(Deprecated <= Obsoleted)) {
2428 S.Diag(Range.getBegin(), diag::warn_availability_version_ordering)
2429 << 2 << PlatformName << Obsoleted.getAsString()
2430 << 1 << Deprecated.getAsString();
2431 return true;
2432 }
2433
2434 return false;
2435}
2436
2437/// Check whether the two versions match.
2438///
2439/// If either version tuple is empty, then they are assumed to match. If
2440/// \p BeforeIsOkay is true, then \p X can be less than or equal to \p Y.
2441static bool versionsMatch(const VersionTuple &X, const VersionTuple &Y,
2442 bool BeforeIsOkay) {
2443 if (X.empty() || Y.empty())
2444 return true;
2445
2446 if (X == Y)
2447 return true;
2448
2449 if (BeforeIsOkay && X < Y)
2450 return true;
2451
2452 return false;
2453}
2454
2456 NamedDecl *D, const AttributeCommonInfo &CI, IdentifierInfo *Platform,
2457 bool Implicit, VersionTuple Introduced, VersionTuple Deprecated,
2458 VersionTuple Obsoleted, bool IsUnavailable, StringRef Message,
2459 bool IsStrict, StringRef Replacement, AvailabilityMergeKind AMK,
2460 int Priority) {
2461 VersionTuple MergedIntroduced = Introduced;
2462 VersionTuple MergedDeprecated = Deprecated;
2463 VersionTuple MergedObsoleted = Obsoleted;
2464 bool FoundAny = false;
2465 bool OverrideOrImpl = false;
2466 switch (AMK) {
2467 case AMK_None:
2468 case AMK_Redeclaration:
2469 OverrideOrImpl = false;
2470 break;
2471
2472 case AMK_Override:
2475 OverrideOrImpl = true;
2476 break;
2477 }
2478
2479 if (D->hasAttrs()) {
2480 AttrVec &Attrs = D->getAttrs();
2481 for (unsigned i = 0, e = Attrs.size(); i != e;) {
2482 const auto *OldAA = dyn_cast<AvailabilityAttr>(Attrs[i]);
2483 if (!OldAA) {
2484 ++i;
2485 continue;
2486 }
2487
2488 IdentifierInfo *OldPlatform = OldAA->getPlatform();
2489 if (OldPlatform != Platform) {
2490 ++i;
2491 continue;
2492 }
2493
2494 // If there is an existing availability attribute for this platform that
2495 // has a lower priority use the existing one and discard the new
2496 // attribute.
2497 if (OldAA->getPriority() < Priority)
2498 return nullptr;
2499
2500 // If there is an existing attribute for this platform that has a higher
2501 // priority than the new attribute then erase the old one and continue
2502 // processing the attributes.
2503 if (OldAA->getPriority() > Priority) {
2504 Attrs.erase(Attrs.begin() + i);
2505 --e;
2506 continue;
2507 }
2508
2509 FoundAny = true;
2510 VersionTuple OldIntroduced = OldAA->getIntroduced();
2511 VersionTuple OldDeprecated = OldAA->getDeprecated();
2512 VersionTuple OldObsoleted = OldAA->getObsoleted();
2513 bool OldIsUnavailable = OldAA->getUnavailable();
2514
2515 if (!versionsMatch(OldIntroduced, Introduced, OverrideOrImpl) ||
2516 !versionsMatch(Deprecated, OldDeprecated, OverrideOrImpl) ||
2517 !versionsMatch(Obsoleted, OldObsoleted, OverrideOrImpl) ||
2518 !(OldIsUnavailable == IsUnavailable ||
2519 (OverrideOrImpl && !OldIsUnavailable && IsUnavailable))) {
2520 if (OverrideOrImpl) {
2521 int Which = -1;
2522 VersionTuple FirstVersion;
2523 VersionTuple SecondVersion;
2524 if (!versionsMatch(OldIntroduced, Introduced, OverrideOrImpl)) {
2525 Which = 0;
2526 FirstVersion = OldIntroduced;
2527 SecondVersion = Introduced;
2528 } else if (!versionsMatch(Deprecated, OldDeprecated, OverrideOrImpl)) {
2529 Which = 1;
2530 FirstVersion = Deprecated;
2531 SecondVersion = OldDeprecated;
2532 } else if (!versionsMatch(Obsoleted, OldObsoleted, OverrideOrImpl)) {
2533 Which = 2;
2534 FirstVersion = Obsoleted;
2535 SecondVersion = OldObsoleted;
2536 }
2537
2538 if (Which == -1) {
2539 Diag(OldAA->getLocation(),
2540 diag::warn_mismatched_availability_override_unavail)
2541 << AvailabilityAttr::getPrettyPlatformName(Platform->getName())
2542 << (AMK == AMK_Override);
2543 } else if (Which != 1 && AMK == AMK_OptionalProtocolImplementation) {
2544 // Allow different 'introduced' / 'obsoleted' availability versions
2545 // on a method that implements an optional protocol requirement. It
2546 // makes less sense to allow this for 'deprecated' as the user can't
2547 // see if the method is 'deprecated' as 'respondsToSelector' will
2548 // still return true when the method is deprecated.
2549 ++i;
2550 continue;
2551 } else {
2552 Diag(OldAA->getLocation(),
2553 diag::warn_mismatched_availability_override)
2554 << Which
2555 << AvailabilityAttr::getPrettyPlatformName(Platform->getName())
2556 << FirstVersion.getAsString() << SecondVersion.getAsString()
2557 << (AMK == AMK_Override);
2558 }
2559 if (AMK == AMK_Override)
2560 Diag(CI.getLoc(), diag::note_overridden_method);
2561 else
2562 Diag(CI.getLoc(), diag::note_protocol_method);
2563 } else {
2564 Diag(OldAA->getLocation(), diag::warn_mismatched_availability);
2565 Diag(CI.getLoc(), diag::note_previous_attribute);
2566 }
2567
2568 Attrs.erase(Attrs.begin() + i);
2569 --e;
2570 continue;
2571 }
2572
2573 VersionTuple MergedIntroduced2 = MergedIntroduced;
2574 VersionTuple MergedDeprecated2 = MergedDeprecated;
2575 VersionTuple MergedObsoleted2 = MergedObsoleted;
2576
2577 if (MergedIntroduced2.empty())
2578 MergedIntroduced2 = OldIntroduced;
2579 if (MergedDeprecated2.empty())
2580 MergedDeprecated2 = OldDeprecated;
2581 if (MergedObsoleted2.empty())
2582 MergedObsoleted2 = OldObsoleted;
2583
2584 if (checkAvailabilityAttr(*this, OldAA->getRange(), Platform,
2585 MergedIntroduced2, MergedDeprecated2,
2586 MergedObsoleted2)) {
2587 Attrs.erase(Attrs.begin() + i);
2588 --e;
2589 continue;
2590 }
2591
2592 MergedIntroduced = MergedIntroduced2;
2593 MergedDeprecated = MergedDeprecated2;
2594 MergedObsoleted = MergedObsoleted2;
2595 ++i;
2596 }
2597 }
2598
2599 if (FoundAny &&
2600 MergedIntroduced == Introduced &&
2601 MergedDeprecated == Deprecated &&
2602 MergedObsoleted == Obsoleted)
2603 return nullptr;
2604
2605 // Only create a new attribute if !OverrideOrImpl, but we want to do
2606 // the checking.
2607 if (!checkAvailabilityAttr(*this, CI.getRange(), Platform, MergedIntroduced,
2608 MergedDeprecated, MergedObsoleted) &&
2609 !OverrideOrImpl) {
2610 auto *Avail = ::new (Context) AvailabilityAttr(
2611 Context, CI, Platform, Introduced, Deprecated, Obsoleted, IsUnavailable,
2612 Message, IsStrict, Replacement, Priority);
2613 Avail->setImplicit(Implicit);
2614 return Avail;
2615 }
2616 return nullptr;
2617}
2618
2619static void handleAvailabilityAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2620 if (isa<UsingDecl, UnresolvedUsingTypenameDecl, UnresolvedUsingValueDecl>(
2621 D)) {
2622 S.Diag(AL.getRange().getBegin(), diag::warn_deprecated_ignored_on_using)
2623 << AL;
2624 return;
2625 }
2626
2627 if (!AL.checkExactlyNumArgs(S, 1))
2628 return;
2629 IdentifierLoc *Platform = AL.getArgAsIdent(0);
2630
2631 IdentifierInfo *II = Platform->Ident;
2632 if (AvailabilityAttr::getPrettyPlatformName(II->getName()).empty())
2633 S.Diag(Platform->Loc, diag::warn_availability_unknown_platform)
2634 << Platform->Ident;
2635
2636 auto *ND = dyn_cast<NamedDecl>(D);
2637 if (!ND) // We warned about this already, so just return.
2638 return;
2639
2643 bool IsUnavailable = AL.getUnavailableLoc().isValid();
2644 bool IsStrict = AL.getStrictLoc().isValid();
2645 StringRef Str;
2646 if (const auto *SE = dyn_cast_if_present<StringLiteral>(AL.getMessageExpr()))
2647 Str = SE->getString();
2648 StringRef Replacement;
2649 if (const auto *SE =
2650 dyn_cast_if_present<StringLiteral>(AL.getReplacementExpr()))
2651 Replacement = SE->getString();
2652
2653 if (II->isStr("swift")) {
2654 if (Introduced.isValid() || Obsoleted.isValid() ||
2655 (!IsUnavailable && !Deprecated.isValid())) {
2656 S.Diag(AL.getLoc(),
2657 diag::warn_availability_swift_unavailable_deprecated_only);
2658 return;
2659 }
2660 }
2661
2662 if (II->isStr("fuchsia")) {
2663 std::optional<unsigned> Min, Sub;
2664 if ((Min = Introduced.Version.getMinor()) ||
2665 (Sub = Introduced.Version.getSubminor())) {
2666 S.Diag(AL.getLoc(), diag::warn_availability_fuchsia_unavailable_minor);
2667 return;
2668 }
2669 }
2670
2671 int PriorityModifier = AL.isPragmaClangAttribute()
2674 AvailabilityAttr *NewAttr = S.mergeAvailabilityAttr(
2675 ND, AL, II, false /*Implicit*/, Introduced.Version, Deprecated.Version,
2676 Obsoleted.Version, IsUnavailable, Str, IsStrict, Replacement,
2677 Sema::AMK_None, PriorityModifier);
2678 if (NewAttr)
2679 D->addAttr(NewAttr);
2680
2681 // Transcribe "ios" to "watchos" (and add a new attribute) if the versioning
2682 // matches before the start of the watchOS platform.
2683 if (S.Context.getTargetInfo().getTriple().isWatchOS()) {
2684 IdentifierInfo *NewII = nullptr;
2685 if (II->getName() == "ios")
2686 NewII = &S.Context.Idents.get("watchos");
2687 else if (II->getName() == "ios_app_extension")
2688 NewII = &S.Context.Idents.get("watchos_app_extension");
2689
2690 if (NewII) {
2691 const auto *SDKInfo = S.getDarwinSDKInfoForAvailabilityChecking();
2692 const auto *IOSToWatchOSMapping =
2693 SDKInfo ? SDKInfo->getVersionMapping(
2695 : nullptr;
2696
2697 auto adjustWatchOSVersion =
2698 [IOSToWatchOSMapping](VersionTuple Version) -> VersionTuple {
2699 if (Version.empty())
2700 return Version;
2701 auto MinimumWatchOSVersion = VersionTuple(2, 0);
2702
2703 if (IOSToWatchOSMapping) {
2704 if (auto MappedVersion = IOSToWatchOSMapping->map(
2705 Version, MinimumWatchOSVersion, std::nullopt)) {
2706 return *MappedVersion;
2707 }
2708 }
2709
2710 auto Major = Version.getMajor();
2711 auto NewMajor = Major >= 9 ? Major - 7 : 0;
2712 if (NewMajor >= 2) {
2713 if (Version.getMinor()) {
2714 if (Version.getSubminor())
2715 return VersionTuple(NewMajor, *Version.getMinor(),
2716 *Version.getSubminor());
2717 else
2718 return VersionTuple(NewMajor, *Version.getMinor());
2719 }
2720 return VersionTuple(NewMajor);
2721 }
2722
2723 return MinimumWatchOSVersion;
2724 };
2725
2726 auto NewIntroduced = adjustWatchOSVersion(Introduced.Version);
2727 auto NewDeprecated = adjustWatchOSVersion(Deprecated.Version);
2728 auto NewObsoleted = adjustWatchOSVersion(Obsoleted.Version);
2729
2730 AvailabilityAttr *NewAttr = S.mergeAvailabilityAttr(
2731 ND, AL, NewII, true /*Implicit*/, NewIntroduced, NewDeprecated,
2732 NewObsoleted, IsUnavailable, Str, IsStrict, Replacement,
2734 PriorityModifier + Sema::AP_InferredFromOtherPlatform);
2735 if (NewAttr)
2736 D->addAttr(NewAttr);
2737 }
2738 } else if (S.Context.getTargetInfo().getTriple().isTvOS()) {
2739 // Transcribe "ios" to "tvos" (and add a new attribute) if the versioning
2740 // matches before the start of the tvOS platform.
2741 IdentifierInfo *NewII = nullptr;
2742 if (II->getName() == "ios")
2743 NewII = &S.Context.Idents.get("tvos");
2744 else if (II->getName() == "ios_app_extension")
2745 NewII = &S.Context.Idents.get("tvos_app_extension");
2746
2747 if (NewII) {
2748 const auto *SDKInfo = S.getDarwinSDKInfoForAvailabilityChecking();
2749 const auto *IOSToTvOSMapping =
2750 SDKInfo ? SDKInfo->getVersionMapping(
2752 : nullptr;
2753
2754 auto AdjustTvOSVersion =
2755 [IOSToTvOSMapping](VersionTuple Version) -> VersionTuple {
2756 if (Version.empty())
2757 return Version;
2758
2759 if (IOSToTvOSMapping) {
2760 if (auto MappedVersion = IOSToTvOSMapping->map(
2761 Version, VersionTuple(0, 0), std::nullopt)) {
2762 return *MappedVersion;
2763 }
2764 }
2765 return Version;
2766 };
2767
2768 auto NewIntroduced = AdjustTvOSVersion(Introduced.Version);
2769 auto NewDeprecated = AdjustTvOSVersion(Deprecated.Version);
2770 auto NewObsoleted = AdjustTvOSVersion(Obsoleted.Version);
2771
2772 AvailabilityAttr *NewAttr = S.mergeAvailabilityAttr(
2773 ND, AL, NewII, true /*Implicit*/, NewIntroduced, NewDeprecated,
2774 NewObsoleted, IsUnavailable, Str, IsStrict, Replacement,
2776 PriorityModifier + Sema::AP_InferredFromOtherPlatform);
2777 if (NewAttr)
2778 D->addAttr(NewAttr);
2779 }
2780 } else if (S.Context.getTargetInfo().getTriple().getOS() ==
2781 llvm::Triple::IOS &&
2782 S.Context.getTargetInfo().getTriple().isMacCatalystEnvironment()) {
2783 auto GetSDKInfo = [&]() {
2785 "macOS");
2786 };
2787
2788 // Transcribe "ios" to "maccatalyst" (and add a new attribute).
2789 IdentifierInfo *NewII = nullptr;
2790 if (II->getName() == "ios")
2791 NewII = &S.Context.Idents.get("maccatalyst");
2792 else if (II->getName() == "ios_app_extension")
2793 NewII = &S.Context.Idents.get("maccatalyst_app_extension");
2794 if (NewII) {
2795 auto MinMacCatalystVersion = [](const VersionTuple &V) {
2796 if (V.empty())
2797 return V;
2798 if (V.getMajor() < 13 ||
2799 (V.getMajor() == 13 && V.getMinor() && *V.getMinor() < 1))
2800 return VersionTuple(13, 1); // The min Mac Catalyst version is 13.1.
2801 return V;
2802 };
2803 AvailabilityAttr *NewAttr = S.mergeAvailabilityAttr(
2804 ND, AL, NewII, true /*Implicit*/,
2805 MinMacCatalystVersion(Introduced.Version),
2806 MinMacCatalystVersion(Deprecated.Version),
2807 MinMacCatalystVersion(Obsoleted.Version), IsUnavailable, Str,
2808 IsStrict, Replacement, Sema::AMK_None,
2809 PriorityModifier + Sema::AP_InferredFromOtherPlatform);
2810 if (NewAttr)
2811 D->addAttr(NewAttr);
2812 } else if (II->getName() == "macos" && GetSDKInfo() &&
2813 (!Introduced.Version.empty() || !Deprecated.Version.empty() ||
2814 !Obsoleted.Version.empty())) {
2815 if (const auto *MacOStoMacCatalystMapping =
2816 GetSDKInfo()->getVersionMapping(
2818 // Infer Mac Catalyst availability from the macOS availability attribute
2819 // if it has versioned availability. Don't infer 'unavailable'. This
2820 // inferred availability has lower priority than the other availability
2821 // attributes that are inferred from 'ios'.
2822 NewII = &S.Context.Idents.get("maccatalyst");
2823 auto RemapMacOSVersion =
2824 [&](const VersionTuple &V) -> std::optional<VersionTuple> {
2825 if (V.empty())
2826 return std::nullopt;
2827 // API_TO_BE_DEPRECATED is 100000.
2828 if (V.getMajor() == 100000)
2829 return VersionTuple(100000);
2830 // The minimum iosmac version is 13.1
2831 return MacOStoMacCatalystMapping->map(V, VersionTuple(13, 1),
2832 std::nullopt);
2833 };
2834 std::optional<VersionTuple> NewIntroduced =
2835 RemapMacOSVersion(Introduced.Version),
2836 NewDeprecated =
2837 RemapMacOSVersion(Deprecated.Version),
2838 NewObsoleted =
2839 RemapMacOSVersion(Obsoleted.Version);
2840 if (NewIntroduced || NewDeprecated || NewObsoleted) {
2841 auto VersionOrEmptyVersion =
2842 [](const std::optional<VersionTuple> &V) -> VersionTuple {
2843 return V ? *V : VersionTuple();
2844 };
2845 AvailabilityAttr *NewAttr = S.mergeAvailabilityAttr(
2846 ND, AL, NewII, true /*Implicit*/,
2847 VersionOrEmptyVersion(NewIntroduced),
2848 VersionOrEmptyVersion(NewDeprecated),
2849 VersionOrEmptyVersion(NewObsoleted), /*IsUnavailable=*/false, Str,
2850 IsStrict, Replacement, Sema::AMK_None,
2851 PriorityModifier + Sema::AP_InferredFromOtherPlatform +
2853 if (NewAttr)
2854 D->addAttr(NewAttr);
2855 }
2856 }
2857 }
2858 }
2859}
2860
2862 const ParsedAttr &AL) {
2863 if (!AL.checkAtLeastNumArgs(S, 1) || !AL.checkAtMostNumArgs(S, 4))
2864 return;
2865
2866 StringRef Language;
2867 if (const auto *SE = dyn_cast_if_present<StringLiteral>(AL.getArgAsExpr(0)))
2868 Language = SE->getString();
2869 StringRef DefinedIn;
2870 if (const auto *SE = dyn_cast_if_present<StringLiteral>(AL.getArgAsExpr(1)))
2871 DefinedIn = SE->getString();
2872 bool IsGeneratedDeclaration = AL.getArgAsIdent(2) != nullptr;
2873 StringRef USR;
2874 if (const auto *SE = dyn_cast_if_present<StringLiteral>(AL.getArgAsExpr(3)))
2875 USR = SE->getString();
2876
2877 D->addAttr(::new (S.Context) ExternalSourceSymbolAttr(
2878 S.Context, AL, Language, DefinedIn, IsGeneratedDeclaration, USR));
2879}
2880
2881template <class T>
2883 typename T::VisibilityType value) {
2884 T *existingAttr = D->getAttr<T>();
2885 if (existingAttr) {
2886 typename T::VisibilityType existingValue = existingAttr->getVisibility();
2887 if (existingValue == value)
2888 return nullptr;
2889 S.Diag(existingAttr->getLocation(), diag::err_mismatched_visibility);
2890 S.Diag(CI.getLoc(), diag::note_previous_attribute);
2891 D->dropAttr<T>();
2892 }
2893 return ::new (S.Context) T(S.Context, CI, value);
2894}
2895
2897 const AttributeCommonInfo &CI,
2898 VisibilityAttr::VisibilityType Vis) {
2899 return ::mergeVisibilityAttr<VisibilityAttr>(*this, D, CI, Vis);
2900}
2901
2902TypeVisibilityAttr *
2904 TypeVisibilityAttr::VisibilityType Vis) {
2905 return ::mergeVisibilityAttr<TypeVisibilityAttr>(*this, D, CI, Vis);
2906}
2907
2908static void handleVisibilityAttr(Sema &S, Decl *D, const ParsedAttr &AL,
2909 bool isTypeVisibility) {
2910 // Visibility attributes don't mean anything on a typedef.
2911 if (isa<TypedefNameDecl>(D)) {
2912 S.Diag(AL.getRange().getBegin(), diag::warn_attribute_ignored) << AL;
2913 return;
2914 }
2915
2916 // 'type_visibility' can only go on a type or namespace.
2917 if (isTypeVisibility && !(isa<TagDecl>(D) || isa<ObjCInterfaceDecl>(D) ||
2918 isa<NamespaceDecl>(D))) {
2919 S.Diag(AL.getRange().getBegin(), diag::err_attribute_wrong_decl_type)
2921 return;
2922 }
2923
2924 // Check that the argument is a string literal.
2925 StringRef TypeStr;
2926 SourceLocation LiteralLoc;
2927 if (!S.checkStringLiteralArgumentAttr(AL, 0, TypeStr, &LiteralLoc))
2928 return;
2929
2930 VisibilityAttr::VisibilityType type;
2931 if (!VisibilityAttr::ConvertStrToVisibilityType(TypeStr, type)) {
2932 S.Diag(LiteralLoc, diag::warn_attribute_type_not_supported) << AL
2933 << TypeStr;
2934 return;
2935 }
2936
2937 // Complain about attempts to use protected visibility on targets
2938 // (like Darwin) that don't support it.
2939 if (type == VisibilityAttr::Protected &&
2941 S.Diag(AL.getLoc(), diag::warn_attribute_protected_visibility);
2942 type = VisibilityAttr::Default;
2943 }
2944
2945 Attr *newAttr;
2946 if (isTypeVisibility) {
2947 newAttr = S.mergeTypeVisibilityAttr(
2948 D, AL, (TypeVisibilityAttr::VisibilityType)type);
2949 } else {
2950 newAttr = S.mergeVisibilityAttr(D, AL, type);
2951 }
2952 if (newAttr)
2953 D->addAttr(newAttr);
2954}
2955
2956static void handleObjCDirectAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2957 // objc_direct cannot be set on methods declared in the context of a protocol
2958 if (isa<ObjCProtocolDecl>(D->getDeclContext())) {
2959 S.Diag(AL.getLoc(), diag::err_objc_direct_on_protocol) << false;
2960 return;
2961 }
2962
2964 handleSimpleAttribute<ObjCDirectAttr>(S, D, AL);
2965 } else {
2966 S.Diag(AL.getLoc(), diag::warn_objc_direct_ignored) << AL;
2967 }
2968}
2969
2971 const ParsedAttr &AL) {
2973 handleSimpleAttribute<ObjCDirectMembersAttr>(S, D, AL);
2974 } else {
2975 S.Diag(AL.getLoc(), diag::warn_objc_direct_ignored) << AL;
2976 }
2977}
2978
2979static void handleObjCMethodFamilyAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2980 const auto *M = cast<ObjCMethodDecl>(D);
2981 if (!AL.isArgIdent(0)) {
2982 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
2983 << AL << 1 << AANT_ArgumentIdentifier;
2984 return;
2985 }
2986
2987 IdentifierLoc *IL = AL.getArgAsIdent(0);
2988 ObjCMethodFamilyAttr::FamilyKind F;
2989 if (!ObjCMethodFamilyAttr::ConvertStrToFamilyKind(IL->Ident->getName(), F)) {
2990 S.Diag(IL->Loc, diag::warn_attribute_type_not_supported) << AL << IL->Ident;
2991 return;
2992 }
2993
2994 if (F == ObjCMethodFamilyAttr::OMF_init &&
2995 !M->getReturnType()->isObjCObjectPointerType()) {
2996 S.Diag(M->getLocation(), diag::err_init_method_bad_return_type)
2997 << M->getReturnType();
2998 // Ignore the attribute.
2999 return;
3000 }
3001
3002 D->addAttr(new (S.Context) ObjCMethodFamilyAttr(S.Context, AL, F));
3003}
3004
3005static void handleObjCNSObject(Sema &S, Decl *D, const ParsedAttr &AL) {
3006 if (const auto *TD = dyn_cast<TypedefNameDecl>(D)) {
3007 QualType T = TD->getUnderlyingType();
3008 if (!T->isCARCBridgableType()) {
3009 S.Diag(TD->getLocation(), diag::err_nsobject_attribute);
3010 return;
3011 }
3012 }
3013 else if (const auto *PD = dyn_cast<ObjCPropertyDecl>(D)) {
3014 QualType T = PD->getType();
3015 if (!T->isCARCBridgableType()) {
3016 S.Diag(PD->getLocation(), diag::err_nsobject_attribute);
3017 return;
3018 }
3019 }
3020 else {
3021 // It is okay to include this attribute on properties, e.g.:
3022 //
3023 // @property (retain, nonatomic) struct Bork *Q __attribute__((NSObject));
3024 //
3025 // In this case it follows tradition and suppresses an error in the above
3026 // case.
3027 S.Diag(D->getLocation(), diag::warn_nsobject_attribute);
3028 }
3029 D->addAttr(::new (S.Context) ObjCNSObjectAttr(S.Context, AL));
3030}
3031
3032static void handleObjCIndependentClass(Sema &S, Decl *D, const ParsedAttr &AL) {
3033 if (const auto *TD = dyn_cast<TypedefNameDecl>(D)) {
3034 QualType T = TD->getUnderlyingType();
3035 if (!T->isObjCObjectPointerType()) {
3036 S.Diag(TD->getLocation(), diag::warn_ptr_independentclass_attribute);
3037 return;
3038 }
3039 } else {
3040 S.Diag(D->getLocation(), diag::warn_independentclass_attribute);
3041 return;
3042 }
3043 D->addAttr(::new (S.Context) ObjCIndependentClassAttr(S.Context, AL));
3044}
3045
3046static void handleBlocksAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3047 if (!AL.isArgIdent(0)) {
3048 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
3049 << AL << 1 << AANT_ArgumentIdentifier;
3050 return;
3051 }
3052
3053 IdentifierInfo *II = AL.getArgAsIdent(0)->Ident;
3054 BlocksAttr::BlockType type;
3055 if (!BlocksAttr::ConvertStrToBlockType(II->getName(), type)) {
3056 S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported) << AL << II;
3057 return;
3058 }
3059
3060 D->addAttr(::new (S.Context) BlocksAttr(S.Context, AL, type));
3061}
3062
3063static void handleSentinelAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3064 unsigned sentinel = (unsigned)SentinelAttr::DefaultSentinel;
3065 if (AL.getNumArgs() > 0) {
3066 Expr *E = AL.getArgAsExpr(0);
3067 std::optional<llvm::APSInt> Idx = llvm::APSInt(32);
3068 if (E->isTypeDependent() || !(Idx = E->getIntegerConstantExpr(S.Context))) {
3069 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
3070 << AL << 1 << AANT_ArgumentIntegerConstant << E->getSourceRange();
3071 return;
3072 }
3073
3074 if (Idx->isSigned() && Idx->isNegative()) {
3075 S.Diag(AL.getLoc(), diag::err_attribute_sentinel_less_than_zero)
3076 << E->getSourceRange();
3077 return;
3078 }
3079
3080 sentinel = Idx->getZExtValue();
3081 }
3082
3083 unsigned nullPos = (unsigned)SentinelAttr::DefaultNullPos;
3084 if (AL.getNumArgs() > 1) {
3085 Expr *E = AL.getArgAsExpr(1);
3086 std::optional<llvm::APSInt> Idx = llvm::APSInt(32);
3087 if (E->isTypeDependent() || !(Idx = E->getIntegerConstantExpr(S.Context))) {
3088 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
3089 << AL << 2 << AANT_ArgumentIntegerConstant << E->getSourceRange();
3090 return;
3091 }
3092 nullPos = Idx->getZExtValue();
3093
3094 if ((Idx->isSigned() && Idx->isNegative()) || nullPos > 1) {
3095 // FIXME: This error message could be improved, it would be nice
3096 // to say what the bounds actually are.
3097 S.Diag(AL.getLoc(), diag::err_attribute_sentinel_not_zero_or_one)
3098 << E->getSourceRange();
3099 return;
3100 }
3101 }
3102
3103 if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
3104 const FunctionType *FT = FD->getType()->castAs<FunctionType>();
3105 if (isa<FunctionNoProtoType>(FT)) {
3106 S.Diag(AL.getLoc(), diag::warn_attribute_sentinel_named_arguments);
3107 return;
3108 }
3109
3110 if (!cast<FunctionProtoType>(FT)->isVariadic()) {
3111 S.Diag(AL.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0;
3112 return;
3113 }
3114 } else if (const auto *MD = dyn_cast<ObjCMethodDecl>(D)) {
3115 if (!MD->isVariadic()) {
3116 S.Diag(AL.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0;
3117 return;
3118 }
3119 } else if (const auto *BD = dyn_cast<BlockDecl>(D)) {
3120 if (!BD->isVariadic()) {
3121 S.Diag(AL.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 1;
3122 return;
3123 }
3124 } else if (const auto *V = dyn_cast<VarDecl>(D)) {
3125 QualType Ty = V->getType();
3126 if (Ty->isBlockPointerType() || Ty->isFunctionPointerType()) {
3127 const FunctionType *FT = Ty->isFunctionPointerType()
3128 ? D->getFunctionType()
3129 : Ty->castAs<BlockPointerType>()
3130 ->getPointeeType()
3131 ->castAs<FunctionType>();
3132 if (!cast<FunctionProtoType>(FT)->isVariadic()) {
3133 int m = Ty->isFunctionPointerType() ? 0 : 1;
3134 S.Diag(AL.getLoc(), diag::warn_attribute_sentinel_not_variadic) << m;
3135 return;
3136 }
3137 } else {
3138 S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type)
3139 << AL << AL.isRegularKeywordAttribute()
3141 return;
3142 }
3143 } else {
3144 S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type)
3145 << AL << AL.isRegularKeywordAttribute()
3147 return;
3148 }
3149 D->addAttr(::new (S.Context) SentinelAttr(S.Context, AL, sentinel, nullPos));
3150}
3151
3152static void handleWarnUnusedResult(Sema &S, Decl *D, const ParsedAttr &AL) {
3153 if (D->getFunctionType() &&
3155 !isa<CXXConstructorDecl>(D)) {
3156 S.Diag(AL.getLoc(), diag::warn_attribute_void_function_method) << AL << 0;
3157 return;
3158 }
3159 if (const auto *MD = dyn_cast<ObjCMethodDecl>(D))
3160 if (MD->getReturnType()->isVoidType()) {
3161 S.Diag(AL.getLoc(), diag::warn_attribute_void_function_method) << AL << 1;
3162 return;
3163 }
3164
3165 StringRef Str;
3166 if (AL.isStandardAttributeSyntax() && !AL.getScopeName()) {
3167 // The standard attribute cannot be applied to variable declarations such
3168 // as a function pointer.
3169 if (isa<VarDecl>(D))
3170 S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type_str)
3171 << AL << AL.isRegularKeywordAttribute()
3172 << "functions, classes, or enumerations";
3173
3174 // If this is spelled as the standard C++17 attribute, but not in C++17,
3175 // warn about using it as an extension. If there are attribute arguments,
3176 // then claim it's a C++20 extension instead.
3177 // FIXME: If WG14 does not seem likely to adopt the same feature, add an
3178 // extension warning for C23 mode.
3179 const LangOptions &LO = S.getLangOpts();
3180 if (AL.getNumArgs() == 1) {
3181 if (LO.CPlusPlus && !LO.CPlusPlus20)
3182 S.Diag(AL.getLoc(), diag::ext_cxx20_attr) << AL;
3183
3184 // Since this is spelled [[nodiscard]], get the optional string
3185 // literal. If in C++ mode, but not in C++20 mode, diagnose as an
3186 // extension.
3187 // FIXME: C23 should support this feature as well, even as an extension.
3188 if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, nullptr))
3189 return;
3190 } else if (LO.CPlusPlus && !LO.CPlusPlus17)
3191 S.Diag(AL.getLoc(), diag::ext_cxx17_attr) << AL;
3192 }
3193
3194 if ((!AL.isGNUAttribute() &&
3195 !(AL.isStandardAttributeSyntax() && AL.isClangScope())) &&
3196 isa<TypedefNameDecl>(D)) {
3197 S.Diag(AL.getLoc(), diag::warn_unused_result_typedef_unsupported_spelling)
3198 << AL.isGNUScope();
3199 return;
3200 }
3201
3202 D->addAttr(::new (S.Context) WarnUnusedResultAttr(S.Context, AL, Str));
3203}
3204
3205static void handleWeakImportAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3206 // weak_import only applies to variable & function declarations.
3207 bool isDef = false;
3208 if (!D->canBeWeakImported(isDef)) {
3209 if (isDef)
3210 S.Diag(AL.getLoc(), diag::warn_attribute_invalid_on_definition)
3211 << "weak_import";
3212 else if (isa<ObjCPropertyDecl>(D) || isa<ObjCMethodDecl>(D) ||
3213 (S.Context.getTargetInfo().getTriple().isOSDarwin() &&
3214 (isa<ObjCInterfaceDecl>(D) || isa<EnumDecl>(D)))) {
3215 // Nothing to warn about here.
3216 } else
3217 S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type)
3219
3220 return;
3221 }
3222
3223 D->addAttr(::new (S.Context) WeakImportAttr(S.Context, AL));
3224}
3225
3226// Handles reqd_work_group_size and work_group_size_hint.
3227template <typename WorkGroupAttr>
3228static void handleWorkGroupSize(Sema &S, Decl *D, const ParsedAttr &AL) {
3229 uint32_t WGSize[3];
3230 for (unsigned i = 0; i < 3; ++i) {
3231 const Expr *E = AL.getArgAsExpr(i);
3232 if (!checkUInt32Argument(S, AL, E, WGSize[i], i,
3233 /*StrictlyUnsigned=*/true))
3234 return;
3235 if (WGSize[i] == 0) {
3236 S.Diag(AL.getLoc(), diag::err_attribute_argument_is_zero)
3237 << AL << E->getSourceRange();
3238 return;
3239 }
3240 }
3241
3242 WorkGroupAttr *Existing = D->getAttr<WorkGroupAttr>();
3243 if (Existing && !(Existing->getXDim() == WGSize[0] &&
3244 Existing->getYDim() == WGSize[1] &&
3245 Existing->getZDim() == WGSize[2]))
3246 S.Diag(AL.getLoc(), diag::warn_duplicate_attribute) << AL;
3247
3248 D->addAttr(::new (S.Context)
3249 WorkGroupAttr(S.Context, AL, WGSize[0], WGSize[1], WGSize[2]));
3250}
3251
3252// Handles intel_reqd_sub_group_size.
3253static void handleSubGroupSize(Sema &S, Decl *D, const ParsedAttr &AL) {
3254 uint32_t SGSize;
3255 const Expr *E = AL.getArgAsExpr(0);
3256 if (!checkUInt32Argument(S, AL, E, SGSize))
3257 return;
3258 if (SGSize == 0) {
3259 S.Diag(AL.getLoc(), diag::err_attribute_argument_is_zero)
3260 << AL << E->getSourceRange();
3261 return;
3262 }
3263
3264 OpenCLIntelReqdSubGroupSizeAttr *Existing =
3265 D->getAttr<OpenCLIntelReqdSubGroupSizeAttr>();
3266 if (Existing && Existing->getSubGroupSize() != SGSize)
3267 S.Diag(AL.getLoc(), diag::warn_duplicate_attribute) << AL;
3268
3269 D->addAttr(::new (S.Context)
3270 OpenCLIntelReqdSubGroupSizeAttr(S.Context, AL, SGSize));
3271}
3272
3273static void handleVecTypeHint(Sema &S, Decl *D, const ParsedAttr &AL) {
3274 if (!AL.hasParsedType()) {
3275 S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) << AL << 1;
3276 return;
3277 }
3278
3279 TypeSourceInfo *ParmTSI = nullptr;
3280 QualType ParmType = S.GetTypeFromParser(AL.getTypeArg(), &ParmTSI);
3281 assert(ParmTSI && "no type source info for attribute argument");
3282
3283 if (!ParmType->isExtVectorType() && !ParmType->isFloatingType() &&
3284 (ParmType->isBooleanType() ||
3285 !ParmType->isIntegralType(S.getASTContext()))) {
3286 S.Diag(AL.getLoc(), diag::err_attribute_invalid_argument) << 2 << AL;
3287 return;
3288 }
3289
3290 if (VecTypeHintAttr *A = D->getAttr<VecTypeHintAttr>()) {
3291 if (!S.Context.hasSameType(A->getTypeHint(), ParmType)) {
3292 S.Diag(AL.getLoc(), diag::warn_duplicate_attribute) << AL;
3293 return;
3294 }
3295 }
3296
3297 D->addAttr(::new (S.Context) VecTypeHintAttr(S.Context, AL, ParmTSI));
3298}
3299
3301 StringRef Name) {
3302 // Explicit or partial specializations do not inherit
3303 // the section attribute from the primary template.
3304 if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
3305 if (CI.getAttributeSpellingListIndex() == SectionAttr::Declspec_allocate &&
3307 return nullptr;
3308 }
3309 if (SectionAttr *ExistingAttr = D->getAttr<SectionAttr>()) {
3310 if (ExistingAttr->getName() == Name)
3311 return nullptr;
3312 Diag(ExistingAttr->getLocation(), diag::warn_mismatched_section)
3313 << 1 /*section*/;
3314 Diag(CI.getLoc(), diag::note_previous_attribute);
3315 return nullptr;
3316 }
3317 return ::new (Context) SectionAttr(Context, CI, Name);
3318}
3319
3320/// Used to implement to perform semantic checking on
3321/// attribute((section("foo"))) specifiers.
3322///
3323/// In this case, "foo" is passed in to be checked. If the section
3324/// specifier is invalid, return an Error that indicates the problem.
3325///
3326/// This is a simple quality of implementation feature to catch errors
3327/// and give good diagnostics in cases when the assembler or code generator
3328/// would otherwise reject the section specifier.
3329llvm::Error Sema::isValidSectionSpecifier(StringRef SecName) {
3330 if (!Context.getTargetInfo().getTriple().isOSDarwin())
3331 return llvm::Error::success();
3332
3333 // Let MCSectionMachO validate this.
3334 StringRef Segment, Section;
3335 unsigned TAA, StubSize;
3336 bool HasTAA;
3337 return llvm::MCSectionMachO::ParseSectionSpecifier(SecName, Segment, Section,
3338 TAA, HasTAA, StubSize);
3339}
3340
3341bool Sema::checkSectionName(SourceLocation LiteralLoc, StringRef SecName) {
3342 if (llvm::Error E = isValidSectionSpecifier(SecName)) {
3343 Diag(LiteralLoc, diag::err_attribute_section_invalid_for_target)
3344 << toString(std::move(E)) << 1 /*'section'*/;
3345 return false;
3346 }
3347 return true;
3348}
3349
3350static void handleSectionAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3351 // Make sure that there is a string literal as the sections's single
3352 // argument.
3353 StringRef Str;
3354 SourceLocation LiteralLoc;
3355 if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &LiteralLoc))
3356 return;
3357
3358 if (!S.checkSectionName(LiteralLoc, Str))
3359 return;
3360
3361 SectionAttr *NewAttr = S.mergeSectionAttr(D, AL, Str);
3362 if (NewAttr) {
3363 D->addAttr(NewAttr);
3365 ObjCPropertyDecl>(D))
3366 S.UnifySection(NewAttr->getName(),
3368 cast<NamedDecl>(D));
3369 }
3370}
3371
3372static void handleCodeModelAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3373 StringRef Str;
3374 SourceLocation LiteralLoc;
3375 // Check that it is a string.
3376 if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &LiteralLoc))
3377 return;
3378
3379 llvm::CodeModel::Model CM;
3380 if (!CodeModelAttr::ConvertStrToModel(Str, CM)) {
3381 S.Diag(LiteralLoc, diag::err_attr_codemodel_arg) << Str;
3382 return;
3383 }
3384
3385 D->addAttr(::new (S.Context) CodeModelAttr(S.Context, AL, CM));
3386}
3387
3388// This is used for `__declspec(code_seg("segname"))` on a decl.
3389// `#pragma code_seg("segname")` uses checkSectionName() instead.
3390static bool checkCodeSegName(Sema &S, SourceLocation LiteralLoc,
3391 StringRef CodeSegName) {
3392 if (llvm::Error E = S.isValidSectionSpecifier(CodeSegName)) {
3393 S.Diag(LiteralLoc, diag::err_attribute_section_invalid_for_target)
3394 << toString(std::move(E)) << 0 /*'code-seg'*/;
3395 return false;
3396 }
3397
3398 return true;
3399}
3400
3402 StringRef Name) {
3403 // Explicit or partial specializations do not inherit
3404 // the code_seg attribute from the primary template.
3405 if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
3407 return nullptr;
3408 }
3409 if (const auto *ExistingAttr = D->getAttr<CodeSegAttr>()) {
3410 if (ExistingAttr->getName() == Name)
3411 return nullptr;
3412 Diag(ExistingAttr->getLocation(), diag::warn_mismatched_section)
3413 << 0 /*codeseg*/;
3414 Diag(CI.getLoc(), diag::note_previous_attribute);
3415 return nullptr;
3416 }
3417 return ::new (Context) CodeSegAttr(Context, CI, Name);
3418}
3419
3420static void handleCodeSegAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3421 StringRef Str;
3422 SourceLocation LiteralLoc;
3423 if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &LiteralLoc))
3424 return;
3425 if (!checkCodeSegName(S, LiteralLoc, Str))
3426 return;
3427 if (const auto *ExistingAttr = D->getAttr<CodeSegAttr>()) {
3428 if (!ExistingAttr->isImplicit()) {
3429 S.Diag(AL.getLoc(),
3430 ExistingAttr->getName() == Str
3431 ? diag::warn_duplicate_codeseg_attribute
3432 : diag::err_conflicting_codeseg_attribute);
3433 return;
3434 }
3435 D->dropAttr<CodeSegAttr>();
3436 }
3437 if (CodeSegAttr *CSA = S.mergeCodeSegAttr(D, AL, Str))
3438 D->addAttr(CSA);
3439}
3440
3441// Check for things we'd like to warn about. Multiversioning issues are
3442// handled later in the process, once we know how many exist.
3443bool Sema::checkTargetAttr(SourceLocation LiteralLoc, StringRef AttrStr) {
3444 enum FirstParam { Unsupported, Duplicate, Unknown };
3445 enum SecondParam { None, CPU, Tune };
3446 enum ThirdParam { Target, TargetClones };
3447 if (AttrStr.contains("fpmath="))
3448 return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
3449 << Unsupported << None << "fpmath=" << Target;
3450
3451 // Diagnose use of tune if target doesn't support it.
3453 AttrStr.contains("tune="))
3454 return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
3455 << Unsupported << None << "tune=" << Target;
3456
3457 ParsedTargetAttr ParsedAttrs =
3459
3460 if (!ParsedAttrs.CPU.empty() &&
3461 !Context.getTargetInfo().isValidCPUName(ParsedAttrs.CPU))
3462 return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
3463 << Unknown << CPU << ParsedAttrs.CPU << Target;
3464
3465 if (!ParsedAttrs.Tune.empty() &&
3466 !Context.getTargetInfo().isValidCPUName(ParsedAttrs.Tune))
3467 return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
3468 << Unknown << Tune << ParsedAttrs.Tune << Target;
3469
3470 if (Context.getTargetInfo().getTriple().isRISCV() &&
3471 ParsedAttrs.Duplicate != "")
3472 return Diag(LiteralLoc, diag::err_duplicate_target_attribute)
3473 << Duplicate << None << ParsedAttrs.Duplicate << Target;
3474
3475 if (ParsedAttrs.Duplicate != "")
3476 return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
3477 << Duplicate << None << ParsedAttrs.Duplicate << Target;
3478
3479 for (const auto &Feature : ParsedAttrs.Features) {
3480 auto CurFeature = StringRef(Feature).drop_front(); // remove + or -.
3481 if (!Context.getTargetInfo().isValidFeatureName(CurFeature))
3482 return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
3483 << Unsupported << None << CurFeature << Target;
3484 }
3485
3487 StringRef DiagMsg;
3488 if (ParsedAttrs.BranchProtection.empty())
3489 return false;
3491 ParsedAttrs.BranchProtection, ParsedAttrs.CPU, BPI, DiagMsg)) {
3492 if (DiagMsg.empty())
3493 return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
3494 << Unsupported << None << "branch-protection" << Target;
3495 return Diag(LiteralLoc, diag::err_invalid_branch_protection_spec)
3496 << DiagMsg;
3497 }
3498 if (!DiagMsg.empty())
3499 Diag(LiteralLoc, diag::warn_unsupported_branch_protection_spec) << DiagMsg;
3500
3501 return false;
3502}
3503
3505 if (const auto *T = FD->getType()->getAs<FunctionProtoType>())
3506 if (T->getAArch64SMEAttributes() & FunctionType::SME_PStateSMEnabledMask)
3507 return true;
3508 return false;
3509}
3510
3511// Check Target Version attrs
3513 StringRef &AttrStr, bool &isDefault) {
3514 enum FirstParam { Unsupported };
3515 enum SecondParam { None };
3516 enum ThirdParam { Target, TargetClones, TargetVersion };
3517 if (AttrStr.trim() == "default")
3518 isDefault = true;
3520 AttrStr.split(Features, "+");
3521 for (auto &CurFeature : Features) {
3522 CurFeature = CurFeature.trim();
3523 if (CurFeature == "default")
3524 continue;
3525 if (!Context.getTargetInfo().validateCpuSupports(CurFeature))
3526 return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
3527 << Unsupported << None << CurFeature << TargetVersion;
3528 }
3529 if (hasArmStreamingInterface(cast<FunctionDecl>(D)))
3530 return Diag(LiteralLoc, diag::err_sme_streaming_cannot_be_multiversioned);
3531 return false;
3532}
3533
3534static void handleTargetVersionAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3535 StringRef Str;
3536 SourceLocation LiteralLoc;
3537 bool isDefault = false;
3538 if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &LiteralLoc) ||
3539 S.checkTargetVersionAttr(LiteralLoc, D, Str, isDefault))
3540 return;
3541 // Do not create default only target_version attribute
3542 if (!isDefault) {
3543 TargetVersionAttr *NewAttr =
3544 ::new (S.Context) TargetVersionAttr(S.Context, AL, Str);
3545 D->addAttr(NewAttr);
3546 }
3547}
3548
3549static void handleTargetAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3550 StringRef Str;
3551 SourceLocation LiteralLoc;
3552 if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &LiteralLoc) ||
3553 S.checkTargetAttr(LiteralLoc, Str))
3554 return;
3555
3556 TargetAttr *NewAttr = ::new (S.Context) TargetAttr(S.Context, AL, Str);
3557 D->addAttr(NewAttr);
3558}
3559
3561 SourceLocation LiteralLoc, StringRef Str, const StringLiteral *Literal,
3562 Decl *D, bool &HasDefault, bool &HasCommas, bool &HasNotDefault,
3563 SmallVectorImpl<SmallString<64>> &StringsBuffer) {
3564 enum FirstParam { Unsupported, Duplicate, Unknown };
3565 enum SecondParam { None, CPU, Tune };
3566 enum ThirdParam { Target, TargetClones };
3567 HasCommas = HasCommas || Str.contains(',');
3568 const TargetInfo &TInfo = Context.getTargetInfo();
3569 // Warn on empty at the beginning of a string.
3570 if (Str.size() == 0)
3571 return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
3572 << Unsupported << None << "" << TargetClones;
3573
3574 std::pair<StringRef, StringRef> Parts = {{}, Str};
3575 while (!Parts.second.empty()) {
3576 Parts = Parts.second.split(',');
3577 StringRef Cur = Parts.first.trim();
3578 SourceLocation CurLoc =
3579 Literal->getLocationOfByte(Cur.data() - Literal->getString().data(),
3580 getSourceManager(), getLangOpts(), TInfo);
3581
3582 bool DefaultIsDupe = false;
3583 bool HasCodeGenImpact = false;
3584 if (Cur.empty())
3585 return Diag(CurLoc, diag::warn_unsupported_target_attribute)
3586 << Unsupported << None << "" << TargetClones;
3587
3588 if (TInfo.getTriple().isAArch64()) {
3589 // AArch64 target clones specific
3590 if (Cur == "default") {
3591 DefaultIsDupe = HasDefault;
3592 HasDefault = true;
3593 if (llvm::is_contained(StringsBuffer, Cur) || DefaultIsDupe)
3594 Diag(CurLoc, diag::warn_target_clone_duplicate_options);
3595 else
3596 StringsBuffer.push_back(Cur);
3597 } else {
3598 std::pair<StringRef, StringRef> CurParts = {{}, Cur};
3600 while (!CurParts.second.empty()) {
3601 CurParts = CurParts.second.split('+');
3602 StringRef CurFeature = CurParts.first.trim();
3603 if (!TInfo.validateCpuSupports(CurFeature)) {
3604 Diag(CurLoc, diag::warn_unsupported_target_attribute)
3605 << Unsupported << None << CurFeature << TargetClones;
3606 continue;
3607 }
3608 if (TInfo.doesFeatureAffectCodeGen(CurFeature))
3609 HasCodeGenImpact = true;
3610 CurFeatures.push_back(CurFeature);
3611 }
3612 // Canonize TargetClones Attributes
3613 llvm::sort(CurFeatures);
3614 SmallString<64> Res;
3615 for (auto &CurFeat : CurFeatures) {
3616 if (!Res.equals(""))
3617 Res.append("+");
3618 Res.append(CurFeat);
3619 }
3620 if (llvm::is_contained(StringsBuffer, Res) || DefaultIsDupe)
3621 Diag(CurLoc, diag::warn_target_clone_duplicate_options);
3622 else if (!HasCodeGenImpact)
3623 // Ignore features in target_clone attribute that don't impact
3624 // code generation
3625 Diag(CurLoc, diag::warn_target_clone_no_impact_options);
3626 else if (!Res.empty()) {
3627 StringsBuffer.push_back(Res);
3628 HasNotDefault = true;
3629 }
3630 }
3631 if (hasArmStreamingInterface(cast<FunctionDecl>(D)))
3632 return Diag(LiteralLoc,
3633 diag::err_sme_streaming_cannot_be_multiversioned);
3634 } else {
3635 // Other targets ( currently X86 )
3636 if (Cur.starts_with("arch=")) {
3638 Cur.drop_front(sizeof("arch=") - 1)))
3639 return Diag(CurLoc, diag::warn_unsupported_target_attribute)
3640 << Unsupported << CPU << Cur.drop_front(sizeof("arch=") - 1)
3641 << TargetClones;
3642 } else if (Cur == "default") {
3643 DefaultIsDupe = HasDefault;
3644 HasDefault = true;
3645 } else if (!Context.getTargetInfo().isValidFeatureName(Cur))
3646 return Diag(CurLoc, diag::warn_unsupported_target_attribute)
3647 << Unsupported << None << Cur << TargetClones;
3648 if (llvm::is_contained(StringsBuffer, Cur) || DefaultIsDupe)
3649 Diag(CurLoc, diag::warn_target_clone_duplicate_options);
3650 // Note: Add even if there are duplicates, since it changes name mangling.
3651 StringsBuffer.push_back(Cur);
3652 }
3653 }
3654 if (Str.rtrim().ends_with(","))
3655 return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
3656 << Unsupported << None << "" << TargetClones;
3657 return false;
3658}
3659
3660static void handleTargetClonesAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3661 if (S.Context.getTargetInfo().getTriple().isAArch64() &&
3662 !S.Context.getTargetInfo().hasFeature("fmv"))
3663 return;
3664
3665 // Ensure we don't combine these with themselves, since that causes some
3666 // confusing behavior.
3667 if (const auto *Other = D->getAttr<TargetClonesAttr>()) {
3668 S.Diag(AL.getLoc(), diag::err_disallowed_duplicate_attribute) << AL;
3669 S.Diag(Other->getLocation(), diag::note_conflicting_attribute);
3670 return;
3671 }
3672 if (checkAttrMutualExclusion<TargetClonesAttr>(S, D, AL))
3673 return;
3674
3676 SmallVector<SmallString<64>, 2> StringsBuffer;
3677 bool HasCommas = false, HasDefault = false, HasNotDefault = false;
3678
3679 for (unsigned I = 0, E = AL.getNumArgs(); I != E; ++I) {
3680 StringRef CurStr;
3681 SourceLocation LiteralLoc;
3682 if (!S.checkStringLiteralArgumentAttr(AL, I, CurStr, &LiteralLoc) ||
3684 LiteralLoc, CurStr,
3685 cast<StringLiteral>(AL.getArgAsExpr(I)->IgnoreParenCasts()), D,
3686 HasDefault, HasCommas, HasNotDefault, StringsBuffer))
3687 return;
3688 }
3689 for (auto &SmallStr : StringsBuffer)
3690 Strings.push_back(SmallStr.str());
3691
3692 if (HasCommas && AL.getNumArgs() > 1)
3693 S.Diag(AL.getLoc(), diag::warn_target_clone_mixed_values);
3694
3695 if (S.Context.getTargetInfo().getTriple().isAArch64() && !HasDefault) {
3696 // Add default attribute if there is no one
3697 HasDefault = true;
3698 Strings.push_back("default");
3699 }
3700
3701 if (!HasDefault) {
3702 S.Diag(AL.getLoc(), diag::err_target_clone_must_have_default);
3703 return;
3704 }
3705
3706 // FIXME: We could probably figure out how to get this to work for lambdas
3707 // someday.
3708 if (const auto *MD = dyn_cast<CXXMethodDecl>(D)) {
3709 if (MD->getParent()->isLambda()) {
3710 S.Diag(D->getLocation(), diag::err_multiversion_doesnt_support)
3711 << static_cast<unsigned>(MultiVersionKind::TargetClones)
3712 << /*Lambda*/ 9;
3713 return;
3714 }
3715 }
3716
3717 // No multiversion if we have default version only.
3718 if (S.Context.getTargetInfo().getTriple().isAArch64() && !HasNotDefault)
3719 return;
3720
3721 cast<FunctionDecl>(D)->setIsMultiVersion();
3722 TargetClonesAttr *NewAttr = ::new (S.Context)
3723 TargetClonesAttr(S.Context, AL, Strings.data(), Strings.size());
3724 D->addAttr(NewAttr);
3725}
3726
3727static void handleMinVectorWidthAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3728 Expr *E = AL.getArgAsExpr(0);
3729 uint32_t VecWidth;
3730 if (!checkUInt32Argument(S, AL, E, VecWidth)) {
3731 AL.setInvalid();
3732 return;
3733 }
3734
3735 MinVectorWidthAttr *Existing = D->getAttr<MinVectorWidthAttr>();
3736 if (Existing && Existing->getVectorWidth() != VecWidth) {
3737 S.Diag(AL.getLoc(), diag::warn_duplicate_attribute) << AL;
3738 return;
3739 }
3740
3741 D->addAttr(::new (S.Context) MinVectorWidthAttr(S.Context, AL, VecWidth));
3742}
3743
3744static void handleCleanupAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3745 Expr *E = AL.getArgAsExpr(0);
3746 SourceLocation Loc = E->getExprLoc();
3747 FunctionDecl *FD = nullptr;
3749
3750 // gcc only allows for simple identifiers. Since we support more than gcc, we
3751 // will warn the user.
3752 if (auto *DRE = dyn_cast<DeclRefExpr>(E)) {
3753 if (DRE->hasQualifier())
3754 S.Diag(Loc, diag::warn_cleanup_ext);
3755 FD = dyn_cast<FunctionDecl>(DRE->getDecl());
3756 NI = DRE->getNameInfo();
3757 if (!FD) {
3758 S.Diag(Loc, diag::err_attribute_cleanup_arg_not_function) << 1
3759 << NI.getName();
3760 return;
3761 }
3762 } else if (auto *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
3763 if (ULE->hasExplicitTemplateArgs())
3764 S.Diag(Loc, diag::warn_cleanup_ext);
3766 NI = ULE->getNameInfo();
3767 if (!FD) {
3768 S.Diag(Loc, diag::err_attribute_cleanup_arg_not_function) << 2
3769 << NI.getName();
3770 if (ULE->getType() == S.Context.OverloadTy)
3772 return;
3773 }
3774 } else {
3775 S.Diag(Loc, diag::err_attribute_cleanup_arg_not_function) << 0;
3776 return;
3777 }
3778
3779 if (FD->getNumParams() != 1) {
3780 S.Diag(Loc, diag::err_attribute_cleanup_func_must_take_one_arg)
3781 << NI.getName();
3782 return;
3783 }
3784
3785 // We're currently more strict than GCC about what function types we accept.
3786 // If this ever proves to be a problem it should be easy to fix.
3787 QualType Ty = S.Context.getPointerType(cast<VarDecl>(D)->getType());
3788 QualType ParamTy = FD->getParamDecl(0)->getType();
3790 ParamTy, Ty) != Sema::Compatible) {
3791 S.Diag(Loc, diag::err_attribute_cleanup_func_arg_incompatible_type)
3792 << NI.getName() << ParamTy << Ty;
3793 return;
3794 }
3795
3796 D->addAttr(::new (S.Context) CleanupAttr(S.Context, AL, FD));
3797}
3798
3800 const ParsedAttr &AL) {
3801 if (!AL.isArgIdent(0)) {
3802 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
3803 << AL << 0 << AANT_ArgumentIdentifier;
3804 return;
3805 }
3806
3807 EnumExtensibilityAttr::Kind ExtensibilityKind;
3808 IdentifierInfo *II = AL.getArgAsIdent(0)->Ident;
3809 if (!EnumExtensibilityAttr::ConvertStrToKind(II->getName(),
3810 ExtensibilityKind)) {
3811 S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported) << AL << II;
3812 return;
3813 }
3814
3815 D->addAttr(::new (S.Context)
3816 EnumExtensibilityAttr(S.Context, AL, ExtensibilityKind));
3817}
3818
3819/// Handle __attribute__((format_arg((idx)))) attribute based on
3820/// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
3821static void handleFormatArgAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3822 const Expr *IdxExpr = AL.getArgAsExpr(0);
3823 ParamIdx Idx;
3824 if (!checkFunctionOrMethodParameterIndex(S, D, AL, 1, IdxExpr, Idx))
3825 return;
3826
3827 // Make sure the format string is really a string.
3829
3830 bool NotNSStringTy = !isNSStringType(Ty, S.Context);
3831 if (NotNSStringTy &&
3832 !isCFStringType(Ty, S.Context) &&
3833 (!Ty->isPointerType() ||
3835 S.Diag(AL.getLoc(), diag::err_format_attribute_not)
3836 << IdxExpr->getSourceRange() << getFunctionOrMethodParamRange(D, 0);
3837 return;
3838 }
3840 // replace instancetype with the class type
3841 auto Instancetype = S.Context.getObjCInstanceTypeDecl()->getTypeForDecl();
3842 if (Ty->getAs<TypedefType>() == Instancetype)
3843 if (auto *OMD = dyn_cast<ObjCMethodDecl>(D))
3844 if (auto *Interface = OMD->getClassInterface())
3846 QualType(Interface->getTypeForDecl(), 0));
3847 if (!isNSStringType(Ty, S.Context, /*AllowNSAttributedString=*/true) &&
3848 !isCFStringType(Ty, S.Context) &&
3849 (!Ty->isPointerType() ||
3851 S.Diag(AL.getLoc(), diag::err_format_attribute_result_not)
3852 << (NotNSStringTy ? "string type" : "NSString")
3853 << IdxExpr->getSourceRange() << getFunctionOrMethodParamRange(D, 0);
3854 return;
3855 }
3856
3857 D->addAttr(::new (S.Context) FormatArgAttr(S.Context, AL, Idx));
3858}
3859
3868
3869/// getFormatAttrKind - Map from format attribute names to supported format
3870/// types.
3871static FormatAttrKind getFormatAttrKind(StringRef Format) {
3872 return llvm::StringSwitch<FormatAttrKind>(Format)
3873 // Check for formats that get handled specially.
3874 .Case("NSString", NSStringFormat)
3875 .Case("CFString", CFStringFormat)
3876 .Case("strftime", StrftimeFormat)
3877
3878 // Otherwise, check for supported formats.
3879 .Cases("scanf", "printf", "printf0", "strfmon", SupportedFormat)
3880 .Cases("cmn_err", "vcmn_err", "zcmn_err", SupportedFormat)
3881 .Case("kprintf", SupportedFormat) // OpenBSD.
3882 .Case("freebsd_kprintf", SupportedFormat) // FreeBSD.
3883 .Case("os_trace", SupportedFormat)
3884 .Case("os_log", SupportedFormat)
3885
3886 .Cases("gcc_diag", "gcc_cdiag", "gcc_cxxdiag", "gcc_tdiag", IgnoredFormat)
3887 .Default(InvalidFormat);
3888}
3889
3890/// Handle __attribute__((init_priority(priority))) attributes based on
3891/// http://gcc.gnu.org/onlinedocs/gcc/C_002b_002b-Attributes.html
3892static void handleInitPriorityAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3893 if (!S.getLangOpts().CPlusPlus) {
3894 S.Diag(AL.getLoc(), diag::warn_attribute_ignored) << AL;
3895 return;
3896 }
3897
3898 if (S.getLangOpts().HLSL) {
3899 S.Diag(AL.getLoc(), diag::err_hlsl_init_priority_unsupported);
3900 return;
3901 }
3902
3904 S.Diag(AL.getLoc(), diag::err_init_priority_object_attr);
3905 AL.setInvalid();
3906 return;
3907 }
3908 QualType T = cast<VarDecl>(D)->getType();
3909 if (S.Context.getAsArrayType(T))
3910 T = S.Context.getBaseElementType(T);
3911 if (!T->getAs<RecordType>()) {
3912 S.Diag(AL.getLoc(), diag::err_init_priority_object_attr);
3913 AL.setInvalid();
3914 return;
3915 }
3916
3917 Expr *E = AL.getArgAsExpr(0);
3918 uint32_t prioritynum;
3919 if (!checkUInt32Argument(S, AL, E, prioritynum)) {
3920 AL.setInvalid();
3921 return;
3922 }
3923
3924 // Only perform the priority check if the attribute is outside of a system
3925 // header. Values <= 100 are reserved for the implementation, and libc++
3926 // benefits from being able to specify values in that range.
3927 if ((prioritynum < 101 || prioritynum > 65535) &&
3929 S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_range)
3930 << E->getSourceRange() << AL << 101 << 65535;
3931 AL.setInvalid();
3932 return;
3933 }
3934 D->addAttr(::new (S.Context) InitPriorityAttr(S.Context, AL, prioritynum));
3935}
3936
3938 StringRef NewUserDiagnostic) {
3939 if (const auto *EA = D->getAttr<ErrorAttr>()) {
3940 std::string NewAttr = CI.getNormalizedFullName();
3941 assert((NewAttr == "error" || NewAttr == "warning") &&
3942 "unexpected normalized full name");
3943 bool Match = (EA->isError() && NewAttr == "error") ||
3944 (EA->isWarning() && NewAttr == "warning");
3945 if (!Match) {
3946 Diag(EA->getLocation(), diag::err_attributes_are_not_compatible)
3947 << CI << EA
3948 << (CI.isRegularKeywordAttribute() ||
3949 EA->isRegularKeywordAttribute());
3950 Diag(CI.getLoc(), diag::note_conflicting_attribute);
3951 return nullptr;
3952 }
3953 if (EA->getUserDiagnostic() != NewUserDiagnostic) {
3954 Diag(CI.getLoc(), diag::warn_duplicate_attribute) << EA;
3955 Diag(EA->getLoc(), diag::note_previous_attribute);
3956 }
3957 D->dropAttr<ErrorAttr>();
3958 }
3959 return ::new (Context) ErrorAttr(Context, CI, NewUserDiagnostic);
3960}
3961
3963 IdentifierInfo *Format, int FormatIdx,
3964 int FirstArg) {
3965 // Check whether we already have an equivalent format attribute.
3966 for (auto *F : D->specific_attrs<FormatAttr>()) {
3967 if (F->getType() == Format &&
3968 F->getFormatIdx() == FormatIdx &&
3969 F->getFirstArg() == FirstArg) {
3970 // If we don't have a valid location for this attribute, adopt the
3971 // location.
3972 if (F->getLocation().isInvalid())
3973 F->setRange(CI.getRange());
3974 return nullptr;
3975 }
3976 }
3977
3978 return ::new (Context) FormatAttr(Context, CI, Format, FormatIdx, FirstArg);
3979}
3980
3981/// Handle __attribute__((format(type,idx,firstarg))) attributes based on
3982/// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
3983static void handleFormatAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3984 if (!AL.isArgIdent(0)) {
3985 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
3986 << AL << 1 << AANT_ArgumentIdentifier;
3987 return;
3988 }
3989
3990 // In C++ the implicit 'this' function parameter also counts, and they are
3991 // counted from one.
3992 bool HasImplicitThisParam = isInstanceMethod(D);
3993 unsigned NumArgs = getFunctionOrMethodNumParams(D) + HasImplicitThisParam;
3994
3995 IdentifierInfo *II = AL.getArgAsIdent(0)->Ident;
3996 StringRef Format = II->getName();
3997
3998 if (normalizeName(Format)) {
3999 // If we've modified the string name, we need a new identifier for it.
4000 II = &S.Context.Idents.get(Format);
4001 }
4002
4003 // Check for supported formats.
4004 FormatAttrKind Kind = getFormatAttrKind(Format);
4005
4006 if (Kind == IgnoredFormat)
4007 return;
4008
4009 if (Kind == InvalidFormat) {
4010 S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported)
4011 << AL << II->getName();
4012 return;
4013 }
4014
4015 // checks for the 2nd argument
4016 Expr *IdxExpr = AL.getArgAsExpr(1);
4017 uint32_t Idx;
4018 if (!checkUInt32Argument(S, AL, IdxExpr, Idx, 2))
4019 return;
4020
4021 if (Idx < 1 || Idx > NumArgs) {
4022 S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_bounds)
4023 << AL << 2 << IdxExpr->getSourceRange();
4024 return;
4025 }
4026
4027 // FIXME: Do we need to bounds check?
4028 unsigned ArgIdx = Idx - 1;
4029
4030 if (HasImplicitThisParam) {
4031 if (ArgIdx == 0) {
4032 S.Diag(AL.getLoc(),
4033 diag::err_format_attribute_implicit_this_format_string)
4034 << IdxExpr->getSourceRange();
4035 return;
4036 }
4037 ArgIdx--;
4038 }
4039
4040 // make sure the format string is really a string
4041 QualType Ty = getFunctionOrMethodParamType(D, ArgIdx);
4042
4043 if (!isNSStringType(Ty, S.Context, true) &&
4044 !isCFStringType(Ty, S.Context) &&
4045 (!Ty->isPointerType() ||
4047 S.Diag(AL.getLoc(), diag::err_format_attribute_not)
4048 << IdxExpr->getSourceRange() << getFunctionOrMethodParamRange(D, ArgIdx);
4049 return;
4050 }
4051
4052 // check the 3rd argument
4053 Expr *FirstArgExpr = AL.getArgAsExpr(2);
4054 uint32_t FirstArg;
4055 if (!checkUInt32Argument(S, AL, FirstArgExpr, FirstArg, 3))
4056 return;
4057
4058 // FirstArg == 0 is is always valid.
4059 if (FirstArg != 0) {
4060 if (Kind == StrftimeFormat) {
4061 // If the kind is strftime, FirstArg must be 0 because strftime does not
4062 // use any variadic arguments.
4063 S.Diag(AL.getLoc(), diag::err_format_strftime_third_parameter)
4064 << FirstArgExpr->getSourceRange()
4065 << FixItHint::CreateReplacement(FirstArgExpr->getSourceRange(), "0");
4066 return;
4067 } else if (isFunctionOrMethodVariadic(D)) {
4068 // Else, if the function is variadic, then FirstArg must be 0 or the
4069 // "position" of the ... parameter. It's unusual to use 0 with variadic
4070 // functions, so the fixit proposes the latter.
4071 if (FirstArg != NumArgs + 1) {
4072 S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_bounds)
4073 << AL << 3 << FirstArgExpr->getSourceRange()
4075 std::to_string(NumArgs + 1));
4076 return;
4077 }
4078 } else {
4079 // Inescapable GCC compatibility diagnostic.
4080 S.Diag(D->getLocation(), diag::warn_gcc_requires_variadic_function) << AL;
4081 if (FirstArg <= Idx) {
4082 // Else, the function is not variadic, and FirstArg must be 0 or any
4083 // parameter after the format parameter. We don't offer a fixit because
4084 // there are too many possible good values.
4085 S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_bounds)
4086 << AL << 3 << FirstArgExpr->getSourceRange();
4087 return;
4088 }
4089 }
4090 }
4091
4092 FormatAttr *NewAttr = S.mergeFormatAttr(D, AL, II, Idx, FirstArg);
4093 if (NewAttr)
4094 D->addAttr(NewAttr);
4095}
4096
4097/// Handle __attribute__((callback(CalleeIdx, PayloadIdx0, ...))) attributes.
4098static void handleCallbackAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4099 // The index that identifies the callback callee is mandatory.
4100 if (AL.getNumArgs() == 0) {
4101 S.Diag(AL.getLoc(), diag::err_callback_attribute_no_callee)
4102 << AL.getRange();
4103 return;
4104 }
4105
4106 bool HasImplicitThisParam = isInstanceMethod(D);
4107 int32_t NumArgs = getFunctionOrMethodNumParams(D);
4108
4109 FunctionDecl *FD = D->getAsFunction();
4110 assert(FD && "Expected a function declaration!");
4111
4112 llvm::StringMap<int> NameIdxMapping;
4113 NameIdxMapping["__"] = -1;
4114
4115 NameIdxMapping["this"] = 0;
4116
4117 int Idx = 1;
4118 for (const ParmVarDecl *PVD : FD->parameters())
4119 NameIdxMapping[PVD->getName()] = Idx++;
4120
4121 auto UnknownName = NameIdxMapping.end();
4122
4123 SmallVector<int, 8> EncodingIndices;
4124 for (unsigned I = 0, E = AL.getNumArgs(); I < E; ++I) {
4125 SourceRange SR;
4126 int32_t ArgIdx;
4127
4128 if (AL.isArgIdent(I)) {
4129 IdentifierLoc *IdLoc = AL.getArgAsIdent(I);
4130 auto It = NameIdxMapping.find(IdLoc->Ident->getName());
4131 if (It == UnknownName) {
4132 S.Diag(AL.getLoc(), diag::err_callback_attribute_argument_unknown)
4133 << IdLoc->Ident << IdLoc->Loc;
4134 return;
4135 }
4136
4137 SR = SourceRange(IdLoc->Loc);
4138 ArgIdx = It->second;
4139 } else if (AL.isArgExpr(I)) {
4140 Expr *IdxExpr = AL.getArgAsExpr(I);
4141
4142 // If the expression is not parseable as an int32_t we have a problem.
4143 if (!checkUInt32Argument(S, AL, IdxExpr, (uint32_t &)ArgIdx, I + 1,
4144 false)) {
4145 S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_bounds)
4146 << AL << (I + 1) << IdxExpr->getSourceRange();
4147 return;
4148 }
4149
4150 // Check oob, excluding the special values, 0 and -1.
4151 if (ArgIdx < -1 || ArgIdx > NumArgs) {
4152 S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_bounds)
4153 << AL << (I + 1) << IdxExpr->getSourceRange();
4154 return;
4155 }
4156
4157 SR = IdxExpr->getSourceRange();
4158 } else {
4159 llvm_unreachable("Unexpected ParsedAttr argument type!");
4160 }
4161
4162 if (ArgIdx == 0 && !HasImplicitThisParam) {
4163 S.Diag(AL.getLoc(), diag::err_callback_implicit_this_not_available)
4164 << (I + 1) << SR;
4165 return;
4166 }
4167
4168 // Adjust for the case we do not have an implicit "this" parameter. In this
4169 // case we decrease all positive values by 1 to get LLVM argument indices.
4170 if (!HasImplicitThisParam && ArgIdx > 0)
4171 ArgIdx -= 1;
4172
4173 EncodingIndices.push_back(ArgIdx);
4174 }
4175
4176 int CalleeIdx = EncodingIndices.front();
4177 // Check if the callee index is proper, thus not "this" and not "unknown".
4178 // This means the "CalleeIdx" has to be non-negative if "HasImplicitThisParam"
4179 // is false and positive if "HasImplicitThisParam" is true.
4180 if (CalleeIdx < (int)HasImplicitThisParam) {
4181 S.Diag(AL.getLoc(), diag::err_callback_attribute_invalid_callee)
4182 << AL.getRange();
4183 return;
4184 }
4185
4186 // Get the callee type, note the index adjustment as the AST doesn't contain
4187 // the this type (which the callee cannot reference anyway!).
4188 const Type *CalleeType =
4189 getFunctionOrMethodParamType(D, CalleeIdx - HasImplicitThisParam)
4190 .getTypePtr();
4191 if (!CalleeType || !CalleeType->isFunctionPointerType()) {
4192 S.Diag(AL.getLoc(), diag::err_callback_callee_no_function_type)
4193 << AL.getRange();
4194 return;
4195 }
4196
4197 const Type *CalleeFnType =
4199
4200 // TODO: Check the type of the callee arguments.
4201
4202 const auto *CalleeFnProtoType = dyn_cast<FunctionProtoType>(CalleeFnType);
4203 if (!CalleeFnProtoType) {
4204 S.Diag(AL.getLoc(), diag::err_callback_callee_no_function_type)
4205 << AL.getRange();
4206 return;
4207 }
4208
4209 if (CalleeFnProtoType->getNumParams() > EncodingIndices.size() - 1) {
4210 S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments)
4211 << AL << (unsigned)(EncodingIndices.size() - 1);
4212 return;
4213 }
4214
4215 if (CalleeFnProtoType->getNumParams() < EncodingIndices.size() - 1) {
4216 S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments)
4217 << AL << (unsigned)(EncodingIndices.size() - 1);
4218 return;
4219 }
4220
4221 if (CalleeFnProtoType->isVariadic()) {
4222 S.Diag(AL.getLoc(), diag::err_callback_callee_is_variadic) << AL.getRange();
4223 return;
4224 }
4225
4226 // Do not allow multiple callback attributes.
4227 if (D->hasAttr<CallbackAttr>()) {
4228 S.Diag(AL.getLoc(), diag::err_callback_attribute_multiple) << AL.getRange();
4229 return;
4230 }
4231
4232 D->addAttr(::new (S.Context) CallbackAttr(
4233 S.Context, AL, EncodingIndices.data(), EncodingIndices.size()));
4234}
4235
4236static bool isFunctionLike(const Type &T) {
4237 // Check for explicit function types.
4238 // 'called_once' is only supported in Objective-C and it has
4239 // function pointers and block pointers.
4240 return T.isFunctionPointerType() || T.isBlockPointerType();
4241}
4242
4243/// Handle 'called_once' attribute.
4244static void handleCalledOnceAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4245 // 'called_once' only applies to parameters representing functions.
4246 QualType T = cast<ParmVarDecl>(D)->getType();
4247
4248 if (!isFunctionLike(*T)) {
4249 S.Diag(AL.getLoc(), diag::err_called_once_attribute_wrong_type);
4250 return;
4251 }
4252
4253 D->addAttr(::new (S.Context) CalledOnceAttr(S.Context, AL));
4254}
4255
4256static void handleTransparentUnionAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4257 // Try to find the underlying union declaration.
4258 RecordDecl *RD = nullptr;
4259 const auto *TD = dyn_cast<TypedefNameDecl>(D);
4260 if (TD && TD->getUnderlyingType()->isUnionType())
4261 RD = TD->getUnderlyingType()->getAsUnionType()->getDecl();
4262 else
4263 RD = dyn_cast<RecordDecl>(D);
4264
4265 if (!RD || !RD->isUnion()) {
4266 S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type)
4268 return;
4269 }
4270
4271 if (!RD->isCompleteDefinition()) {
4272 if (!RD->isBeingDefined())
4273 S.Diag(AL.getLoc(),
4274 diag::warn_transparent_union_attribute_not_definition);
4275 return;
4276 }
4277
4279 FieldEnd = RD->field_end();
4280 if (Field == FieldEnd) {
4281 S.Diag(AL.getLoc(), diag::warn_transparent_union_attribute_zero_fields);
4282 return;
4283 }
4284
4285 FieldDecl *FirstField = *Field;
4286 QualType FirstType = FirstField->getType();
4287 if (FirstType->hasFloatingRepresentation() || FirstType->isVectorType()) {
4288 S.Diag(FirstField->getLocation(),
4289 diag::warn_transparent_union_attribute_floating)
4290 << FirstType->isVectorType() << FirstType;
4291 return;
4292 }
4293
4294 if (FirstType->isIncompleteType())
4295 return;
4296 uint64_t FirstSize = S.Context.getTypeSize(FirstType);
4297 uint64_t FirstAlign = S.Context.getTypeAlign(FirstType);
4298 for (; Field != FieldEnd; ++Field) {
4299 QualType FieldType = Field->getType();
4300 if (FieldType->isIncompleteType())
4301 return;
4302 // FIXME: this isn't fully correct; we also need to test whether the
4303 // members of the union would all have the same calling convention as the
4304 // first member of the union. Checking just the size and alignment isn't
4305 // sufficient (consider structs passed on the stack instead of in registers
4306 // as an example).
4307 if (S.Context.getTypeSize(FieldType) != FirstSize ||
4308 S.Context.getTypeAlign(FieldType) > FirstAlign) {
4309 // Warn if we drop the attribute.
4310 bool isSize = S.Context.getTypeSize(FieldType) != FirstSize;
4311 unsigned FieldBits = isSize ? S.Context.getTypeSize(FieldType)
4312 : S.Context.getTypeAlign(FieldType);
4313 S.Diag(Field->getLocation(),
4314 diag::warn_transparent_union_attribute_field_size_align)
4315 << isSize << *Field << FieldBits;
4316 unsigned FirstBits = isSize ? FirstSize : FirstAlign;
4317 S.Diag(FirstField->getLocation(),
4318 diag::note_transparent_union_first_field_size_align)
4319 << isSize << FirstBits;
4320 return;
4321 }
4322 }
4323
4324 RD->addAttr(::new (S.Context) TransparentUnionAttr(S.Context, AL));
4325}
4326
4328 StringRef Str, MutableArrayRef<Expr *> Args) {
4329 auto *Attr = AnnotateAttr::Create(Context, Str, Args.data(), Args.size(), CI);
4331 CI, MutableArrayRef<Expr *>(Attr->args_begin(), Attr->args_end()))) {
4332 D->addAttr(Attr);
4333 }
4334}
4335
4336static void handleAnnotateAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4337 // Make sure that there is a string literal as the annotation's first
4338 // argument.
4339 StringRef Str;
4340 if (!S.checkStringLiteralArgumentAttr(AL, 0, Str))
4341 return;
4342
4344 Args.reserve(AL.getNumArgs() - 1);
4345 for (unsigned Idx = 1; Idx < AL.getNumArgs(); Idx++) {
4346 assert(!AL.isArgIdent(Idx));
4347 Args.push_back(AL.getArgAsExpr(Idx));
4348 }
4349
4350 S.AddAnnotationAttr(D, AL, Str, Args);
4351}
4352
4353static void handleAlignValueAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4354 S.AddAlignValueAttr(D, AL, AL.getArgAsExpr(0));
4355}
4356
4358 AlignValueAttr TmpAttr(Context, CI, E);
4359 SourceLocation AttrLoc = CI.getLoc();
4360
4361 QualType T;
4362 if (const auto *TD = dyn_cast<TypedefNameDecl>(D))
4363 T = TD->getUnderlyingType();
4364 else if (const auto *VD = dyn_cast<ValueDecl>(D))
4365 T = VD->getType();
4366 else
4367 llvm_unreachable("Unknown decl type for align_value");
4368
4369 if (!T->isDependentType() && !T->isAnyPointerType() &&
4370 !T->isReferenceType() && !T->isMemberPointerType()) {
4371 Diag(AttrLoc, diag::warn_attribute_pointer_or_reference_only)
4372 << &TmpAttr << T << D->getSourceRange();
4373 return;
4374 }
4375
4376 if (!E->isValueDependent()) {
4377 llvm::APSInt Alignment;
4379 E, &Alignment, diag::err_align_value_attribute_argument_not_int);
4380 if (ICE.isInvalid())
4381 return;
4382
4383 if (!Alignment.isPowerOf2()) {
4384 Diag(AttrLoc, diag::err_alignment_not_power_of_two)
4385 << E->getSourceRange();
4386 return;
4387 }
4388
4389 D->addAttr(::new (Context) AlignValueAttr(Context, CI, ICE.get()));
4390 return;
4391 }
4392
4393 // Save dependent expressions in the AST to be instantiated.
4394 D->addAttr(::new (Context) AlignValueAttr(Context, CI, E));
4395}
4396
4397static void handleAlignedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4398 if (AL.hasParsedType()) {
4399 const ParsedType &TypeArg = AL.getTypeArg();
4400 TypeSourceInfo *TInfo;
4401 (void)S.GetTypeFromParser(
4402 ParsedType::getFromOpaquePtr(TypeArg.getAsOpaquePtr()), &TInfo);
4403 if (AL.isPackExpansion() &&
4405 S.Diag(AL.getEllipsisLoc(),
4406 diag::err_pack_expansion_without_parameter_packs);
4407 return;
4408 }
4409
4410 if (!AL.isPackExpansion() &&
4412 TInfo, Sema::UPPC_Expression))
4413 return;
4414
4415 S.AddAlignedAttr(D, AL, TInfo, AL.isPackExpansion());
4416 return;
4417 }
4418
4419 // check the attribute arguments.
4420 if (AL.getNumArgs() > 1) {
4421 S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) << AL << 1;
4422 return;
4423 }
4424
4425 if (AL.getNumArgs() == 0) {
4426 D->addAttr(::new (S.Context) AlignedAttr(S.Context, AL, true, nullptr));
4427 return;
4428 }
4429
4430 Expr *E = AL.getArgAsExpr(0);
4432 S.Diag(AL.getEllipsisLoc(),
4433 diag::err_pack_expansion_without_parameter_packs);
4434 return;
4435 }
4436
4438 return;
4439
4440 S.AddAlignedAttr(D, AL, E, AL.isPackExpansion());
4441}
4442
4443/// Perform checking of type validity
4444///
4445/// C++11 [dcl.align]p1:
4446/// An alignment-specifier may be applied to a variable or to a class
4447/// data member, but it shall not be applied to a bit-field, a function
4448/// parameter, the formal parameter of a catch clause, or a variable
4449/// declared with the register storage class specifier. An
4450/// alignment-specifier may also be applied to the declaration of a class
4451/// or enumeration type.
4452/// CWG 2354:
4453/// CWG agreed to remove permission for alignas to be applied to
4454/// enumerations.
4455/// C11 6.7.5/2:
4456/// An alignment attribute shall not be specified in a declaration of
4457/// a typedef, or a bit-field, or a function, or a parameter, or an
4458/// object declared with the register storage-class specifier.
4460 const AlignedAttr &Attr,
4461 SourceLocation AttrLoc) {
4462 int DiagKind = -1;
4463 if (isa<ParmVarDecl>(D)) {
4464 DiagKind = 0;
4465 } else if (const auto *VD = dyn_cast<VarDecl>(D)) {
4466 if (VD->getStorageClass() == SC_Register)
4467 DiagKind = 1;
4468 if (VD->isExceptionVariable())
4469 DiagKind = 2;
4470 } else if (const auto *FD = dyn_cast<FieldDecl>(D)) {
4471 if (FD->isBitField())
4472 DiagKind = 3;
4473 } else if (const auto *ED = dyn_cast<EnumDecl>(D)) {
4474 if (ED->getLangOpts().CPlusPlus)
4475 DiagKind = 4;
4476 } else if (!isa<TagDecl>(D)) {
4477 return S.Diag(AttrLoc, diag::err_attribute_wrong_decl_type)
4479 << (Attr.isC11() ? ExpectedVariableOrField
4481 }
4482 if (DiagKind != -1) {
4483 return S.Diag(AttrLoc, diag::err_alignas_attribute_wrong_decl_type)
4484 << &Attr << DiagKind;
4485 }
4486 return false;
4487}
4488
4490 bool IsPackExpansion) {
4491 AlignedAttr TmpAttr(Context, CI, true, E);
4492 SourceLocation AttrLoc = CI.getLoc();
4493
4494 // C++11 alignas(...) and C11 _Alignas(...) have additional requirements.
4495 if (TmpAttr.isAlignas() &&
4496 validateAlignasAppliedType(*this, D, TmpAttr, AttrLoc))
4497 return;
4498
4499 if (E->isValueDependent()) {
4500 // We can't support a dependent alignment on a non-dependent type,
4501 // because we have no way to model that a type is "alignment-dependent"
4502 // but not dependent in any other way.
4503 if (const auto *TND = dyn_cast<TypedefNameDecl>(D)) {
4504 if (!TND->getUnderlyingType()->isDependentType()) {
4505 Diag(AttrLoc, diag::err_alignment_dependent_typedef_name)
4506 << E->getSourceRange();
4507 return;
4508 }
4509 }
4510
4511 // Save dependent expressions in the AST to be instantiated.
4512 AlignedAttr *AA = ::new (Context) AlignedAttr(Context, CI, true, E);
4513 AA->setPackExpansion(IsPackExpansion);
4514 D->addAttr(AA);
4515 return;
4516 }
4517
4518 // FIXME: Cache the number on the AL object?
4519 llvm::APSInt Alignment;
4521 E, &Alignment, diag::err_aligned_attribute_argument_not_int);
4522 if (ICE.isInvalid())
4523 return;
4524
4526 if (Context.getTargetInfo().getTriple().isOSBinFormatCOFF())
4527 MaximumAlignment = std::min(MaximumAlignment, uint64_t(8192));
4528 if (Alignment > MaximumAlignment) {
4529 Diag(AttrLoc, diag::err_attribute_aligned_too_great)
4531 return;
4532 }
4533
4534 uint64_t AlignVal = Alignment.getZExtValue();
4535 // C++11 [dcl.align]p2:
4536 // -- if the constant expression evaluates to zero, the alignment
4537 // specifier shall have no effect
4538 // C11 6.7.5p6:
4539 // An alignment specification of zero has no effect.
4540 if (!(TmpAttr.isAlignas() && !Alignment)) {
4541 if (!llvm::isPowerOf2_64(AlignVal)) {
4542 Diag(AttrLoc, diag::err_alignment_not_power_of_two)
4543 << E->getSourceRange();
4544 return;
4545 }
4546 }
4547
4548 const auto *VD = dyn_cast<VarDecl>(D);
4549 if (VD) {
4550 unsigned MaxTLSAlign =
4552 .getQuantity();
4553 if (MaxTLSAlign && AlignVal > MaxTLSAlign &&
4554 VD->getTLSKind() != VarDecl::TLS_None) {
4555 Diag(VD->getLocation(), diag::err_tls_var_aligned_over_maximum)
4556 << (unsigned)AlignVal << VD << MaxTLSAlign;
4557 return;
4558 }
4559 }
4560
4561 // On AIX, an aligned attribute can not decrease the alignment when applied
4562 // to a variable declaration with vector type.
4563 if (VD && Context.getTargetInfo().getTriple().isOSAIX()) {
4564 const Type *Ty = VD->getType().getTypePtr();
4565 if (Ty->isVectorType() && AlignVal < 16) {
4566 Diag(VD->getLocation(), diag::warn_aligned_attr_underaligned)
4567 << VD->getType() << 16;
4568 return;
4569 }
4570 }
4571
4572 AlignedAttr *AA = ::new (Context) AlignedAttr(Context, CI, true, ICE.get());
4573 AA->setPackExpansion(IsPackExpansion);
4574 AA->setCachedAlignmentValue(
4575 static_cast<unsigned>(AlignVal * Context.getCharWidth()));
4576 D->addAttr(AA);
4577}
4578
4580 TypeSourceInfo *TS, bool IsPackExpansion) {
4581 AlignedAttr TmpAttr(Context, CI, false, TS);
4582 SourceLocation AttrLoc = CI.getLoc();
4583
4584 // C++11 alignas(...) and C11 _Alignas(...) have additional requirements.
4585 if (TmpAttr.isAlignas() &&
4586 validateAlignasAppliedType(*this, D, TmpAttr, AttrLoc))
4587 return;
4588
4589 if (TS->getType()->isDependentType()) {
4590 // We can't support a dependent alignment on a non-dependent type,
4591 // because we have no way to model that a type is "type-dependent"
4592 // but not dependent in any other way.
4593 if (const auto *TND = dyn_cast<TypedefNameDecl>(D)) {
4594 if (!TND->getUnderlyingType()->isDependentType()) {
4595 Diag(AttrLoc, diag::err_alignment_dependent_typedef_name)
4596 << TS->getTypeLoc().getSourceRange();
4597 return;
4598 }
4599 }
4600
4601 AlignedAttr *AA = ::new (Context) AlignedAttr(Context, CI, false, TS);
4602 AA->setPackExpansion(IsPackExpansion);
4603 D->addAttr(AA);
4604 return;
4605 }
4606
4607 const auto *VD = dyn_cast<VarDecl>(D);
4608 unsigned AlignVal = TmpAttr.getAlignment(Context);
4609 // On AIX, an aligned attribute can not decrease the alignment when applied
4610 // to a variable declaration with vector type.
4611 if (VD && Context.getTargetInfo().getTriple().isOSAIX()) {
4612 const Type *Ty = VD->getType().getTypePtr();
4613 if (Ty->isVectorType() &&
4614 Context.toCharUnitsFromBits(AlignVal).getQuantity() < 16) {
4615 Diag(VD->getLocation(), diag::warn_aligned_attr_underaligned)
4616 << VD->getType() << 16;
4617 return;
4618 }
4619 }
4620
4621 AlignedAttr *AA = ::new (Context) AlignedAttr(Context, CI, false, TS);
4622 AA->setPackExpansion(IsPackExpansion);
4623 AA->setCachedAlignmentValue(AlignVal);
4624 D->addAttr(AA);
4625}
4626
4628 assert(D->hasAttrs() && "no attributes on decl");
4629
4630 QualType UnderlyingTy, DiagTy;
4631 if (const auto *VD = dyn_cast<ValueDecl>(D)) {
4632 UnderlyingTy = DiagTy = VD->getType();
4633 } else {
4634 UnderlyingTy = DiagTy = Context.getTagDeclType(cast<TagDecl>(D));
4635 if (const auto *ED = dyn_cast<EnumDecl>(D))
4636 UnderlyingTy = ED->getIntegerType();
4637 }
4638 if (DiagTy->isDependentType() || DiagTy->isIncompleteType())
4639 return;
4640
4641 // C++11 [dcl.align]p5, C11 6.7.5/4:
4642 // The combined effect of all alignment attributes in a declaration shall
4643 // not specify an alignment that is less strict than the alignment that
4644 // would otherwise be required for the entity being declared.
4645 AlignedAttr *AlignasAttr = nullptr;
4646 AlignedAttr *LastAlignedAttr = nullptr;
4647 unsigned Align = 0;
4648 for (auto *I : D->specific_attrs<AlignedAttr>()) {
4649 if (I->isAlignmentDependent())
4650 return;
4651 if (I->isAlignas())
4652 AlignasAttr = I;
4653 Align = std::max(Align, I->getAlignment(Context));
4654 LastAlignedAttr = I;
4655 }
4656
4657 if (Align && DiagTy->isSizelessType()) {
4658 Diag(LastAlignedAttr->getLocation(), diag::err_attribute_sizeless_type)
4659 << LastAlignedAttr << DiagTy;
4660 } else if (AlignasAttr && Align) {
4661 CharUnits RequestedAlign = Context.toCharUnitsFromBits(Align);
4662 CharUnits NaturalAlign = Context.getTypeAlignInChars(UnderlyingTy);
4663 if (NaturalAlign > RequestedAlign)
4664 Diag(AlignasAttr->getLocation(), diag::err_alignas_underaligned)
4665 << DiagTy << (unsigned)NaturalAlign.getQuantity();
4666 }
4667}
4668
4670 CXXRecordDecl *RD, SourceRange Range, bool BestCase,
4671 MSInheritanceModel ExplicitModel) {
4672 assert(RD->hasDefinition() && "RD has no definition!");
4673
4674 // We may not have seen base specifiers or any virtual methods yet. We will
4675 // have to wait until the record is defined to catch any mismatches.
4676 if (!RD->getDefinition()->isCompleteDefinition())
4677 return false;
4678
4679 // The unspecified model never matches what a definition could need.
4680 if (ExplicitModel == MSInheritanceModel::Unspecified)
4681 return false;
4682
4683 if (BestCase) {
4684 if (RD->calculateInheritanceModel() == ExplicitModel)
4685 return false;
4686 } else {
4687 if (RD->calculateInheritanceModel() <= ExplicitModel)
4688 return false;
4689 }
4690
4691 Diag(Range.getBegin(), diag::err_mismatched_ms_inheritance)
4692 << 0 /*definition*/;
4693 Diag(RD->getDefinition()->getLocation(), diag::note_defined_here) << RD;
4694 return true;
4695}
4696
4697/// parseModeAttrArg - Parses attribute mode string and returns parsed type
4698/// attribute.
4699static void parseModeAttrArg(Sema &S, StringRef Str, unsigned &DestWidth,
4700 bool &IntegerMode, bool &ComplexMode,
4701 FloatModeKind &ExplicitType) {
4702 IntegerMode = true;
4703 ComplexMode = false;
4704 ExplicitType = FloatModeKind::NoFloat;
4705 switch (Str.size()) {
4706 case 2:
4707 switch (Str[0]) {
4708 case 'Q':
4709 DestWidth = 8;
4710 break;
4711 case 'H':
4712 DestWidth = 16;
4713 break;
4714 case 'S':
4715 DestWidth = 32;
4716 break;
4717 case 'D':
4718 DestWidth = 64;
4719 break;
4720 case 'X':
4721 DestWidth = 96;
4722 break;
4723 case 'K': // KFmode - IEEE quad precision (__float128)
4724 ExplicitType = FloatModeKind::Float128;
4725 DestWidth = Str[1] == 'I' ? 0 : 128;
4726 break;
4727 case 'T':
4728 ExplicitType = FloatModeKind::LongDouble;
4729 DestWidth = 128;
4730 break;
4731 case 'I':
4732 ExplicitType = FloatModeKind::Ibm128;
4733 DestWidth = Str[1] == 'I' ? 0 : 128;
4734 break;
4735 }
4736 if (Str[1] == 'F') {
4737 IntegerMode = false;
4738 } else if (Str[1] == 'C') {
4739 IntegerMode = false;
4740 ComplexMode = true;
4741 } else if (Str[1] != 'I') {
4742 DestWidth = 0;
4743 }
4744 break;
4745 case 4:
4746 // FIXME: glibc uses 'word' to define register_t; this is narrower than a
4747 // pointer on PIC16 and other embedded platforms.
4748 if (Str == "word")
4749 DestWidth = S.Context.getTargetInfo().getRegisterWidth();
4750 else if (Str == "byte")
4751 DestWidth = S.Context.getTargetInfo().getCharWidth();
4752 break;
4753 case 7:
4754 if (Str == "pointer")
4756 break;
4757 case 11:
4758 if (Str == "unwind_word")
4759 DestWidth = S.Context.getTargetInfo().getUnwindWordWidth();
4760 break;
4761 }
4762}
4763
4764/// handleModeAttr - This attribute modifies the width of a decl with primitive
4765/// type.
4766///
4767/// Despite what would be logical, the mode attribute is a decl attribute, not a
4768/// type attribute: 'int ** __attribute((mode(HI))) *G;' tries to make 'G' be
4769/// HImode, not an intermediate pointer.
4770static void handleModeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4771 // This attribute isn't documented, but glibc uses it. It changes
4772 // the width of an int or unsigned int to the specified size.
4773 if (!AL.isArgIdent(0)) {
4774 S.Diag(AL.getLoc(), diag::err_attribute_argument_type)
4775 << AL << AANT_ArgumentIdentifier;
4776 return;
4777 }
4778
4779 IdentifierInfo *Name = AL.getArgAsIdent(0)->Ident;
4780
4781 S.AddModeAttr(D, AL, Name);
4782}
4783
4785 IdentifierInfo *Name, bool InInstantiation) {
4786 StringRef Str = Name->getName();
4787 normalizeName(Str);
4788 SourceLocation AttrLoc = CI.getLoc();
4789
4790 unsigned DestWidth = 0;
4791 bool IntegerMode = true;
4792 bool ComplexMode = false;
4794 llvm::APInt VectorSize(64, 0);
4795 if (Str.size() >= 4 && Str[0] == 'V') {
4796 // Minimal length of vector mode is 4: 'V' + NUMBER(>=1) + TYPE(>=2).
4797 size_t StrSize = Str.size();
4798 size_t VectorStringLength = 0;
4799 while ((VectorStringLength + 1) < StrSize &&
4800 isdigit(Str[VectorStringLength + 1]))
4801 ++VectorStringLength;
4802 if (VectorStringLength &&
4803 !Str.substr(1, VectorStringLength).getAsInteger(10, VectorSize) &&
4804 VectorSize.isPowerOf2()) {
4805 parseModeAttrArg(*this, Str.substr(VectorStringLength + 1), DestWidth,
4806 IntegerMode, ComplexMode, ExplicitType);
4807 // Avoid duplicate warning from template instantiation.
4808 if (!InInstantiation)
4809 Diag(AttrLoc, diag::warn_vector_mode_deprecated);
4810 } else {
4811 VectorSize = 0;
4812 }
4813 }
4814
4815 if (!VectorSize)
4816 parseModeAttrArg(*this, Str, DestWidth, IntegerMode, ComplexMode,
4817 ExplicitType);
4818
4819 // FIXME: Sync this with InitializePredefinedMacros; we need to match int8_t
4820 // and friends, at least with glibc.
4821 // FIXME: Make sure floating-point mappings are accurate
4822 // FIXME: Support XF and TF types
4823 if (!DestWidth) {
4824 Diag(AttrLoc, diag::err_machine_mode) << 0 /*Unknown*/ << Name;
4825 return;
4826 }
4827
4828 QualType OldTy;
4829 if (const auto *TD = dyn_cast<TypedefNameDecl>(D))
4830 OldTy = TD->getUnderlyingType();
4831 else if (const auto *ED = dyn_cast<EnumDecl>(D)) {
4832 // Something like 'typedef enum { X } __attribute__((mode(XX))) T;'.
4833 // Try to get type from enum declaration, default to int.
4834 OldTy = ED->getIntegerType();
4835 if (OldTy.isNull())
4836 OldTy = Context.IntTy;
4837 } else
4838 OldTy = cast<ValueDecl>(D)->getType();
4839
4840 if (OldTy->isDependentType()) {
4841 D->addAttr(::new (Context) ModeAttr(Context, CI, Name));
4842 return;
4843 }
4844
4845 // Base type can also be a vector type (see PR17453).
4846 // Distinguish between base type and base element type.
4847 QualType OldElemTy = OldTy;
4848 if (const auto *VT = OldTy->getAs<VectorType>())
4849 OldElemTy = VT->getElementType();
4850
4851 // GCC allows 'mode' attribute on enumeration types (even incomplete), except
4852 // for vector modes. So, 'enum X __attribute__((mode(QI)));' forms a complete
4853 // type, 'enum { A } __attribute__((mode(V4SI)))' is rejected.
4854 if ((isa<EnumDecl>(D) || OldElemTy->getAs<EnumType>()) &&
4855 VectorSize.getBoolValue()) {
4856 Diag(AttrLoc, diag::err_enum_mode_vector_type) << Name << CI.getRange();
4857 return;
4858 }
4859 bool IntegralOrAnyEnumType = (OldElemTy->isIntegralOrEnumerationType() &&
4860 !OldElemTy->isBitIntType()) ||
4861 OldElemTy->getAs<EnumType>();
4862
4863 if (!OldElemTy->getAs<BuiltinType>() && !OldElemTy->isComplexType() &&
4864 !IntegralOrAnyEnumType)
4865 Diag(AttrLoc, diag::err_mode_not_primitive);
4866 else if (IntegerMode) {
4867 if (!IntegralOrAnyEnumType)
4868 Diag(AttrLoc, diag::err_mode_wrong_type);
4869 } else if (ComplexMode) {
4870 if (!OldElemTy->isComplexType())
4871 Diag(AttrLoc, diag::err_mode_wrong_type);
4872 } else {
4873 if (!OldElemTy->isFloatingType())
4874 Diag(AttrLoc, diag::err_mode_wrong_type);
4875 }
4876
4877 QualType NewElemTy;
4878
4879 if (IntegerMode)
4880 NewElemTy = Context.getIntTypeForBitwidth(DestWidth,
4881 OldElemTy->isSignedIntegerType());
4882 else
4883 NewElemTy = Context.getRealTypeForBitwidth(DestWidth, ExplicitType);
4884
4885 if (NewElemTy.isNull()) {
4886 Diag(AttrLoc, diag::err_machine_mode) << 1 /*Unsupported*/ << Name;
4887 return;
4888 }
4889
4890 if (ComplexMode) {
4891 NewElemTy = Context.getComplexType(NewElemTy);
4892 }
4893
4894 QualType NewTy = NewElemTy;
4895 if (VectorSize.getBoolValue()) {
4896 NewTy = Context.getVectorType(NewTy, VectorSize.getZExtValue(),
4898 } else if (const auto *OldVT = OldTy->getAs<VectorType>()) {
4899 // Complex machine mode does not support base vector types.
4900 if (ComplexMode) {
4901 Diag(AttrLoc, diag::err_complex_mode_vector_type);
4902 return;
4903 }
4904 unsigned NumElements = Context.getTypeSize(OldElemTy) *
4905 OldVT->getNumElements() /
4906 Context.getTypeSize(NewElemTy);
4907 NewTy =
4908 Context.getVectorType(NewElemTy, NumElements, OldVT->getVectorKind());
4909 }
4910
4911 if (NewTy.isNull()) {
4912 Diag(AttrLoc, diag::err_mode_wrong_type);
4913 return;
4914 }
4915
4916 // Install the new type.
4917 if (auto *TD = dyn_cast<TypedefNameDecl>(D))
4918 TD->setModedTypeSourceInfo(TD->getTypeSourceInfo(), NewTy);
4919 else if (auto *ED = dyn_cast<EnumDecl>(D))
4920 ED->setIntegerType(NewTy);
4921 else
4922 cast<ValueDecl>(D)->setType(NewTy);
4923
4924 D->addAttr(::new (Context) ModeAttr(Context, CI, Name));
4925}
4926
4927static void handleNoDebugAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4928 D->addAttr(::new (S.Context) NoDebugAttr(S.Context, AL));
4929}
4930
4932 const AttributeCommonInfo &CI,
4933 const IdentifierInfo *Ident) {
4934 if (OptimizeNoneAttr *Optnone = D->getAttr<OptimizeNoneAttr>()) {
4935 Diag(CI.getLoc(), diag::warn_attribute_ignored) << Ident;
4936 Diag(Optnone->getLocation(), diag::note_conflicting_attribute);
4937 return nullptr;
4938 }
4939
4940 if (D->hasAttr<AlwaysInlineAttr>())
4941 return nullptr;
4942
4943 return ::new (Context) AlwaysInlineAttr(Context, CI);
4944}
4945
4946InternalLinkageAttr *Sema::mergeInternalLinkageAttr(Decl *D,
4947 const ParsedAttr &AL) {
4948 if (const auto *VD = dyn_cast<VarDecl>(D)) {
4949 // Attribute applies to Var but not any subclass of it (like ParmVar,
4950 // ImplicitParm or VarTemplateSpecialization).
4951 if (VD->getKind() != Decl::Var) {
4952 Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type)
4953 << AL << AL.isRegularKeywordAttribute()
4956 return nullptr;
4957 }
4958 // Attribute does not apply to non-static local variables.
4959 if (VD->hasLocalStorage()) {
4960 Diag(VD->getLocation(), diag::warn_internal_linkage_local_storage);
4961 return nullptr;
4962 }
4963 }
4964
4965 return ::new (Context) InternalLinkageAttr(Context, AL);
4966}
4967InternalLinkageAttr *
4968Sema::mergeInternalLinkageAttr(Decl *D, const InternalLinkageAttr &AL) {
4969 if (const auto *VD = dyn_cast<VarDecl>(D)) {