Bug Summary

File:tools/clang/lib/Sema/SemaDeclAttr.cpp
Warning:line 4132, column 53
Potential leak of memory pointed to by field 'DiagStorage'

Annotated Source Code

/build/llvm-toolchain-snapshot-6.0~svn318882/tools/clang/lib/Sema/SemaDeclAttr.cpp

1//===--- SemaDeclAttr.cpp - Declaration Attribute Handling ----------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements decl-related attribute processing.
11//
12//===----------------------------------------------------------------------===//
13
14#include "clang/AST/ASTConsumer.h"
15#include "clang/AST/ASTContext.h"
16#include "clang/AST/ASTMutationListener.h"
17#include "clang/AST/CXXInheritance.h"
18#include "clang/AST/DeclCXX.h"
19#include "clang/AST/DeclObjC.h"
20#include "clang/AST/DeclTemplate.h"
21#include "clang/AST/Expr.h"
22#include "clang/AST/ExprCXX.h"
23#include "clang/AST/Mangle.h"
24#include "clang/AST/RecursiveASTVisitor.h"
25#include "clang/Basic/CharInfo.h"
26#include "clang/Basic/SourceManager.h"
27#include "clang/Basic/TargetInfo.h"
28#include "clang/Lex/Preprocessor.h"
29#include "clang/Sema/DeclSpec.h"
30#include "clang/Sema/DelayedDiagnostic.h"
31#include "clang/Sema/Initialization.h"
32#include "clang/Sema/Lookup.h"
33#include "clang/Sema/Scope.h"
34#include "clang/Sema/SemaInternal.h"
35#include "llvm/ADT/STLExtras.h"
36#include "llvm/ADT/StringExtras.h"
37#include "llvm/Support/MathExtras.h"
38
39using namespace clang;
40using namespace sema;
41
42namespace AttributeLangSupport {
43 enum LANG {
44 C,
45 Cpp,
46 ObjC
47 };
48} // end namespace AttributeLangSupport
49
50//===----------------------------------------------------------------------===//
51// Helper functions
52//===----------------------------------------------------------------------===//
53
54/// isFunctionOrMethod - Return true if the given decl has function
55/// type (function or function-typed variable) or an Objective-C
56/// method.
57static bool isFunctionOrMethod(const Decl *D) {
58 return (D->getFunctionType() != nullptr) || isa<ObjCMethodDecl>(D);
59}
60
61/// \brief Return true if the given decl has function type (function or
62/// function-typed variable) or an Objective-C method or a block.
63static bool isFunctionOrMethodOrBlock(const Decl *D) {
64 return isFunctionOrMethod(D) || isa<BlockDecl>(D);
65}
66
67/// Return true if the given decl has a declarator that should have
68/// been processed by Sema::GetTypeForDeclarator.
69static bool hasDeclarator(const Decl *D) {
70 // In some sense, TypedefDecl really *ought* to be a DeclaratorDecl.
71 return isa<DeclaratorDecl>(D) || isa<BlockDecl>(D) || isa<TypedefNameDecl>(D) ||
72 isa<ObjCPropertyDecl>(D);
73}
74
75/// hasFunctionProto - Return true if the given decl has a argument
76/// information. This decl should have already passed
77/// isFunctionOrMethod or isFunctionOrMethodOrBlock.
78static bool hasFunctionProto(const Decl *D) {
79 if (const FunctionType *FnTy = D->getFunctionType())
80 return isa<FunctionProtoType>(FnTy);
81 return isa<ObjCMethodDecl>(D) || isa<BlockDecl>(D);
82}
83
84/// getFunctionOrMethodNumParams - Return number of function or method
85/// parameters. It is an error to call this on a K&R function (use
86/// hasFunctionProto first).
87static unsigned getFunctionOrMethodNumParams(const Decl *D) {
88 if (const FunctionType *FnTy = D->getFunctionType())
89 return cast<FunctionProtoType>(FnTy)->getNumParams();
90 if (const BlockDecl *BD = dyn_cast<BlockDecl>(D))
91 return BD->getNumParams();
92 return cast<ObjCMethodDecl>(D)->param_size();
93}
94
95static QualType getFunctionOrMethodParamType(const Decl *D, unsigned Idx) {
96 if (const FunctionType *FnTy = D->getFunctionType())
97 return cast<FunctionProtoType>(FnTy)->getParamType(Idx);
98 if (const BlockDecl *BD = dyn_cast<BlockDecl>(D))
99 return BD->getParamDecl(Idx)->getType();
100
101 return cast<ObjCMethodDecl>(D)->parameters()[Idx]->getType();
102}
103
104static SourceRange getFunctionOrMethodParamRange(const Decl *D, unsigned Idx) {
105 if (const auto *FD = dyn_cast<FunctionDecl>(D))
106 return FD->getParamDecl(Idx)->getSourceRange();
107 if (const auto *MD = dyn_cast<ObjCMethodDecl>(D))
108 return MD->parameters()[Idx]->getSourceRange();
109 if (const auto *BD = dyn_cast<BlockDecl>(D))
110 return BD->getParamDecl(Idx)->getSourceRange();
111 return SourceRange();
112}
113
114static QualType getFunctionOrMethodResultType(const Decl *D) {
115 if (const FunctionType *FnTy = D->getFunctionType())
116 return cast<FunctionType>(FnTy)->getReturnType();
117 return cast<ObjCMethodDecl>(D)->getReturnType();
118}
119
120static SourceRange getFunctionOrMethodResultSourceRange(const Decl *D) {
121 if (const auto *FD = dyn_cast<FunctionDecl>(D))
122 return FD->getReturnTypeSourceRange();
123 if (const auto *MD = dyn_cast<ObjCMethodDecl>(D))
124 return MD->getReturnTypeSourceRange();
125 return SourceRange();
126}
127
128static bool isFunctionOrMethodVariadic(const Decl *D) {
129 if (const FunctionType *FnTy = D->getFunctionType()) {
130 const FunctionProtoType *proto = cast<FunctionProtoType>(FnTy);
131 return proto->isVariadic();
132 }
133 if (const BlockDecl *BD = dyn_cast<BlockDecl>(D))
134 return BD->isVariadic();
135
136 return cast<ObjCMethodDecl>(D)->isVariadic();
137}
138
139static bool isInstanceMethod(const Decl *D) {
140 if (const CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(D))
141 return MethodDecl->isInstance();
142 return false;
143}
144
145static inline bool isNSStringType(QualType T, ASTContext &Ctx) {
146 const ObjCObjectPointerType *PT = T->getAs<ObjCObjectPointerType>();
147 if (!PT)
148 return false;
149
150 ObjCInterfaceDecl *Cls = PT->getObjectType()->getInterface();
151 if (!Cls)
152 return false;
153
154 IdentifierInfo* ClsName = Cls->getIdentifier();
155
156 // FIXME: Should we walk the chain of classes?
157 return ClsName == &Ctx.Idents.get("NSString") ||
158 ClsName == &Ctx.Idents.get("NSMutableString");
159}
160
161static inline bool isCFStringType(QualType T, ASTContext &Ctx) {
162 const PointerType *PT = T->getAs<PointerType>();
163 if (!PT)
164 return false;
165
166 const RecordType *RT = PT->getPointeeType()->getAs<RecordType>();
167 if (!RT)
168 return false;
169
170 const RecordDecl *RD = RT->getDecl();
171 if (RD->getTagKind() != TTK_Struct)
172 return false;
173
174 return RD->getIdentifier() == &Ctx.Idents.get("__CFString");
175}
176
177static unsigned getNumAttributeArgs(const AttributeList &Attr) {
178 // FIXME: Include the type in the argument list.
179 return Attr.getNumArgs() + Attr.hasParsedType();
180}
181
182template <typename Compare>
183static bool checkAttributeNumArgsImpl(Sema &S, const AttributeList &Attr,
184 unsigned Num, unsigned Diag,
185 Compare Comp) {
186 if (Comp(getNumAttributeArgs(Attr), Num)) {
187 S.Diag(Attr.getLoc(), Diag) << Attr.getName() << Num;
188 return false;
189 }
190
191 return true;
192}
193
194/// \brief Check if the attribute has exactly as many args as Num. May
195/// output an error.
196static bool checkAttributeNumArgs(Sema &S, const AttributeList &Attr,
197 unsigned Num) {
198 return checkAttributeNumArgsImpl(S, Attr, Num,
199 diag::err_attribute_wrong_number_arguments,
200 std::not_equal_to<unsigned>());
201}
202
203/// \brief Check if the attribute has at least as many args as Num. May
204/// output an error.
205static bool checkAttributeAtLeastNumArgs(Sema &S, const AttributeList &Attr,
206 unsigned Num) {
207 return checkAttributeNumArgsImpl(S, Attr, Num,
208 diag::err_attribute_too_few_arguments,
209 std::less<unsigned>());
210}
211
212/// \brief Check if the attribute has at most as many args as Num. May
213/// output an error.
214static bool checkAttributeAtMostNumArgs(Sema &S, const AttributeList &Attr,
215 unsigned Num) {
216 return checkAttributeNumArgsImpl(S, Attr, Num,
217 diag::err_attribute_too_many_arguments,
218 std::greater<unsigned>());
219}
220
221/// \brief A helper function to provide Attribute Location for the Attr types
222/// AND the AttributeList.
223template <typename AttrInfo>
224static typename std::enable_if<std::is_base_of<clang::Attr, AttrInfo>::value,
225 SourceLocation>::type
226getAttrLoc(const AttrInfo &Attr) {
227 return Attr.getLocation();
228}
229static SourceLocation getAttrLoc(const clang::AttributeList &Attr) {
230 return Attr.getLoc();
231}
232
233/// \brief A helper function to provide Attribute Name for the Attr types
234/// AND the AttributeList.
235template <typename AttrInfo>
236static typename std::enable_if<std::is_base_of<clang::Attr, AttrInfo>::value,
237 const AttrInfo *>::type
238getAttrName(const AttrInfo &Attr) {
239 return &Attr;
240}
241static const IdentifierInfo *getAttrName(const clang::AttributeList &Attr) {
242 return Attr.getName();
243}
244
245/// \brief If Expr is a valid integer constant, get the value of the integer
246/// expression and return success or failure. May output an error.
247template<typename AttrInfo>
248static bool checkUInt32Argument(Sema &S, const AttrInfo& Attr, const Expr *Expr,
249 uint32_t &Val, unsigned Idx = UINT_MAX(2147483647 *2U +1U)) {
250 llvm::APSInt I(32);
251 if (Expr->isTypeDependent() || Expr->isValueDependent() ||
252 !Expr->isIntegerConstantExpr(I, S.Context)) {
253 if (Idx != UINT_MAX(2147483647 *2U +1U))
254 S.Diag(getAttrLoc(Attr), diag::err_attribute_argument_n_type)
255 << getAttrName(Attr) << Idx << AANT_ArgumentIntegerConstant
256 << Expr->getSourceRange();
257 else
258 S.Diag(getAttrLoc(Attr), diag::err_attribute_argument_type)
259 << getAttrName(Attr) << AANT_ArgumentIntegerConstant
260 << Expr->getSourceRange();
261 return false;
262 }
263
264 if (!I.isIntN(32)) {
265 S.Diag(Expr->getExprLoc(), diag::err_ice_too_large)
266 << I.toString(10, false) << 32 << /* Unsigned */ 1;
267 return false;
268 }
269
270 Val = (uint32_t)I.getZExtValue();
271 return true;
272}
273
274/// \brief Wrapper around checkUInt32Argument, with an extra check to be sure
275/// that the result will fit into a regular (signed) int. All args have the same
276/// purpose as they do in checkUInt32Argument.
277template<typename AttrInfo>
278static bool checkPositiveIntArgument(Sema &S, const AttrInfo& Attr, const Expr *Expr,
279 int &Val, unsigned Idx = UINT_MAX(2147483647 *2U +1U)) {
280 uint32_t UVal;
281 if (!checkUInt32Argument(S, Attr, Expr, UVal, Idx))
282 return false;
283
284 if (UVal > (uint32_t)std::numeric_limits<int>::max()) {
285 llvm::APSInt I(32); // for toString
286 I = UVal;
287 S.Diag(Expr->getExprLoc(), diag::err_ice_too_large)
288 << I.toString(10, false) << 32 << /* Unsigned */ 0;
289 return false;
290 }
291
292 Val = UVal;
293 return true;
294}
295
296/// \brief Diagnose mutually exclusive attributes when present on a given
297/// declaration. Returns true if diagnosed.
298template <typename AttrTy>
299static bool checkAttrMutualExclusion(Sema &S, Decl *D, SourceRange Range,
300 IdentifierInfo *Ident) {
301 if (AttrTy *A = D->getAttr<AttrTy>()) {
302 S.Diag(Range.getBegin(), diag::err_attributes_are_not_compatible) << Ident
303 << A;
304 S.Diag(A->getLocation(), diag::note_conflicting_attribute);
305 return true;
306 }
307 return false;
308}
309
310/// \brief Check if IdxExpr is a valid parameter index for a function or
311/// instance method D. May output an error.
312///
313/// \returns true if IdxExpr is a valid index.
314template <typename AttrInfo>
315static bool checkFunctionOrMethodParameterIndex(
316 Sema &S, const Decl *D, const AttrInfo &Attr, unsigned AttrArgNum,
317 const Expr *IdxExpr, uint64_t &Idx, bool AllowImplicitThis = false) {
318 assert(isFunctionOrMethodOrBlock(D))(static_cast <bool> (isFunctionOrMethodOrBlock(D)) ? void
(0) : __assert_fail ("isFunctionOrMethodOrBlock(D)", "/build/llvm-toolchain-snapshot-6.0~svn318882/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 318, __extension__ __PRETTY_FUNCTION__))
;
319
320 // In C++ the implicit 'this' function parameter also counts.
321 // Parameters are counted from one.
322 bool HP = hasFunctionProto(D);
323 bool HasImplicitThisParam = isInstanceMethod(D);
324 bool IV = HP && isFunctionOrMethodVariadic(D);
325 unsigned NumParams =
326 (HP ? getFunctionOrMethodNumParams(D) : 0) + HasImplicitThisParam;
327
328 llvm::APSInt IdxInt;
329 if (IdxExpr->isTypeDependent() || IdxExpr->isValueDependent() ||
330 !IdxExpr->isIntegerConstantExpr(IdxInt, S.Context)) {
331 S.Diag(getAttrLoc(Attr), diag::err_attribute_argument_n_type)
332 << getAttrName(Attr) << AttrArgNum << AANT_ArgumentIntegerConstant
333 << IdxExpr->getSourceRange();
334 return false;
335 }
336
337 Idx = IdxInt.getLimitedValue();
338 if (Idx < 1 || (!IV && Idx > NumParams)) {
339 S.Diag(getAttrLoc(Attr), diag::err_attribute_argument_out_of_bounds)
340 << getAttrName(Attr) << AttrArgNum << IdxExpr->getSourceRange();
341 return false;
342 }
343 Idx--; // Convert to zero-based.
344 if (HasImplicitThisParam && !AllowImplicitThis) {
345 if (Idx == 0) {
346 S.Diag(getAttrLoc(Attr),
347 diag::err_attribute_invalid_implicit_this_argument)
348 << getAttrName(Attr) << IdxExpr->getSourceRange();
349 return false;
350 }
351 --Idx;
352 }
353
354 return true;
355}
356
357/// \brief Check if the argument \p ArgNum of \p Attr is a ASCII string literal.
358/// If not emit an error and return false. If the argument is an identifier it
359/// will emit an error with a fixit hint and treat it as if it was a string
360/// literal.
361bool Sema::checkStringLiteralArgumentAttr(const AttributeList &Attr,
362 unsigned ArgNum, StringRef &Str,
363 SourceLocation *ArgLocation) {
364 // Look for identifiers. If we have one emit a hint to fix it to a literal.
365 if (Attr.isArgIdent(ArgNum)) {
366 IdentifierLoc *Loc = Attr.getArgAsIdent(ArgNum);
367 Diag(Loc->Loc, diag::err_attribute_argument_type)
368 << Attr.getName() << AANT_ArgumentString
369 << FixItHint::CreateInsertion(Loc->Loc, "\"")
370 << FixItHint::CreateInsertion(getLocForEndOfToken(Loc->Loc), "\"");
371 Str = Loc->Ident->getName();
372 if (ArgLocation)
373 *ArgLocation = Loc->Loc;
374 return true;
375 }
376
377 // Now check for an actual string literal.
378 Expr *ArgExpr = Attr.getArgAsExpr(ArgNum);
379 StringLiteral *Literal = dyn_cast<StringLiteral>(ArgExpr->IgnoreParenCasts());
380 if (ArgLocation)
381 *ArgLocation = ArgExpr->getLocStart();
382
383 if (!Literal || !Literal->isAscii()) {
384 Diag(ArgExpr->getLocStart(), diag::err_attribute_argument_type)
385 << Attr.getName() << AANT_ArgumentString;
386 return false;
387 }
388
389 Str = Literal->getString();
390 return true;
391}
392
393/// \brief Applies the given attribute to the Decl without performing any
394/// additional semantic checking.
395template <typename AttrType>
396static void handleSimpleAttribute(Sema &S, Decl *D,
397 const AttributeList &Attr) {
398 D->addAttr(::new (S.Context) AttrType(Attr.getRange(), S.Context,
399 Attr.getAttributeSpellingListIndex()));
400}
401
402template <typename AttrType>
403static void handleSimpleAttributeWithExclusions(Sema &S, Decl *D,
404 const AttributeList &Attr) {
405 handleSimpleAttribute<AttrType>(S, D, Attr);
406}
407
408/// \brief Applies the given attribute to the Decl so long as the Decl doesn't
409/// already have one of the given incompatible attributes.
410template <typename AttrType, typename IncompatibleAttrType,
411 typename... IncompatibleAttrTypes>
412static void handleSimpleAttributeWithExclusions(Sema &S, Decl *D,
413 const AttributeList &Attr) {
414 if (checkAttrMutualExclusion<IncompatibleAttrType>(S, D, Attr.getRange(),
415 Attr.getName()))
416 return;
417 handleSimpleAttributeWithExclusions<AttrType, IncompatibleAttrTypes...>(S, D,
418 Attr);
419}
420
421/// \brief Check if the passed-in expression is of type int or bool.
422static bool isIntOrBool(Expr *Exp) {
423 QualType QT = Exp->getType();
424 return QT->isBooleanType() || QT->isIntegerType();
425}
426
427
428// Check to see if the type is a smart pointer of some kind. We assume
429// it's a smart pointer if it defines both operator-> and operator*.
430static bool threadSafetyCheckIsSmartPointer(Sema &S, const RecordType* RT) {
431 DeclContextLookupResult Res1 = RT->getDecl()->lookup(
432 S.Context.DeclarationNames.getCXXOperatorName(OO_Star));
433 if (Res1.empty())
434 return false;
435
436 DeclContextLookupResult Res2 = RT->getDecl()->lookup(
437 S.Context.DeclarationNames.getCXXOperatorName(OO_Arrow));
438 if (Res2.empty())
439 return false;
440
441 return true;
442}
443
444/// \brief Check if passed in Decl is a pointer type.
445/// Note that this function may produce an error message.
446/// \return true if the Decl is a pointer type; false otherwise
447static bool threadSafetyCheckIsPointer(Sema &S, const Decl *D,
448 const AttributeList &Attr) {
449 const ValueDecl *vd = cast<ValueDecl>(D);
450 QualType QT = vd->getType();
451 if (QT->isAnyPointerType())
452 return true;
453
454 if (const RecordType *RT = QT->getAs<RecordType>()) {
455 // If it's an incomplete type, it could be a smart pointer; skip it.
456 // (We don't want to force template instantiation if we can avoid it,
457 // since that would alter the order in which templates are instantiated.)
458 if (RT->isIncompleteType())
459 return true;
460
461 if (threadSafetyCheckIsSmartPointer(S, RT))
462 return true;
463 }
464
465 S.Diag(Attr.getLoc(), diag::warn_thread_attribute_decl_not_pointer)
466 << Attr.getName() << QT;
467 return false;
468}
469
470/// \brief Checks that the passed in QualType either is of RecordType or points
471/// to RecordType. Returns the relevant RecordType, null if it does not exit.
472static const RecordType *getRecordType(QualType QT) {
473 if (const RecordType *RT = QT->getAs<RecordType>())
474 return RT;
475
476 // Now check if we point to record type.
477 if (const PointerType *PT = QT->getAs<PointerType>())
478 return PT->getPointeeType()->getAs<RecordType>();
479
480 return nullptr;
481}
482
483static bool checkRecordTypeForCapability(Sema &S, QualType Ty) {
484 const RecordType *RT = getRecordType(Ty);
485
486 if (!RT)
487 return false;
488
489 // Don't check for the capability if the class hasn't been defined yet.
490 if (RT->isIncompleteType())
491 return true;
492
493 // Allow smart pointers to be used as capability objects.
494 // FIXME -- Check the type that the smart pointer points to.
495 if (threadSafetyCheckIsSmartPointer(S, RT))
496 return true;
497
498 // Check if the record itself has a capability.
499 RecordDecl *RD = RT->getDecl();
500 if (RD->hasAttr<CapabilityAttr>())
501 return true;
502
503 // Else check if any base classes have a capability.
504 if (CXXRecordDecl *CRD = dyn_cast<CXXRecordDecl>(RD)) {
505 CXXBasePaths BPaths(false, false);
506 if (CRD->lookupInBases([](const CXXBaseSpecifier *BS, CXXBasePath &) {
507 const auto *Type = BS->getType()->getAs<RecordType>();
508 return Type->getDecl()->hasAttr<CapabilityAttr>();
509 }, BPaths))
510 return true;
511 }
512 return false;
513}
514
515static bool checkTypedefTypeForCapability(QualType Ty) {
516 const auto *TD = Ty->getAs<TypedefType>();
517 if (!TD)
518 return false;
519
520 TypedefNameDecl *TN = TD->getDecl();
521 if (!TN)
522 return false;
523
524 return TN->hasAttr<CapabilityAttr>();
525}
526
527static bool typeHasCapability(Sema &S, QualType Ty) {
528 if (checkTypedefTypeForCapability(Ty))
529 return true;
530
531 if (checkRecordTypeForCapability(S, Ty))
532 return true;
533
534 return false;
535}
536
537static bool isCapabilityExpr(Sema &S, const Expr *Ex) {
538 // Capability expressions are simple expressions involving the boolean logic
539 // operators &&, || or !, a simple DeclRefExpr, CastExpr or a ParenExpr. Once
540 // a DeclRefExpr is found, its type should be checked to determine whether it
541 // is a capability or not.
542
543 if (const auto *E = dyn_cast<DeclRefExpr>(Ex))
544 return typeHasCapability(S, E->getType());
545 else if (const auto *E = dyn_cast<CastExpr>(Ex))
546 return isCapabilityExpr(S, E->getSubExpr());
547 else if (const auto *E = dyn_cast<ParenExpr>(Ex))
548 return isCapabilityExpr(S, E->getSubExpr());
549 else if (const auto *E = dyn_cast<UnaryOperator>(Ex)) {
550 if (E->getOpcode() == UO_LNot)
551 return isCapabilityExpr(S, E->getSubExpr());
552 return false;
553 } else if (const auto *E = dyn_cast<BinaryOperator>(Ex)) {
554 if (E->getOpcode() == BO_LAnd || E->getOpcode() == BO_LOr)
555 return isCapabilityExpr(S, E->getLHS()) &&
556 isCapabilityExpr(S, E->getRHS());
557 return false;
558 }
559
560 return false;
561}
562
563/// \brief Checks that all attribute arguments, starting from Sidx, resolve to
564/// a capability object.
565/// \param Sidx The attribute argument index to start checking with.
566/// \param ParamIdxOk Whether an argument can be indexing into a function
567/// parameter list.
568static void checkAttrArgsAreCapabilityObjs(Sema &S, Decl *D,
569 const AttributeList &Attr,
570 SmallVectorImpl<Expr *> &Args,
571 int Sidx = 0,
572 bool ParamIdxOk = false) {
573 for (unsigned Idx = Sidx; Idx < Attr.getNumArgs(); ++Idx) {
574 Expr *ArgExp = Attr.getArgAsExpr(Idx);
575
576 if (ArgExp->isTypeDependent()) {
577 // FIXME -- need to check this again on template instantiation
578 Args.push_back(ArgExp);
579 continue;
580 }
581
582 if (StringLiteral *StrLit = dyn_cast<StringLiteral>(ArgExp)) {
583 if (StrLit->getLength() == 0 ||
584 (StrLit->isAscii() && StrLit->getString() == StringRef("*"))) {
585 // Pass empty strings to the analyzer without warnings.
586 // Treat "*" as the universal lock.
587 Args.push_back(ArgExp);
588 continue;
589 }
590
591 // We allow constant strings to be used as a placeholder for expressions
592 // that are not valid C++ syntax, but warn that they are ignored.
593 S.Diag(Attr.getLoc(), diag::warn_thread_attribute_ignored) <<
594 Attr.getName();
595 Args.push_back(ArgExp);
596 continue;
597 }
598
599 QualType ArgTy = ArgExp->getType();
600
601 // A pointer to member expression of the form &MyClass::mu is treated
602 // specially -- we need to look at the type of the member.
603 if (UnaryOperator *UOp = dyn_cast<UnaryOperator>(ArgExp))
604 if (UOp->getOpcode() == UO_AddrOf)
605 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(UOp->getSubExpr()))
606 if (DRE->getDecl()->isCXXInstanceMember())
607 ArgTy = DRE->getDecl()->getType();
608
609 // First see if we can just cast to record type, or pointer to record type.
610 const RecordType *RT = getRecordType(ArgTy);
611
612 // Now check if we index into a record type function param.
613 if(!RT && ParamIdxOk) {
614 FunctionDecl *FD = dyn_cast<FunctionDecl>(D);
615 IntegerLiteral *IL = dyn_cast<IntegerLiteral>(ArgExp);
616 if(FD && IL) {
617 unsigned int NumParams = FD->getNumParams();
618 llvm::APInt ArgValue = IL->getValue();
619 uint64_t ParamIdxFromOne = ArgValue.getZExtValue();
620 uint64_t ParamIdxFromZero = ParamIdxFromOne - 1;
621 if(!ArgValue.isStrictlyPositive() || ParamIdxFromOne > NumParams) {
622 S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_range)
623 << Attr.getName() << Idx + 1 << NumParams;
624 continue;
625 }
626 ArgTy = FD->getParamDecl(ParamIdxFromZero)->getType();
627 }
628 }
629
630 // If the type does not have a capability, see if the components of the
631 // expression have capabilities. This allows for writing C code where the
632 // capability may be on the type, and the expression is a capability
633 // boolean logic expression. Eg) requires_capability(A || B && !C)
634 if (!typeHasCapability(S, ArgTy) && !isCapabilityExpr(S, ArgExp))
635 S.Diag(Attr.getLoc(), diag::warn_thread_attribute_argument_not_lockable)
636 << Attr.getName() << ArgTy;
637
638 Args.push_back(ArgExp);
639 }
640}
641
642//===----------------------------------------------------------------------===//
643// Attribute Implementations
644//===----------------------------------------------------------------------===//
645
646static void handlePtGuardedVarAttr(Sema &S, Decl *D,
647 const AttributeList &Attr) {
648 if (!threadSafetyCheckIsPointer(S, D, Attr))
649 return;
650
651 D->addAttr(::new (S.Context)
652 PtGuardedVarAttr(Attr.getRange(), S.Context,
653 Attr.getAttributeSpellingListIndex()));
654}
655
656static bool checkGuardedByAttrCommon(Sema &S, Decl *D,
657 const AttributeList &Attr,
658 Expr* &Arg) {
659 SmallVector<Expr*, 1> Args;
660 // check that all arguments are lockable objects
661 checkAttrArgsAreCapabilityObjs(S, D, Attr, Args);
662 unsigned Size = Args.size();
663 if (Size != 1)
664 return false;
665
666 Arg = Args[0];
667
668 return true;
669}
670
671static void handleGuardedByAttr(Sema &S, Decl *D, const AttributeList &Attr) {
672 Expr *Arg = nullptr;
673 if (!checkGuardedByAttrCommon(S, D, Attr, Arg))
674 return;
675
676 D->addAttr(::new (S.Context) GuardedByAttr(Attr.getRange(), S.Context, Arg,
677 Attr.getAttributeSpellingListIndex()));
678}
679
680static void handlePtGuardedByAttr(Sema &S, Decl *D,
681 const AttributeList &Attr) {
682 Expr *Arg = nullptr;
683 if (!checkGuardedByAttrCommon(S, D, Attr, Arg))
684 return;
685
686 if (!threadSafetyCheckIsPointer(S, D, Attr))
687 return;
688
689 D->addAttr(::new (S.Context) PtGuardedByAttr(Attr.getRange(),
690 S.Context, Arg,
691 Attr.getAttributeSpellingListIndex()));
692}
693
694static bool checkAcquireOrderAttrCommon(Sema &S, Decl *D,
695 const AttributeList &Attr,
696 SmallVectorImpl<Expr *> &Args) {
697 if (!checkAttributeAtLeastNumArgs(S, Attr, 1))
698 return false;
699
700 // Check that this attribute only applies to lockable types.
701 QualType QT = cast<ValueDecl>(D)->getType();
702 if (!QT->isDependentType() && !typeHasCapability(S, QT)) {
703 S.Diag(Attr.getLoc(), diag::warn_thread_attribute_decl_not_lockable)
704 << Attr.getName();
705 return false;
706 }
707
708 // Check that all arguments are lockable objects.
709 checkAttrArgsAreCapabilityObjs(S, D, Attr, Args);
710 if (Args.empty())
711 return false;
712
713 return true;
714}
715
716static void handleAcquiredAfterAttr(Sema &S, Decl *D,
717 const AttributeList &Attr) {
718 SmallVector<Expr*, 1> Args;
719 if (!checkAcquireOrderAttrCommon(S, D, Attr, Args))
720 return;
721
722 Expr **StartArg = &Args[0];
723 D->addAttr(::new (S.Context)
724 AcquiredAfterAttr(Attr.getRange(), S.Context,
725 StartArg, Args.size(),
726 Attr.getAttributeSpellingListIndex()));
727}
728
729static void handleAcquiredBeforeAttr(Sema &S, Decl *D,
730 const AttributeList &Attr) {
731 SmallVector<Expr*, 1> Args;
732 if (!checkAcquireOrderAttrCommon(S, D, Attr, Args))
733 return;
734
735 Expr **StartArg = &Args[0];
736 D->addAttr(::new (S.Context)
737 AcquiredBeforeAttr(Attr.getRange(), S.Context,
738 StartArg, Args.size(),
739 Attr.getAttributeSpellingListIndex()));
740}
741
742static bool checkLockFunAttrCommon(Sema &S, Decl *D,
743 const AttributeList &Attr,
744 SmallVectorImpl<Expr *> &Args) {
745 // zero or more arguments ok
746 // check that all arguments are lockable objects
747 checkAttrArgsAreCapabilityObjs(S, D, Attr, Args, 0, /*ParamIdxOk=*/true);
748
749 return true;
750}
751
752static void handleAssertSharedLockAttr(Sema &S, Decl *D,
753 const AttributeList &Attr) {
754 SmallVector<Expr*, 1> Args;
755 if (!checkLockFunAttrCommon(S, D, Attr, Args))
756 return;
757
758 unsigned Size = Args.size();
759 Expr **StartArg = Size == 0 ? nullptr : &Args[0];
760 D->addAttr(::new (S.Context)
761 AssertSharedLockAttr(Attr.getRange(), S.Context, StartArg, Size,
762 Attr.getAttributeSpellingListIndex()));
763}
764
765static void handleAssertExclusiveLockAttr(Sema &S, Decl *D,
766 const AttributeList &Attr) {
767 SmallVector<Expr*, 1> Args;
768 if (!checkLockFunAttrCommon(S, D, Attr, Args))
769 return;
770
771 unsigned Size = Args.size();
772 Expr **StartArg = Size == 0 ? nullptr : &Args[0];
773 D->addAttr(::new (S.Context)
774 AssertExclusiveLockAttr(Attr.getRange(), S.Context,
775 StartArg, Size,
776 Attr.getAttributeSpellingListIndex()));
777}
778
779/// \brief Checks to be sure that the given parameter number is in bounds, and is
780/// an integral type. Will emit appropriate diagnostics if this returns
781/// false.
782///
783/// FuncParamNo is expected to be from the user, so is base-1. AttrArgNo is used
784/// to actually retrieve the argument, so it's base-0.
785template <typename AttrInfo>
786static bool checkParamIsIntegerType(Sema &S, const FunctionDecl *FD,
787 const AttrInfo &Attr, Expr *AttrArg,
788 unsigned FuncParamNo, unsigned AttrArgNo,
789 bool AllowDependentType = false) {
790 uint64_t Idx;
791 if (!checkFunctionOrMethodParameterIndex(S, FD, Attr, FuncParamNo, AttrArg,
792 Idx))
793 return false;
794
795 const ParmVarDecl *Param = FD->getParamDecl(Idx);
796 if (AllowDependentType && Param->getType()->isDependentType())
797 return true;
798 if (!Param->getType()->isIntegerType() && !Param->getType()->isCharType()) {
799 SourceLocation SrcLoc = AttrArg->getLocStart();
800 S.Diag(SrcLoc, diag::err_attribute_integers_only)
801 << getAttrName(Attr) << Param->getSourceRange();
802 return false;
803 }
804 return true;
805}
806
807/// \brief Checks to be sure that the given parameter number is in bounds, and is
808/// an integral type. Will emit appropriate diagnostics if this returns false.
809///
810/// FuncParamNo is expected to be from the user, so is base-1. AttrArgNo is used
811/// to actually retrieve the argument, so it's base-0.
812static bool checkParamIsIntegerType(Sema &S, const FunctionDecl *FD,
813 const AttributeList &Attr,
814 unsigned FuncParamNo, unsigned AttrArgNo,
815 bool AllowDependentType = false) {
816 assert(Attr.isArgExpr(AttrArgNo) && "Expected expression argument")(static_cast <bool> (Attr.isArgExpr(AttrArgNo) &&
"Expected expression argument") ? void (0) : __assert_fail (
"Attr.isArgExpr(AttrArgNo) && \"Expected expression argument\""
, "/build/llvm-toolchain-snapshot-6.0~svn318882/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 816, __extension__ __PRETTY_FUNCTION__))
;
817 return checkParamIsIntegerType(S, FD, Attr, Attr.getArgAsExpr(AttrArgNo),
818 FuncParamNo, AttrArgNo, AllowDependentType);
819}
820
821static void handleAllocSizeAttr(Sema &S, Decl *D, const AttributeList &Attr) {
822 if (!checkAttributeAtLeastNumArgs(S, Attr, 1) ||
823 !checkAttributeAtMostNumArgs(S, Attr, 2))
824 return;
825
826 const auto *FD = cast<FunctionDecl>(D);
827 if (!FD->getReturnType()->isPointerType()) {
828 S.Diag(Attr.getLoc(), diag::warn_attribute_return_pointers_only)
829 << Attr.getName();
830 return;
831 }
832
833 const Expr *SizeExpr = Attr.getArgAsExpr(0);
834 int SizeArgNo;
835 // Parameter indices are 1-indexed, hence Index=1
836 if (!checkPositiveIntArgument(S, Attr, SizeExpr, SizeArgNo, /*Index=*/1))
837 return;
838
839 if (!checkParamIsIntegerType(S, FD, Attr, SizeArgNo, /*AttrArgNo=*/0))
840 return;
841
842 // Args are 1-indexed, so 0 implies that the arg was not present
843 int NumberArgNo = 0;
844 if (Attr.getNumArgs() == 2) {
845 const Expr *NumberExpr = Attr.getArgAsExpr(1);
846 // Parameter indices are 1-based, hence Index=2
847 if (!checkPositiveIntArgument(S, Attr, NumberExpr, NumberArgNo,
848 /*Index=*/2))
849 return;
850
851 if (!checkParamIsIntegerType(S, FD, Attr, NumberArgNo, /*AttrArgNo=*/1))
852 return;
853 }
854
855 D->addAttr(::new (S.Context) AllocSizeAttr(
856 Attr.getRange(), S.Context, SizeArgNo, NumberArgNo,
857 Attr.getAttributeSpellingListIndex()));
858}
859
860static bool checkTryLockFunAttrCommon(Sema &S, Decl *D,
861 const AttributeList &Attr,
862 SmallVectorImpl<Expr *> &Args) {
863 if (!checkAttributeAtLeastNumArgs(S, Attr, 1))
864 return false;
865
866 if (!isIntOrBool(Attr.getArgAsExpr(0))) {
867 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_type)
868 << Attr.getName() << 1 << AANT_ArgumentIntOrBool;
869 return false;
870 }
871
872 // check that all arguments are lockable objects
873 checkAttrArgsAreCapabilityObjs(S, D, Attr, Args, 1);
874
875 return true;
876}
877
878static void handleSharedTrylockFunctionAttr(Sema &S, Decl *D,
879 const AttributeList &Attr) {
880 SmallVector<Expr*, 2> Args;
881 if (!checkTryLockFunAttrCommon(S, D, Attr, Args))
882 return;
883
884 D->addAttr(::new (S.Context)
885 SharedTrylockFunctionAttr(Attr.getRange(), S.Context,
886 Attr.getArgAsExpr(0),
887 Args.data(), Args.size(),
888 Attr.getAttributeSpellingListIndex()));
889}
890
891static void handleExclusiveTrylockFunctionAttr(Sema &S, Decl *D,
892 const AttributeList &Attr) {
893 SmallVector<Expr*, 2> Args;
894 if (!checkTryLockFunAttrCommon(S, D, Attr, Args))
895 return;
896
897 D->addAttr(::new (S.Context) ExclusiveTrylockFunctionAttr(
898 Attr.getRange(), S.Context, Attr.getArgAsExpr(0), Args.data(),
899 Args.size(), Attr.getAttributeSpellingListIndex()));
900}
901
902static void handleLockReturnedAttr(Sema &S, Decl *D,
903 const AttributeList &Attr) {
904 // check that the argument is lockable object
905 SmallVector<Expr*, 1> Args;
906 checkAttrArgsAreCapabilityObjs(S, D, Attr, Args);
907 unsigned Size = Args.size();
908 if (Size == 0)
909 return;
910
911 D->addAttr(::new (S.Context)
912 LockReturnedAttr(Attr.getRange(), S.Context, Args[0],
913 Attr.getAttributeSpellingListIndex()));
914}
915
916static void handleLocksExcludedAttr(Sema &S, Decl *D,
917 const AttributeList &Attr) {
918 if (!checkAttributeAtLeastNumArgs(S, Attr, 1))
919 return;
920
921 // check that all arguments are lockable objects
922 SmallVector<Expr*, 1> Args;
923 checkAttrArgsAreCapabilityObjs(S, D, Attr, Args);
924 unsigned Size = Args.size();
925 if (Size == 0)
926 return;
927 Expr **StartArg = &Args[0];
928
929 D->addAttr(::new (S.Context)
930 LocksExcludedAttr(Attr.getRange(), S.Context, StartArg, Size,
931 Attr.getAttributeSpellingListIndex()));
932}
933
934static bool checkFunctionConditionAttr(Sema &S, Decl *D,
935 const AttributeList &Attr,
936 Expr *&Cond, StringRef &Msg) {
937 Cond = Attr.getArgAsExpr(0);
938 if (!Cond->isTypeDependent()) {
939 ExprResult Converted = S.PerformContextuallyConvertToBool(Cond);
940 if (Converted.isInvalid())
941 return false;
942 Cond = Converted.get();
943 }
944
945 if (!S.checkStringLiteralArgumentAttr(Attr, 1, Msg))
946 return false;
947
948 if (Msg.empty())
949 Msg = "<no message provided>";
950
951 SmallVector<PartialDiagnosticAt, 8> Diags;
952 if (isa<FunctionDecl>(D) && !Cond->isValueDependent() &&
953 !Expr::isPotentialConstantExprUnevaluated(Cond, cast<FunctionDecl>(D),
954 Diags)) {
955 S.Diag(Attr.getLoc(), diag::err_attr_cond_never_constant_expr)
956 << Attr.getName();
957 for (const PartialDiagnosticAt &PDiag : Diags)
958 S.Diag(PDiag.first, PDiag.second);
959 return false;
960 }
961 return true;
962}
963
964static void handleEnableIfAttr(Sema &S, Decl *D, const AttributeList &Attr) {
965 S.Diag(Attr.getLoc(), diag::ext_clang_enable_if);
966
967 Expr *Cond;
968 StringRef Msg;
969 if (checkFunctionConditionAttr(S, D, Attr, Cond, Msg))
970 D->addAttr(::new (S.Context)
971 EnableIfAttr(Attr.getRange(), S.Context, Cond, Msg,
972 Attr.getAttributeSpellingListIndex()));
973}
974
975namespace {
976/// Determines if a given Expr references any of the given function's
977/// ParmVarDecls, or the function's implicit `this` parameter (if applicable).
978class ArgumentDependenceChecker
979 : public RecursiveASTVisitor<ArgumentDependenceChecker> {
980#ifndef NDEBUG
981 const CXXRecordDecl *ClassType;
982#endif
983 llvm::SmallPtrSet<const ParmVarDecl *, 16> Parms;
984 bool Result;
985
986public:
987 ArgumentDependenceChecker(const FunctionDecl *FD) {
988#ifndef NDEBUG
989 if (const auto *MD = dyn_cast<CXXMethodDecl>(FD))
990 ClassType = MD->getParent();
991 else
992 ClassType = nullptr;
993#endif
994 Parms.insert(FD->param_begin(), FD->param_end());
995 }
996
997 bool referencesArgs(Expr *E) {
998 Result = false;
999 TraverseStmt(E);
1000 return Result;
1001 }
1002
1003 bool VisitCXXThisExpr(CXXThisExpr *E) {
1004 assert(E->getType()->getPointeeCXXRecordDecl() == ClassType &&(static_cast <bool> (E->getType()->getPointeeCXXRecordDecl
() == ClassType && "`this` doesn't refer to the enclosing class?"
) ? void (0) : __assert_fail ("E->getType()->getPointeeCXXRecordDecl() == ClassType && \"`this` doesn't refer to the enclosing class?\""
, "/build/llvm-toolchain-snapshot-6.0~svn318882/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 1005, __extension__ __PRETTY_FUNCTION__))
1005 "`this` doesn't refer to the enclosing class?")(static_cast <bool> (E->getType()->getPointeeCXXRecordDecl
() == ClassType && "`this` doesn't refer to the enclosing class?"
) ? void (0) : __assert_fail ("E->getType()->getPointeeCXXRecordDecl() == ClassType && \"`this` doesn't refer to the enclosing class?\""
, "/build/llvm-toolchain-snapshot-6.0~svn318882/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 1005, __extension__ __PRETTY_FUNCTION__))
;
1006 Result = true;
1007 return false;
1008 }
1009
1010 bool VisitDeclRefExpr(DeclRefExpr *DRE) {
1011 if (const auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl()))
1012 if (Parms.count(PVD)) {
1013 Result = true;
1014 return false;
1015 }
1016 return true;
1017 }
1018};
1019}
1020
1021static void handleDiagnoseIfAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1022 S.Diag(Attr.getLoc(), diag::ext_clang_diagnose_if);
1023
1024 Expr *Cond;
1025 StringRef Msg;
1026 if (!checkFunctionConditionAttr(S, D, Attr, Cond, Msg))
1027 return;
1028
1029 StringRef DiagTypeStr;
1030 if (!S.checkStringLiteralArgumentAttr(Attr, 2, DiagTypeStr))
1031 return;
1032
1033 DiagnoseIfAttr::DiagnosticType DiagType;
1034 if (!DiagnoseIfAttr::ConvertStrToDiagnosticType(DiagTypeStr, DiagType)) {
1035 S.Diag(Attr.getArgAsExpr(2)->getLocStart(),
1036 diag::err_diagnose_if_invalid_diagnostic_type);
1037 return;
1038 }
1039
1040 bool ArgDependent = false;
1041 if (const auto *FD = dyn_cast<FunctionDecl>(D))
1042 ArgDependent = ArgumentDependenceChecker(FD).referencesArgs(Cond);
1043 D->addAttr(::new (S.Context) DiagnoseIfAttr(
1044 Attr.getRange(), S.Context, Cond, Msg, DiagType, ArgDependent, cast<NamedDecl>(D),
1045 Attr.getAttributeSpellingListIndex()));
1046}
1047
1048static void handlePassObjectSizeAttr(Sema &S, Decl *D,
1049 const AttributeList &Attr) {
1050 if (D->hasAttr<PassObjectSizeAttr>()) {
1051 S.Diag(D->getLocStart(), diag::err_attribute_only_once_per_parameter)
1052 << Attr.getName();
1053 return;
1054 }
1055
1056 Expr *E = Attr.getArgAsExpr(0);
1057 uint32_t Type;
1058 if (!checkUInt32Argument(S, Attr, E, Type, /*Idx=*/1))
1059 return;
1060
1061 // pass_object_size's argument is passed in as the second argument of
1062 // __builtin_object_size. So, it has the same constraints as that second
1063 // argument; namely, it must be in the range [0, 3].
1064 if (Type > 3) {
1065 S.Diag(E->getLocStart(), diag::err_attribute_argument_outof_range)
1066 << Attr.getName() << 0 << 3 << E->getSourceRange();
1067 return;
1068 }
1069
1070 // pass_object_size is only supported on constant pointer parameters; as a
1071 // kindness to users, we allow the parameter to be non-const for declarations.
1072 // At this point, we have no clue if `D` belongs to a function declaration or
1073 // definition, so we defer the constness check until later.
1074 if (!cast<ParmVarDecl>(D)->getType()->isPointerType()) {
1075 S.Diag(D->getLocStart(), diag::err_attribute_pointers_only)
1076 << Attr.getName() << 1;
1077 return;
1078 }
1079
1080 D->addAttr(::new (S.Context)
1081 PassObjectSizeAttr(Attr.getRange(), S.Context, (int)Type,
1082 Attr.getAttributeSpellingListIndex()));
1083}
1084
1085static void handleConsumableAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1086 ConsumableAttr::ConsumedState DefaultState;
1087
1088 if (Attr.isArgIdent(0)) {
1089 IdentifierLoc *IL = Attr.getArgAsIdent(0);
1090 if (!ConsumableAttr::ConvertStrToConsumedState(IL->Ident->getName(),
1091 DefaultState)) {
1092 S.Diag(IL->Loc, diag::warn_attribute_type_not_supported)
1093 << Attr.getName() << IL->Ident;
1094 return;
1095 }
1096 } else {
1097 S.Diag(Attr.getLoc(), diag::err_attribute_argument_type)
1098 << Attr.getName() << AANT_ArgumentIdentifier;
1099 return;
1100 }
1101
1102 D->addAttr(::new (S.Context)
1103 ConsumableAttr(Attr.getRange(), S.Context, DefaultState,
1104 Attr.getAttributeSpellingListIndex()));
1105}
1106
1107static bool checkForConsumableClass(Sema &S, const CXXMethodDecl *MD,
1108 const AttributeList &Attr) {
1109 ASTContext &CurrContext = S.getASTContext();
1110 QualType ThisType = MD->getThisType(CurrContext)->getPointeeType();
1111
1112 if (const CXXRecordDecl *RD = ThisType->getAsCXXRecordDecl()) {
1113 if (!RD->hasAttr<ConsumableAttr>()) {
1114 S.Diag(Attr.getLoc(), diag::warn_attr_on_unconsumable_class) <<
1115 RD->getNameAsString();
1116
1117 return false;
1118 }
1119 }
1120
1121 return true;
1122}
1123
1124static void handleCallableWhenAttr(Sema &S, Decl *D,
1125 const AttributeList &Attr) {
1126 if (!checkAttributeAtLeastNumArgs(S, Attr, 1))
1127 return;
1128
1129 if (!checkForConsumableClass(S, cast<CXXMethodDecl>(D), Attr))
1130 return;
1131
1132 SmallVector<CallableWhenAttr::ConsumedState, 3> States;
1133 for (unsigned ArgIndex = 0; ArgIndex < Attr.getNumArgs(); ++ArgIndex) {
1134 CallableWhenAttr::ConsumedState CallableState;
1135
1136 StringRef StateString;
1137 SourceLocation Loc;
1138 if (Attr.isArgIdent(ArgIndex)) {
1139 IdentifierLoc *Ident = Attr.getArgAsIdent(ArgIndex);
1140 StateString = Ident->Ident->getName();
1141 Loc = Ident->Loc;
1142 } else {
1143 if (!S.checkStringLiteralArgumentAttr(Attr, ArgIndex, StateString, &Loc))
1144 return;
1145 }
1146
1147 if (!CallableWhenAttr::ConvertStrToConsumedState(StateString,
1148 CallableState)) {
1149 S.Diag(Loc, diag::warn_attribute_type_not_supported)
1150 << Attr.getName() << StateString;
1151 return;
1152 }
1153
1154 States.push_back(CallableState);
1155 }
1156
1157 D->addAttr(::new (S.Context)
1158 CallableWhenAttr(Attr.getRange(), S.Context, States.data(),
1159 States.size(), Attr.getAttributeSpellingListIndex()));
1160}
1161
1162static void handleParamTypestateAttr(Sema &S, Decl *D,
1163 const AttributeList &Attr) {
1164 ParamTypestateAttr::ConsumedState ParamState;
1165
1166 if (Attr.isArgIdent(0)) {
1167 IdentifierLoc *Ident = Attr.getArgAsIdent(0);
1168 StringRef StateString = Ident->Ident->getName();
1169
1170 if (!ParamTypestateAttr::ConvertStrToConsumedState(StateString,
1171 ParamState)) {
1172 S.Diag(Ident->Loc, diag::warn_attribute_type_not_supported)
1173 << Attr.getName() << StateString;
1174 return;
1175 }
1176 } else {
1177 S.Diag(Attr.getLoc(), diag::err_attribute_argument_type) <<
1178 Attr.getName() << AANT_ArgumentIdentifier;
1179 return;
1180 }
1181
1182 // FIXME: This check is currently being done in the analysis. It can be
1183 // enabled here only after the parser propagates attributes at
1184 // template specialization definition, not declaration.
1185 //QualType ReturnType = cast<ParmVarDecl>(D)->getType();
1186 //const CXXRecordDecl *RD = ReturnType->getAsCXXRecordDecl();
1187 //
1188 //if (!RD || !RD->hasAttr<ConsumableAttr>()) {
1189 // S.Diag(Attr.getLoc(), diag::warn_return_state_for_unconsumable_type) <<
1190 // ReturnType.getAsString();
1191 // return;
1192 //}
1193
1194 D->addAttr(::new (S.Context)
1195 ParamTypestateAttr(Attr.getRange(), S.Context, ParamState,
1196 Attr.getAttributeSpellingListIndex()));
1197}
1198
1199static void handleReturnTypestateAttr(Sema &S, Decl *D,
1200 const AttributeList &Attr) {
1201 ReturnTypestateAttr::ConsumedState ReturnState;
1202
1203 if (Attr.isArgIdent(0)) {
1204 IdentifierLoc *IL = Attr.getArgAsIdent(0);
1205 if (!ReturnTypestateAttr::ConvertStrToConsumedState(IL->Ident->getName(),
1206 ReturnState)) {
1207 S.Diag(IL->Loc, diag::warn_attribute_type_not_supported)
1208 << Attr.getName() << IL->Ident;
1209 return;
1210 }
1211 } else {
1212 S.Diag(Attr.getLoc(), diag::err_attribute_argument_type) <<
1213 Attr.getName() << AANT_ArgumentIdentifier;
1214 return;
1215 }
1216
1217 // FIXME: This check is currently being done in the analysis. It can be
1218 // enabled here only after the parser propagates attributes at
1219 // template specialization definition, not declaration.
1220 //QualType ReturnType;
1221 //
1222 //if (const ParmVarDecl *Param = dyn_cast<ParmVarDecl>(D)) {
1223 // ReturnType = Param->getType();
1224 //
1225 //} else if (const CXXConstructorDecl *Constructor =
1226 // dyn_cast<CXXConstructorDecl>(D)) {
1227 // ReturnType = Constructor->getThisType(S.getASTContext())->getPointeeType();
1228 //
1229 //} else {
1230 //
1231 // ReturnType = cast<FunctionDecl>(D)->getCallResultType();
1232 //}
1233 //
1234 //const CXXRecordDecl *RD = ReturnType->getAsCXXRecordDecl();
1235 //
1236 //if (!RD || !RD->hasAttr<ConsumableAttr>()) {
1237 // S.Diag(Attr.getLoc(), diag::warn_return_state_for_unconsumable_type) <<
1238 // ReturnType.getAsString();
1239 // return;
1240 //}
1241
1242 D->addAttr(::new (S.Context)
1243 ReturnTypestateAttr(Attr.getRange(), S.Context, ReturnState,
1244 Attr.getAttributeSpellingListIndex()));
1245}
1246
1247static void handleSetTypestateAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1248 if (!checkForConsumableClass(S, cast<CXXMethodDecl>(D), Attr))
1249 return;
1250
1251 SetTypestateAttr::ConsumedState NewState;
1252 if (Attr.isArgIdent(0)) {
1253 IdentifierLoc *Ident = Attr.getArgAsIdent(0);
1254 StringRef Param = Ident->Ident->getName();
1255 if (!SetTypestateAttr::ConvertStrToConsumedState(Param, NewState)) {
1256 S.Diag(Ident->Loc, diag::warn_attribute_type_not_supported)
1257 << Attr.getName() << Param;
1258 return;
1259 }
1260 } else {
1261 S.Diag(Attr.getLoc(), diag::err_attribute_argument_type) <<
1262 Attr.getName() << AANT_ArgumentIdentifier;
1263 return;
1264 }
1265
1266 D->addAttr(::new (S.Context)
1267 SetTypestateAttr(Attr.getRange(), S.Context, NewState,
1268 Attr.getAttributeSpellingListIndex()));
1269}
1270
1271static void handleTestTypestateAttr(Sema &S, Decl *D,
1272 const AttributeList &Attr) {
1273 if (!checkForConsumableClass(S, cast<CXXMethodDecl>(D), Attr))
1274 return;
1275
1276 TestTypestateAttr::ConsumedState TestState;
1277 if (Attr.isArgIdent(0)) {
1278 IdentifierLoc *Ident = Attr.getArgAsIdent(0);
1279 StringRef Param = Ident->Ident->getName();
1280 if (!TestTypestateAttr::ConvertStrToConsumedState(Param, TestState)) {
1281 S.Diag(Ident->Loc, diag::warn_attribute_type_not_supported)
1282 << Attr.getName() << Param;
1283 return;
1284 }
1285 } else {
1286 S.Diag(Attr.getLoc(), diag::err_attribute_argument_type) <<
1287 Attr.getName() << AANT_ArgumentIdentifier;
1288 return;
1289 }
1290
1291 D->addAttr(::new (S.Context)
1292 TestTypestateAttr(Attr.getRange(), S.Context, TestState,
1293 Attr.getAttributeSpellingListIndex()));
1294}
1295
1296static void handleExtVectorTypeAttr(Sema &S, Scope *scope, Decl *D,
1297 const AttributeList &Attr) {
1298 // Remember this typedef decl, we will need it later for diagnostics.
1299 S.ExtVectorDecls.push_back(cast<TypedefNameDecl>(D));
1300}
1301
1302static void handlePackedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1303 if (TagDecl *TD = dyn_cast<TagDecl>(D))
1304 TD->addAttr(::new (S.Context) PackedAttr(Attr.getRange(), S.Context,
1305 Attr.getAttributeSpellingListIndex()));
1306 else if (FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
1307 bool BitfieldByteAligned = (!FD->getType()->isDependentType() &&
1308 !FD->getType()->isIncompleteType() &&
1309 FD->isBitField() &&
1310 S.Context.getTypeAlign(FD->getType()) <= 8);
1311
1312 if (S.getASTContext().getTargetInfo().getTriple().isPS4()) {
1313 if (BitfieldByteAligned)
1314 // The PS4 target needs to maintain ABI backwards compatibility.
1315 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored_for_field_of_type)
1316 << Attr.getName() << FD->getType();
1317 else
1318 FD->addAttr(::new (S.Context) PackedAttr(
1319 Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
1320 } else {
1321 // Report warning about changed offset in the newer compiler versions.
1322 if (BitfieldByteAligned)
1323 S.Diag(Attr.getLoc(), diag::warn_attribute_packed_for_bitfield);
1324
1325 FD->addAttr(::new (S.Context) PackedAttr(
1326 Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
1327 }
1328
1329 } else
1330 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
1331}
1332
1333static bool checkIBOutletCommon(Sema &S, Decl *D, const AttributeList &Attr) {
1334 // The IBOutlet/IBOutletCollection attributes only apply to instance
1335 // variables or properties of Objective-C classes. The outlet must also
1336 // have an object reference type.
1337 if (const ObjCIvarDecl *VD = dyn_cast<ObjCIvarDecl>(D)) {
1338 if (!VD->getType()->getAs<ObjCObjectPointerType>()) {
1339 S.Diag(Attr.getLoc(), diag::warn_iboutlet_object_type)
1340 << Attr.getName() << VD->getType() << 0;
1341 return false;
1342 }
1343 }
1344 else if (const ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(D)) {
1345 if (!PD->getType()->getAs<ObjCObjectPointerType>()) {
1346 S.Diag(Attr.getLoc(), diag::warn_iboutlet_object_type)
1347 << Attr.getName() << PD->getType() << 1;
1348 return false;
1349 }
1350 }
1351 else {
1352 S.Diag(Attr.getLoc(), diag::warn_attribute_iboutlet) << Attr.getName();
1353 return false;
1354 }
1355
1356 return true;
1357}
1358
1359static void handleIBOutlet(Sema &S, Decl *D, const AttributeList &Attr) {
1360 if (!checkIBOutletCommon(S, D, Attr))
1361 return;
1362
1363 D->addAttr(::new (S.Context)
1364 IBOutletAttr(Attr.getRange(), S.Context,
1365 Attr.getAttributeSpellingListIndex()));
1366}
1367
1368static void handleIBOutletCollection(Sema &S, Decl *D,
1369 const AttributeList &Attr) {
1370
1371 // The iboutletcollection attribute can have zero or one arguments.
1372 if (Attr.getNumArgs() > 1) {
1373 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments)
1374 << Attr.getName() << 1;
1375 return;
1376 }
1377
1378 if (!checkIBOutletCommon(S, D, Attr))
1379 return;
1380
1381 ParsedType PT;
1382
1383 if (Attr.hasParsedType())
1384 PT = Attr.getTypeArg();
1385 else {
1386 PT = S.getTypeName(S.Context.Idents.get("NSObject"), Attr.getLoc(),
1387 S.getScopeForContext(D->getDeclContext()->getParent()));
1388 if (!PT) {
1389 S.Diag(Attr.getLoc(), diag::err_iboutletcollection_type) << "NSObject";
1390 return;
1391 }
1392 }
1393
1394 TypeSourceInfo *QTLoc = nullptr;
1395 QualType QT = S.GetTypeFromParser(PT, &QTLoc);
1396 if (!QTLoc)
1397 QTLoc = S.Context.getTrivialTypeSourceInfo(QT, Attr.getLoc());
1398
1399 // Diagnose use of non-object type in iboutletcollection attribute.
1400 // FIXME. Gnu attribute extension ignores use of builtin types in
1401 // attributes. So, __attribute__((iboutletcollection(char))) will be
1402 // treated as __attribute__((iboutletcollection())).
1403 if (!QT->isObjCIdType() && !QT->isObjCObjectType()) {
1404 S.Diag(Attr.getLoc(),
1405 QT->isBuiltinType() ? diag::err_iboutletcollection_builtintype
1406 : diag::err_iboutletcollection_type) << QT;
1407 return;
1408 }
1409
1410 D->addAttr(::new (S.Context)
1411 IBOutletCollectionAttr(Attr.getRange(), S.Context, QTLoc,
1412 Attr.getAttributeSpellingListIndex()));
1413}
1414
1415bool Sema::isValidPointerAttrType(QualType T, bool RefOkay) {
1416 if (RefOkay) {
1417 if (T->isReferenceType())
1418 return true;
1419 } else {
1420 T = T.getNonReferenceType();
1421 }
1422
1423 // The nonnull attribute, and other similar attributes, can be applied to a
1424 // transparent union that contains a pointer type.
1425 if (const RecordType *UT = T->getAsUnionType()) {
1426 if (UT && UT->getDecl()->hasAttr<TransparentUnionAttr>()) {
1427 RecordDecl *UD = UT->getDecl();
1428 for (const auto *I : UD->fields()) {
1429 QualType QT = I->getType();
1430 if (QT->isAnyPointerType() || QT->isBlockPointerType())
1431 return true;
1432 }
1433 }
1434 }
1435
1436 return T->isAnyPointerType() || T->isBlockPointerType();
1437}
1438
1439static bool attrNonNullArgCheck(Sema &S, QualType T, const AttributeList &Attr,
1440 SourceRange AttrParmRange,
1441 SourceRange TypeRange,
1442 bool isReturnValue = false) {
1443 if (!S.isValidPointerAttrType(T)) {
1444 if (isReturnValue)
1445 S.Diag(Attr.getLoc(), diag::warn_attribute_return_pointers_only)
1446 << Attr.getName() << AttrParmRange << TypeRange;
1447 else
1448 S.Diag(Attr.getLoc(), diag::warn_attribute_pointers_only)
1449 << Attr.getName() << AttrParmRange << TypeRange << 0;
1450 return false;
1451 }
1452 return true;
1453}
1454
1455static void handleNonNullAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1456 SmallVector<unsigned, 8> NonNullArgs;
1457 for (unsigned I = 0; I < Attr.getNumArgs(); ++I) {
1458 Expr *Ex = Attr.getArgAsExpr(I);
1459 uint64_t Idx;
1460 if (!checkFunctionOrMethodParameterIndex(S, D, Attr, I + 1, Ex, Idx))
1461 return;
1462
1463 // Is the function argument a pointer type?
1464 if (Idx < getFunctionOrMethodNumParams(D) &&
1465 !attrNonNullArgCheck(S, getFunctionOrMethodParamType(D, Idx), Attr,
1466 Ex->getSourceRange(),
1467 getFunctionOrMethodParamRange(D, Idx)))
1468 continue;
1469
1470 NonNullArgs.push_back(Idx);
1471 }
1472
1473 // If no arguments were specified to __attribute__((nonnull)) then all pointer
1474 // arguments have a nonnull attribute; warn if there aren't any. Skip this
1475 // check if the attribute came from a macro expansion or a template
1476 // instantiation.
1477 if (NonNullArgs.empty() && Attr.getLoc().isFileID() &&
1478 !S.inTemplateInstantiation()) {
1479 bool AnyPointers = isFunctionOrMethodVariadic(D);
1480 for (unsigned I = 0, E = getFunctionOrMethodNumParams(D);
1481 I != E && !AnyPointers; ++I) {
1482 QualType T = getFunctionOrMethodParamType(D, I);
1483 if (T->isDependentType() || S.isValidPointerAttrType(T))
1484 AnyPointers = true;
1485 }
1486
1487 if (!AnyPointers)
1488 S.Diag(Attr.getLoc(), diag::warn_attribute_nonnull_no_pointers);
1489 }
1490
1491 unsigned *Start = NonNullArgs.data();
1492 unsigned Size = NonNullArgs.size();
1493 llvm::array_pod_sort(Start, Start + Size);
1494 D->addAttr(::new (S.Context)
1495 NonNullAttr(Attr.getRange(), S.Context, Start, Size,
1496 Attr.getAttributeSpellingListIndex()));
1497}
1498
1499static void handleNonNullAttrParameter(Sema &S, ParmVarDecl *D,
1500 const AttributeList &Attr) {
1501 if (Attr.getNumArgs() > 0) {
1502 if (D->getFunctionType()) {
1503 handleNonNullAttr(S, D, Attr);
1504 } else {
1505 S.Diag(Attr.getLoc(), diag::warn_attribute_nonnull_parm_no_args)
1506 << D->getSourceRange();
1507 }
1508 return;
1509 }
1510
1511 // Is the argument a pointer type?
1512 if (!attrNonNullArgCheck(S, D->getType(), Attr, SourceRange(),
1513 D->getSourceRange()))
1514 return;
1515
1516 D->addAttr(::new (S.Context)
1517 NonNullAttr(Attr.getRange(), S.Context, nullptr, 0,
1518 Attr.getAttributeSpellingListIndex()));
1519}
1520
1521static void handleReturnsNonNullAttr(Sema &S, Decl *D,
1522 const AttributeList &Attr) {
1523 QualType ResultType = getFunctionOrMethodResultType(D);
1524 SourceRange SR = getFunctionOrMethodResultSourceRange(D);
1525 if (!attrNonNullArgCheck(S, ResultType, Attr, SourceRange(), SR,
1526 /* isReturnValue */ true))
1527 return;
1528
1529 D->addAttr(::new (S.Context)
1530 ReturnsNonNullAttr(Attr.getRange(), S.Context,
1531 Attr.getAttributeSpellingListIndex()));
1532}
1533
1534static void handleNoEscapeAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1535 if (D->isInvalidDecl())
1536 return;
1537
1538 // noescape only applies to pointer types.
1539 QualType T = cast<ParmVarDecl>(D)->getType();
1540 if (!S.isValidPointerAttrType(T, /* RefOkay */ true)) {
1541 S.Diag(Attr.getLoc(), diag::warn_attribute_pointers_only)
1542 << Attr.getName() << Attr.getRange() << 0;
1543 return;
1544 }
1545
1546 D->addAttr(::new (S.Context) NoEscapeAttr(
1547 Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
1548}
1549
1550static void handleAssumeAlignedAttr(Sema &S, Decl *D,
1551 const AttributeList &Attr) {
1552 Expr *E = Attr.getArgAsExpr(0),
1553 *OE = Attr.getNumArgs() > 1 ? Attr.getArgAsExpr(1) : nullptr;
1554 S.AddAssumeAlignedAttr(Attr.getRange(), D, E, OE,
1555 Attr.getAttributeSpellingListIndex());
1556}
1557
1558static void handleAllocAlignAttr(Sema &S, Decl *D,
1559 const AttributeList &Attr) {
1560 S.AddAllocAlignAttr(Attr.getRange(), D, Attr.getArgAsExpr(0),
1561 Attr.getAttributeSpellingListIndex());
1562}
1563
1564void Sema::AddAssumeAlignedAttr(SourceRange AttrRange, Decl *D, Expr *E,
1565 Expr *OE, unsigned SpellingListIndex) {
1566 QualType ResultType = getFunctionOrMethodResultType(D);
1567 SourceRange SR = getFunctionOrMethodResultSourceRange(D);
1568
1569 AssumeAlignedAttr TmpAttr(AttrRange, Context, E, OE, SpellingListIndex);
1570 SourceLocation AttrLoc = AttrRange.getBegin();
1571
1572 if (!isValidPointerAttrType(ResultType, /* RefOkay */ true)) {
1573 Diag(AttrLoc, diag::warn_attribute_return_pointers_refs_only)
1574 << &TmpAttr << AttrRange << SR;
1575 return;
1576 }
1577
1578 if (!E->isValueDependent()) {
1579 llvm::APSInt I(64);
1580 if (!E->isIntegerConstantExpr(I, Context)) {
1581 if (OE)
1582 Diag(AttrLoc, diag::err_attribute_argument_n_type)
1583 << &TmpAttr << 1 << AANT_ArgumentIntegerConstant
1584 << E->getSourceRange();
1585 else
1586 Diag(AttrLoc, diag::err_attribute_argument_type)
1587 << &TmpAttr << AANT_ArgumentIntegerConstant
1588 << E->getSourceRange();
1589 return;
1590 }
1591
1592 if (!I.isPowerOf2()) {
1593 Diag(AttrLoc, diag::err_alignment_not_power_of_two)
1594 << E->getSourceRange();
1595 return;
1596 }
1597 }
1598
1599 if (OE) {
1600 if (!OE->isValueDependent()) {
1601 llvm::APSInt I(64);
1602 if (!OE->isIntegerConstantExpr(I, Context)) {
1603 Diag(AttrLoc, diag::err_attribute_argument_n_type)
1604 << &TmpAttr << 2 << AANT_ArgumentIntegerConstant
1605 << OE->getSourceRange();
1606 return;
1607 }
1608 }
1609 }
1610
1611 D->addAttr(::new (Context)
1612 AssumeAlignedAttr(AttrRange, Context, E, OE, SpellingListIndex));
1613}
1614
1615void Sema::AddAllocAlignAttr(SourceRange AttrRange, Decl *D, Expr *ParamExpr,
1616 unsigned SpellingListIndex) {
1617 QualType ResultType = getFunctionOrMethodResultType(D);
1618
1619 AllocAlignAttr TmpAttr(AttrRange, Context, 0, SpellingListIndex);
1620 SourceLocation AttrLoc = AttrRange.getBegin();
1621
1622 if (!ResultType->isDependentType() &&
1623 !isValidPointerAttrType(ResultType, /* RefOkay */ true)) {
1624 Diag(AttrLoc, diag::warn_attribute_return_pointers_refs_only)
1625 << &TmpAttr << AttrRange << getFunctionOrMethodResultSourceRange(D);
1626 return;
1627 }
1628
1629 uint64_t IndexVal;
1630 const auto *FuncDecl = cast<FunctionDecl>(D);
1631 if (!checkFunctionOrMethodParameterIndex(*this, FuncDecl, TmpAttr,
1632 /*AttrArgNo=*/1, ParamExpr,
1633 IndexVal))
1634 return;
1635
1636 QualType Ty = getFunctionOrMethodParamType(D, IndexVal);
1637 if (!Ty->isDependentType() && !Ty->isIntegralType(Context)) {
1638 Diag(ParamExpr->getLocStart(), diag::err_attribute_integers_only)
1639 << &TmpAttr << FuncDecl->getParamDecl(IndexVal)->getSourceRange();
1640 return;
1641 }
1642
1643 // We cannot use the Idx returned from checkFunctionOrMethodParameterIndex
1644 // because that has corrected for the implicit this parameter, and is zero-
1645 // based. The attribute expects what the user wrote explicitly.
1646 llvm::APSInt Val;
1647 ParamExpr->EvaluateAsInt(Val, Context);
1648
1649 D->addAttr(::new (Context) AllocAlignAttr(
1650 AttrRange, Context, Val.getZExtValue(), SpellingListIndex));
1651}
1652
1653/// Normalize the attribute, __foo__ becomes foo.
1654/// Returns true if normalization was applied.
1655static bool normalizeName(StringRef &AttrName) {
1656 if (AttrName.size() > 4 && AttrName.startswith("__") &&
1657 AttrName.endswith("__")) {
1658 AttrName = AttrName.drop_front(2).drop_back(2);
1659 return true;
1660 }
1661 return false;
1662}
1663
1664static void handleOwnershipAttr(Sema &S, Decl *D, const AttributeList &AL) {
1665 // This attribute must be applied to a function declaration. The first
1666 // argument to the attribute must be an identifier, the name of the resource,
1667 // for example: malloc. The following arguments must be argument indexes, the
1668 // arguments must be of integer type for Returns, otherwise of pointer type.
1669 // The difference between Holds and Takes is that a pointer may still be used
1670 // after being held. free() should be __attribute((ownership_takes)), whereas
1671 // a list append function may well be __attribute((ownership_holds)).
1672
1673 if (!AL.isArgIdent(0)) {
1674 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
1675 << AL.getName() << 1 << AANT_ArgumentIdentifier;
1676 return;
1677 }
1678
1679 // Figure out our Kind.
1680 OwnershipAttr::OwnershipKind K =
1681 OwnershipAttr(AL.getLoc(), S.Context, nullptr, nullptr, 0,
1682 AL.getAttributeSpellingListIndex()).getOwnKind();
1683
1684 // Check arguments.
1685 switch (K) {
1686 case OwnershipAttr::Takes:
1687 case OwnershipAttr::Holds:
1688 if (AL.getNumArgs() < 2) {
1689 S.Diag(AL.getLoc(), diag::err_attribute_too_few_arguments)
1690 << AL.getName() << 2;
1691 return;
1692 }
1693 break;
1694 case OwnershipAttr::Returns:
1695 if (AL.getNumArgs() > 2) {
1696 S.Diag(AL.getLoc(), diag::err_attribute_too_many_arguments)
1697 << AL.getName() << 1;
1698 return;
1699 }
1700 break;
1701 }
1702
1703 IdentifierInfo *Module = AL.getArgAsIdent(0)->Ident;
1704
1705 StringRef ModuleName = Module->getName();
1706 if (normalizeName(ModuleName)) {
1707 Module = &S.PP.getIdentifierTable().get(ModuleName);
1708 }
1709
1710 SmallVector<unsigned, 8> OwnershipArgs;
1711 for (unsigned i = 1; i < AL.getNumArgs(); ++i) {
1712 Expr *Ex = AL.getArgAsExpr(i);
1713 uint64_t Idx;
1714 if (!checkFunctionOrMethodParameterIndex(S, D, AL, i, Ex, Idx))
1715 return;
1716
1717 // Is the function argument a pointer type?
1718 QualType T = getFunctionOrMethodParamType(D, Idx);
1719 int Err = -1; // No error
1720 switch (K) {
1721 case OwnershipAttr::Takes:
1722 case OwnershipAttr::Holds:
1723 if (!T->isAnyPointerType() && !T->isBlockPointerType())
1724 Err = 0;
1725 break;
1726 case OwnershipAttr::Returns:
1727 if (!T->isIntegerType())
1728 Err = 1;
1729 break;
1730 }
1731 if (-1 != Err) {
1732 S.Diag(AL.getLoc(), diag::err_ownership_type) << AL.getName() << Err
1733 << Ex->getSourceRange();
1734 return;
1735 }
1736
1737 // Check we don't have a conflict with another ownership attribute.
1738 for (const auto *I : D->specific_attrs<OwnershipAttr>()) {
1739 // Cannot have two ownership attributes of different kinds for the same
1740 // index.
1741 if (I->getOwnKind() != K && I->args_end() !=
1742 std::find(I->args_begin(), I->args_end(), Idx)) {
1743 S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible)
1744 << AL.getName() << I;
1745 return;
1746 } else if (K == OwnershipAttr::Returns &&
1747 I->getOwnKind() == OwnershipAttr::Returns) {
1748 // A returns attribute conflicts with any other returns attribute using
1749 // a different index. Note, diagnostic reporting is 1-based, but stored
1750 // argument indexes are 0-based.
1751 if (std::find(I->args_begin(), I->args_end(), Idx) == I->args_end()) {
1752 S.Diag(I->getLocation(), diag::err_ownership_returns_index_mismatch)
1753 << *(I->args_begin()) + 1;
1754 if (I->args_size())
1755 S.Diag(AL.getLoc(), diag::note_ownership_returns_index_mismatch)
1756 << (unsigned)Idx + 1 << Ex->getSourceRange();
1757 return;
1758 }
1759 }
1760 }
1761 OwnershipArgs.push_back(Idx);
1762 }
1763
1764 unsigned* start = OwnershipArgs.data();
1765 unsigned size = OwnershipArgs.size();
1766 llvm::array_pod_sort(start, start + size);
1767
1768 D->addAttr(::new (S.Context)
1769 OwnershipAttr(AL.getLoc(), S.Context, Module, start, size,
1770 AL.getAttributeSpellingListIndex()));
1771}
1772
1773static void handleWeakRefAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1774 // Check the attribute arguments.
1775 if (Attr.getNumArgs() > 1) {
1776 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments)
1777 << Attr.getName() << 1;
1778 return;
1779 }
1780
1781 NamedDecl *nd = cast<NamedDecl>(D);
1782
1783 // gcc rejects
1784 // class c {
1785 // static int a __attribute__((weakref ("v2")));
1786 // static int b() __attribute__((weakref ("f3")));
1787 // };
1788 // and ignores the attributes of
1789 // void f(void) {
1790 // static int a __attribute__((weakref ("v2")));
1791 // }
1792 // we reject them
1793 const DeclContext *Ctx = D->getDeclContext()->getRedeclContext();
1794 if (!Ctx->isFileContext()) {
1795 S.Diag(Attr.getLoc(), diag::err_attribute_weakref_not_global_context)
1796 << nd;
1797 return;
1798 }
1799
1800 // The GCC manual says
1801 //
1802 // At present, a declaration to which `weakref' is attached can only
1803 // be `static'.
1804 //
1805 // It also says
1806 //
1807 // Without a TARGET,
1808 // given as an argument to `weakref' or to `alias', `weakref' is
1809 // equivalent to `weak'.
1810 //
1811 // gcc 4.4.1 will accept
1812 // int a7 __attribute__((weakref));
1813 // as
1814 // int a7 __attribute__((weak));
1815 // This looks like a bug in gcc. We reject that for now. We should revisit
1816 // it if this behaviour is actually used.
1817
1818 // GCC rejects
1819 // static ((alias ("y"), weakref)).
1820 // Should we? How to check that weakref is before or after alias?
1821
1822 // FIXME: it would be good for us to keep the WeakRefAttr as-written instead
1823 // of transforming it into an AliasAttr. The WeakRefAttr never uses the
1824 // StringRef parameter it was given anyway.
1825 StringRef Str;
1826 if (Attr.getNumArgs() && S.checkStringLiteralArgumentAttr(Attr, 0, Str))
1827 // GCC will accept anything as the argument of weakref. Should we
1828 // check for an existing decl?
1829 D->addAttr(::new (S.Context) AliasAttr(Attr.getRange(), S.Context, Str,
1830 Attr.getAttributeSpellingListIndex()));
1831
1832 D->addAttr(::new (S.Context)
1833 WeakRefAttr(Attr.getRange(), S.Context,
1834 Attr.getAttributeSpellingListIndex()));
1835}
1836
1837static void handleIFuncAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1838 StringRef Str;
1839 if (!S.checkStringLiteralArgumentAttr(Attr, 0, Str))
1840 return;
1841
1842 // Aliases should be on declarations, not definitions.
1843 const auto *FD = cast<FunctionDecl>(D);
1844 if (FD->isThisDeclarationADefinition()) {
1845 S.Diag(Attr.getLoc(), diag::err_alias_is_definition) << FD << 1;
1846 return;
1847 }
1848 // FIXME: it should be handled as a target specific attribute.
1849 if (S.Context.getTargetInfo().getTriple().getObjectFormat() !=
1850 llvm::Triple::ELF) {
1851 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
1852 return;
1853 }
1854
1855 D->addAttr(::new (S.Context) IFuncAttr(Attr.getRange(), S.Context, Str,
1856 Attr.getAttributeSpellingListIndex()));
1857}
1858
1859static void handleAliasAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1860 StringRef Str;
1861 if (!S.checkStringLiteralArgumentAttr(Attr, 0, Str))
1862 return;
1863
1864 if (S.Context.getTargetInfo().getTriple().isOSDarwin()) {
1865 S.Diag(Attr.getLoc(), diag::err_alias_not_supported_on_darwin);
1866 return;
1867 }
1868 if (S.Context.getTargetInfo().getTriple().isNVPTX()) {
1869 S.Diag(Attr.getLoc(), diag::err_alias_not_supported_on_nvptx);
1870 }
1871
1872 // Aliases should be on declarations, not definitions.
1873 if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
1874 if (FD->isThisDeclarationADefinition()) {
1875 S.Diag(Attr.getLoc(), diag::err_alias_is_definition) << FD << 0;
1876 return;
1877 }
1878 } else {
1879 const auto *VD = cast<VarDecl>(D);
1880 if (VD->isThisDeclarationADefinition() && VD->isExternallyVisible()) {
1881 S.Diag(Attr.getLoc(), diag::err_alias_is_definition) << VD << 0;
1882 return;
1883 }
1884 }
1885
1886 // FIXME: check if target symbol exists in current file
1887
1888 D->addAttr(::new (S.Context) AliasAttr(Attr.getRange(), S.Context, Str,
1889 Attr.getAttributeSpellingListIndex()));
1890}
1891
1892static void handleColdAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1893 if (checkAttrMutualExclusion<HotAttr>(S, D, Attr.getRange(), Attr.getName()))
1894 return;
1895
1896 D->addAttr(::new (S.Context) ColdAttr(Attr.getRange(), S.Context,
1897 Attr.getAttributeSpellingListIndex()));
1898}
1899
1900static void handleHotAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1901 if (checkAttrMutualExclusion<ColdAttr>(S, D, Attr.getRange(), Attr.getName()))
1902 return;
1903
1904 D->addAttr(::new (S.Context) HotAttr(Attr.getRange(), S.Context,
1905 Attr.getAttributeSpellingListIndex()));
1906}
1907
1908static void handleTLSModelAttr(Sema &S, Decl *D,
1909 const AttributeList &Attr) {
1910 StringRef Model;
1911 SourceLocation LiteralLoc;
1912 // Check that it is a string.
1913 if (!S.checkStringLiteralArgumentAttr(Attr, 0, Model, &LiteralLoc))
1914 return;
1915
1916 // Check that the value.
1917 if (Model != "global-dynamic" && Model != "local-dynamic"
1918 && Model != "initial-exec" && Model != "local-exec") {
1919 S.Diag(LiteralLoc, diag::err_attr_tlsmodel_arg);
1920 return;
1921 }
1922
1923 D->addAttr(::new (S.Context)
1924 TLSModelAttr(Attr.getRange(), S.Context, Model,
1925 Attr.getAttributeSpellingListIndex()));
1926}
1927
1928static void handleRestrictAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1929 QualType ResultType = getFunctionOrMethodResultType(D);
1930 if (ResultType->isAnyPointerType() || ResultType->isBlockPointerType()) {
1931 D->addAttr(::new (S.Context) RestrictAttr(
1932 Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
1933 return;
1934 }
1935
1936 S.Diag(Attr.getLoc(), diag::warn_attribute_return_pointers_only)
1937 << Attr.getName() << getFunctionOrMethodResultSourceRange(D);
1938}
1939
1940static void handleCommonAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1941 if (S.LangOpts.CPlusPlus) {
1942 S.Diag(Attr.getLoc(), diag::err_attribute_not_supported_in_lang)
1943 << Attr.getName() << AttributeLangSupport::Cpp;
1944 return;
1945 }
1946
1947 if (CommonAttr *CA = S.mergeCommonAttr(D, Attr.getRange(), Attr.getName(),
1948 Attr.getAttributeSpellingListIndex()))
1949 D->addAttr(CA);
1950}
1951
1952static void handleNakedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
1953 if (checkAttrMutualExclusion<DisableTailCallsAttr>(S, D, Attr.getRange(),
1954 Attr.getName()))
1955 return;
1956
1957 if (Attr.isDeclspecAttribute()) {
1958 const auto &Triple = S.getASTContext().getTargetInfo().getTriple();
1959 const auto &Arch = Triple.getArch();
1960 if (Arch != llvm::Triple::x86 &&
1961 (Arch != llvm::Triple::arm && Arch != llvm::Triple::thumb)) {
1962 S.Diag(Attr.getLoc(), diag::err_attribute_not_supported_on_arch)
1963 << Attr.getName() << Triple.getArchName();
1964 return;
1965 }
1966 }
1967
1968 D->addAttr(::new (S.Context) NakedAttr(Attr.getRange(), S.Context,
1969 Attr.getAttributeSpellingListIndex()));
1970}
1971
1972static void handleNoReturnAttr(Sema &S, Decl *D, const AttributeList &Attrs) {
1973 if (hasDeclarator(D)) return;
1974
1975 if (S.CheckNoReturnAttr(Attrs))
1976 return;
1977
1978 if (!isa<ObjCMethodDecl>(D)) {
1979 S.Diag(Attrs.getLoc(), diag::warn_attribute_wrong_decl_type)
1980 << Attrs.getName() << ExpectedFunctionOrMethod;
1981 return;
1982 }
1983
1984 D->addAttr(::new (S.Context) NoReturnAttr(
1985 Attrs.getRange(), S.Context, Attrs.getAttributeSpellingListIndex()));
1986}
1987
1988static void handleNoCallerSavedRegsAttr(Sema &S, Decl *D,
1989 const AttributeList &Attr) {
1990 if (S.CheckNoCallerSavedRegsAttr(Attr))
1991 return;
1992
1993 D->addAttr(::new (S.Context) AnyX86NoCallerSavedRegistersAttr(
1994 Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
1995}
1996
1997bool Sema::CheckNoReturnAttr(const AttributeList &Attrs) {
1998 if (!checkAttributeNumArgs(*this, Attrs, 0)) {
1999 Attrs.setInvalid();
2000 return true;
2001 }
2002
2003 return false;
2004}
2005
2006bool Sema::CheckNoCallerSavedRegsAttr(const AttributeList &Attr) {
2007 // Check whether the attribute is valid on the current target.
2008 if (!Attr.existsInTarget(Context.getTargetInfo())) {
2009 Diag(Attr.getLoc(), diag::warn_unknown_attribute_ignored) << Attr.getName();
2010 Attr.setInvalid();
2011 return true;
2012 }
2013
2014 if (!checkAttributeNumArgs(*this, Attr, 0)) {
2015 Attr.setInvalid();
2016 return true;
2017 }
2018
2019 return false;
2020}
2021
2022static void handleAnalyzerNoReturnAttr(Sema &S, Decl *D,
2023 const AttributeList &Attr) {
2024
2025 // The checking path for 'noreturn' and 'analyzer_noreturn' are different
2026 // because 'analyzer_noreturn' does not impact the type.
2027 if (!isFunctionOrMethodOrBlock(D)) {
2028 ValueDecl *VD = dyn_cast<ValueDecl>(D);
2029 if (!VD || (!VD->getType()->isBlockPointerType() &&
2030 !VD->getType()->isFunctionPointerType())) {
2031 S.Diag(Attr.getLoc(),
2032 Attr.isCXX11Attribute() ? diag::err_attribute_wrong_decl_type
2033 : diag::warn_attribute_wrong_decl_type)
2034 << Attr.getName() << ExpectedFunctionMethodOrBlock;
2035 return;
2036 }
2037 }
2038
2039 D->addAttr(::new (S.Context)
2040 AnalyzerNoReturnAttr(Attr.getRange(), S.Context,
2041 Attr.getAttributeSpellingListIndex()));
2042}
2043
2044// PS3 PPU-specific.
2045static void handleVecReturnAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2046/*
2047 Returning a Vector Class in Registers
2048
2049 According to the PPU ABI specifications, a class with a single member of
2050 vector type is returned in memory when used as the return value of a function.
2051 This results in inefficient code when implementing vector classes. To return
2052 the value in a single vector register, add the vecreturn attribute to the
2053 class definition. This attribute is also applicable to struct types.
2054
2055 Example:
2056
2057 struct Vector
2058 {
2059 __vector float xyzw;
2060 } __attribute__((vecreturn));
2061
2062 Vector Add(Vector lhs, Vector rhs)
2063 {
2064 Vector result;
2065 result.xyzw = vec_add(lhs.xyzw, rhs.xyzw);
2066 return result; // This will be returned in a register
2067 }
2068*/
2069 if (VecReturnAttr *A = D->getAttr<VecReturnAttr>()) {
2070 S.Diag(Attr.getLoc(), diag::err_repeat_attribute) << A;
2071 return;
2072 }
2073
2074 RecordDecl *record = cast<RecordDecl>(D);
2075 int count = 0;
2076
2077 if (!isa<CXXRecordDecl>(record)) {
2078 S.Diag(Attr.getLoc(), diag::err_attribute_vecreturn_only_vector_member);
2079 return;
2080 }
2081
2082 if (!cast<CXXRecordDecl>(record)->isPOD()) {
2083 S.Diag(Attr.getLoc(), diag::err_attribute_vecreturn_only_pod_record);
2084 return;
2085 }
2086
2087 for (const auto *I : record->fields()) {
2088 if ((count == 1) || !I->getType()->isVectorType()) {
2089 S.Diag(Attr.getLoc(), diag::err_attribute_vecreturn_only_vector_member);
2090 return;
2091 }
2092 count++;
2093 }
2094
2095 D->addAttr(::new (S.Context)
2096 VecReturnAttr(Attr.getRange(), S.Context,
2097 Attr.getAttributeSpellingListIndex()));
2098}
2099
2100static void handleDependencyAttr(Sema &S, Scope *Scope, Decl *D,
2101 const AttributeList &Attr) {
2102 if (isa<ParmVarDecl>(D)) {
2103 // [[carries_dependency]] can only be applied to a parameter if it is a
2104 // parameter of a function declaration or lambda.
2105 if (!(Scope->getFlags() & clang::Scope::FunctionDeclarationScope)) {
2106 S.Diag(Attr.getLoc(),
2107 diag::err_carries_dependency_param_not_function_decl);
2108 return;
2109 }
2110 }
2111
2112 D->addAttr(::new (S.Context) CarriesDependencyAttr(
2113 Attr.getRange(), S.Context,
2114 Attr.getAttributeSpellingListIndex()));
2115}
2116
2117static void handleNotTailCalledAttr(Sema &S, Decl *D,
2118 const AttributeList &Attr) {
2119 if (checkAttrMutualExclusion<AlwaysInlineAttr>(S, D, Attr.getRange(),
2120 Attr.getName()))
2121 return;
2122
2123 D->addAttr(::new (S.Context) NotTailCalledAttr(
2124 Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
2125}
2126
2127static void handleDisableTailCallsAttr(Sema &S, Decl *D,
2128 const AttributeList &Attr) {
2129 if (checkAttrMutualExclusion<NakedAttr>(S, D, Attr.getRange(),
2130 Attr.getName()))
2131 return;
2132
2133 D->addAttr(::new (S.Context) DisableTailCallsAttr(
2134 Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
2135}
2136
2137static void handleUsedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2138 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
2139 if (VD->hasLocalStorage()) {
2140 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
2141 return;
2142 }
2143 } else if (!isFunctionOrMethod(D)) {
2144 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2145 << Attr.getName() << ExpectedVariableOrFunction;
2146 return;
2147 }
2148
2149 D->addAttr(::new (S.Context)
2150 UsedAttr(Attr.getRange(), S.Context,
2151 Attr.getAttributeSpellingListIndex()));
2152}
2153
2154static void handleUnusedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2155 bool IsCXX1zAttr = Attr.isCXX11Attribute() && !Attr.getScopeName();
2156
2157 if (IsCXX1zAttr && isa<VarDecl>(D)) {
2158 // The C++1z spelling of this attribute cannot be applied to a static data
2159 // member per [dcl.attr.unused]p2.
2160 if (cast<VarDecl>(D)->isStaticDataMember()) {
2161 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2162 << Attr.getName() << ExpectedForMaybeUnused;
2163 return;
2164 }
2165 }
2166
2167 // If this is spelled as the standard C++1z attribute, but not in C++1z, warn
2168 // about using it as an extension.
2169 if (!S.getLangOpts().CPlusPlus1z && IsCXX1zAttr)
2170 S.Diag(Attr.getLoc(), diag::ext_cxx17_attr) << Attr.getName();
2171
2172 D->addAttr(::new (S.Context) UnusedAttr(
2173 Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
2174}
2175
2176static void handleConstructorAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2177 uint32_t priority = ConstructorAttr::DefaultPriority;
2178 if (Attr.getNumArgs() &&
2179 !checkUInt32Argument(S, Attr, Attr.getArgAsExpr(0), priority))
2180 return;
2181
2182 D->addAttr(::new (S.Context)
2183 ConstructorAttr(Attr.getRange(), S.Context, priority,
2184 Attr.getAttributeSpellingListIndex()));
2185}
2186
2187static void handleDestructorAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2188 uint32_t priority = DestructorAttr::DefaultPriority;
2189 if (Attr.getNumArgs() &&
2190 !checkUInt32Argument(S, Attr, Attr.getArgAsExpr(0), priority))
2191 return;
2192
2193 D->addAttr(::new (S.Context)
2194 DestructorAttr(Attr.getRange(), S.Context, priority,
2195 Attr.getAttributeSpellingListIndex()));
2196}
2197
2198template <typename AttrTy>
2199static void handleAttrWithMessage(Sema &S, Decl *D,
2200 const AttributeList &Attr) {
2201 // Handle the case where the attribute has a text message.
2202 StringRef Str;
2203 if (Attr.getNumArgs() == 1 && !S.checkStringLiteralArgumentAttr(Attr, 0, Str))
2204 return;
2205
2206 D->addAttr(::new (S.Context) AttrTy(Attr.getRange(), S.Context, Str,
2207 Attr.getAttributeSpellingListIndex()));
2208}
2209
2210static void handleObjCSuppresProtocolAttr(Sema &S, Decl *D,
2211 const AttributeList &Attr) {
2212 if (!cast<ObjCProtocolDecl>(D)->isThisDeclarationADefinition()) {
2213 S.Diag(Attr.getLoc(), diag::err_objc_attr_protocol_requires_definition)
2214 << Attr.getName() << Attr.getRange();
2215 return;
2216 }
2217
2218 D->addAttr(::new (S.Context)
2219 ObjCExplicitProtocolImplAttr(Attr.getRange(), S.Context,
2220 Attr.getAttributeSpellingListIndex()));
2221}
2222
2223static bool checkAvailabilityAttr(Sema &S, SourceRange Range,
2224 IdentifierInfo *Platform,
2225 VersionTuple Introduced,
2226 VersionTuple Deprecated,
2227 VersionTuple Obsoleted) {
2228 StringRef PlatformName
2229 = AvailabilityAttr::getPrettyPlatformName(Platform->getName());
2230 if (PlatformName.empty())
2231 PlatformName = Platform->getName();
2232
2233 // Ensure that Introduced <= Deprecated <= Obsoleted (although not all
2234 // of these steps are needed).
2235 if (!Introduced.empty() && !Deprecated.empty() &&
2236 !(Introduced <= Deprecated)) {
2237 S.Diag(Range.getBegin(), diag::warn_availability_version_ordering)
2238 << 1 << PlatformName << Deprecated.getAsString()
2239 << 0 << Introduced.getAsString();
2240 return true;
2241 }
2242
2243 if (!Introduced.empty() && !Obsoleted.empty() &&
2244 !(Introduced <= Obsoleted)) {
2245 S.Diag(Range.getBegin(), diag::warn_availability_version_ordering)
2246 << 2 << PlatformName << Obsoleted.getAsString()
2247 << 0 << Introduced.getAsString();
2248 return true;
2249 }
2250
2251 if (!Deprecated.empty() && !Obsoleted.empty() &&
2252 !(Deprecated <= Obsoleted)) {
2253 S.Diag(Range.getBegin(), diag::warn_availability_version_ordering)
2254 << 2 << PlatformName << Obsoleted.getAsString()
2255 << 1 << Deprecated.getAsString();
2256 return true;
2257 }
2258
2259 return false;
2260}
2261
2262/// \brief Check whether the two versions match.
2263///
2264/// If either version tuple is empty, then they are assumed to match. If
2265/// \p BeforeIsOkay is true, then \p X can be less than or equal to \p Y.
2266static bool versionsMatch(const VersionTuple &X, const VersionTuple &Y,
2267 bool BeforeIsOkay) {
2268 if (X.empty() || Y.empty())
2269 return true;
2270
2271 if (X == Y)
2272 return true;
2273
2274 if (BeforeIsOkay && X < Y)
2275 return true;
2276
2277 return false;
2278}
2279
2280AvailabilityAttr *Sema::mergeAvailabilityAttr(NamedDecl *D, SourceRange Range,
2281 IdentifierInfo *Platform,
2282 bool Implicit,
2283 VersionTuple Introduced,
2284 VersionTuple Deprecated,
2285 VersionTuple Obsoleted,
2286 bool IsUnavailable,
2287 StringRef Message,
2288 bool IsStrict,
2289 StringRef Replacement,
2290 AvailabilityMergeKind AMK,
2291 unsigned AttrSpellingListIndex) {
2292 VersionTuple MergedIntroduced = Introduced;
2293 VersionTuple MergedDeprecated = Deprecated;
2294 VersionTuple MergedObsoleted = Obsoleted;
2295 bool FoundAny = false;
2296 bool OverrideOrImpl = false;
2297 switch (AMK) {
2298 case AMK_None:
2299 case AMK_Redeclaration:
2300 OverrideOrImpl = false;
2301 break;
2302
2303 case AMK_Override:
2304 case AMK_ProtocolImplementation:
2305 OverrideOrImpl = true;
2306 break;
2307 }
2308
2309 if (D->hasAttrs()) {
2310 AttrVec &Attrs = D->getAttrs();
2311 for (unsigned i = 0, e = Attrs.size(); i != e;) {
2312 const AvailabilityAttr *OldAA = dyn_cast<AvailabilityAttr>(Attrs[i]);
2313 if (!OldAA) {
2314 ++i;
2315 continue;
2316 }
2317
2318 IdentifierInfo *OldPlatform = OldAA->getPlatform();
2319 if (OldPlatform != Platform) {
2320 ++i;
2321 continue;
2322 }
2323
2324 // If there is an existing availability attribute for this platform that
2325 // is explicit and the new one is implicit use the explicit one and
2326 // discard the new implicit attribute.
2327 if (!OldAA->isImplicit() && Implicit) {
2328 return nullptr;
2329 }
2330
2331 // If there is an existing attribute for this platform that is implicit
2332 // and the new attribute is explicit then erase the old one and
2333 // continue processing the attributes.
2334 if (!Implicit && OldAA->isImplicit()) {
2335 Attrs.erase(Attrs.begin() + i);
2336 --e;
2337 continue;
2338 }
2339
2340 FoundAny = true;
2341 VersionTuple OldIntroduced = OldAA->getIntroduced();
2342 VersionTuple OldDeprecated = OldAA->getDeprecated();
2343 VersionTuple OldObsoleted = OldAA->getObsoleted();
2344 bool OldIsUnavailable = OldAA->getUnavailable();
2345
2346 if (!versionsMatch(OldIntroduced, Introduced, OverrideOrImpl) ||
2347 !versionsMatch(Deprecated, OldDeprecated, OverrideOrImpl) ||
2348 !versionsMatch(Obsoleted, OldObsoleted, OverrideOrImpl) ||
2349 !(OldIsUnavailable == IsUnavailable ||
2350 (OverrideOrImpl && !OldIsUnavailable && IsUnavailable))) {
2351 if (OverrideOrImpl) {
2352 int Which = -1;
2353 VersionTuple FirstVersion;
2354 VersionTuple SecondVersion;
2355 if (!versionsMatch(OldIntroduced, Introduced, OverrideOrImpl)) {
2356 Which = 0;
2357 FirstVersion = OldIntroduced;
2358 SecondVersion = Introduced;
2359 } else if (!versionsMatch(Deprecated, OldDeprecated, OverrideOrImpl)) {
2360 Which = 1;
2361 FirstVersion = Deprecated;
2362 SecondVersion = OldDeprecated;
2363 } else if (!versionsMatch(Obsoleted, OldObsoleted, OverrideOrImpl)) {
2364 Which = 2;
2365 FirstVersion = Obsoleted;
2366 SecondVersion = OldObsoleted;
2367 }
2368
2369 if (Which == -1) {
2370 Diag(OldAA->getLocation(),
2371 diag::warn_mismatched_availability_override_unavail)
2372 << AvailabilityAttr::getPrettyPlatformName(Platform->getName())
2373 << (AMK == AMK_Override);
2374 } else {
2375 Diag(OldAA->getLocation(),
2376 diag::warn_mismatched_availability_override)
2377 << Which
2378 << AvailabilityAttr::getPrettyPlatformName(Platform->getName())
2379 << FirstVersion.getAsString() << SecondVersion.getAsString()
2380 << (AMK == AMK_Override);
2381 }
2382 if (AMK == AMK_Override)
2383 Diag(Range.getBegin(), diag::note_overridden_method);
2384 else
2385 Diag(Range.getBegin(), diag::note_protocol_method);
2386 } else {
2387 Diag(OldAA->getLocation(), diag::warn_mismatched_availability);
2388 Diag(Range.getBegin(), diag::note_previous_attribute);
2389 }
2390
2391 Attrs.erase(Attrs.begin() + i);
2392 --e;
2393 continue;
2394 }
2395
2396 VersionTuple MergedIntroduced2 = MergedIntroduced;
2397 VersionTuple MergedDeprecated2 = MergedDeprecated;
2398 VersionTuple MergedObsoleted2 = MergedObsoleted;
2399
2400 if (MergedIntroduced2.empty())
2401 MergedIntroduced2 = OldIntroduced;
2402 if (MergedDeprecated2.empty())
2403 MergedDeprecated2 = OldDeprecated;
2404 if (MergedObsoleted2.empty())
2405 MergedObsoleted2 = OldObsoleted;
2406
2407 if (checkAvailabilityAttr(*this, OldAA->getRange(), Platform,
2408 MergedIntroduced2, MergedDeprecated2,
2409 MergedObsoleted2)) {
2410 Attrs.erase(Attrs.begin() + i);
2411 --e;
2412 continue;
2413 }
2414
2415 MergedIntroduced = MergedIntroduced2;
2416 MergedDeprecated = MergedDeprecated2;
2417 MergedObsoleted = MergedObsoleted2;
2418 ++i;
2419 }
2420 }
2421
2422 if (FoundAny &&
2423 MergedIntroduced == Introduced &&
2424 MergedDeprecated == Deprecated &&
2425 MergedObsoleted == Obsoleted)
2426 return nullptr;
2427
2428 // Only create a new attribute if !OverrideOrImpl, but we want to do
2429 // the checking.
2430 if (!checkAvailabilityAttr(*this, Range, Platform, MergedIntroduced,
2431 MergedDeprecated, MergedObsoleted) &&
2432 !OverrideOrImpl) {
2433 auto *Avail = ::new (Context) AvailabilityAttr(Range, Context, Platform,
2434 Introduced, Deprecated,
2435 Obsoleted, IsUnavailable, Message,
2436 IsStrict, Replacement,
2437 AttrSpellingListIndex);
2438 Avail->setImplicit(Implicit);
2439 return Avail;
2440 }
2441 return nullptr;
2442}
2443
2444static void handleAvailabilityAttr(Sema &S, Decl *D,
2445 const AttributeList &Attr) {
2446 if (!checkAttributeNumArgs(S, Attr, 1))
2447 return;
2448 IdentifierLoc *Platform = Attr.getArgAsIdent(0);
2449 unsigned Index = Attr.getAttributeSpellingListIndex();
2450
2451 IdentifierInfo *II = Platform->Ident;
2452 if (AvailabilityAttr::getPrettyPlatformName(II->getName()).empty())
2453 S.Diag(Platform->Loc, diag::warn_availability_unknown_platform)
2454 << Platform->Ident;
2455
2456 NamedDecl *ND = dyn_cast<NamedDecl>(D);
2457 if (!ND) // We warned about this already, so just return.
2458 return;
2459
2460 AvailabilityChange Introduced = Attr.getAvailabilityIntroduced();
2461 AvailabilityChange Deprecated = Attr.getAvailabilityDeprecated();
2462 AvailabilityChange Obsoleted = Attr.getAvailabilityObsoleted();
2463 bool IsUnavailable = Attr.getUnavailableLoc().isValid();
2464 bool IsStrict = Attr.getStrictLoc().isValid();
2465 StringRef Str;
2466 if (const StringLiteral *SE =
2467 dyn_cast_or_null<StringLiteral>(Attr.getMessageExpr()))
2468 Str = SE->getString();
2469 StringRef Replacement;
2470 if (const StringLiteral *SE =
2471 dyn_cast_or_null<StringLiteral>(Attr.getReplacementExpr()))
2472 Replacement = SE->getString();
2473
2474 AvailabilityAttr *NewAttr = S.mergeAvailabilityAttr(ND, Attr.getRange(), II,
2475 false/*Implicit*/,
2476 Introduced.Version,
2477 Deprecated.Version,
2478 Obsoleted.Version,
2479 IsUnavailable, Str,
2480 IsStrict, Replacement,
2481 Sema::AMK_None,
2482 Index);
2483 if (NewAttr)
2484 D->addAttr(NewAttr);
2485
2486 // Transcribe "ios" to "watchos" (and add a new attribute) if the versioning
2487 // matches before the start of the watchOS platform.
2488 if (S.Context.getTargetInfo().getTriple().isWatchOS()) {
2489 IdentifierInfo *NewII = nullptr;
2490 if (II->getName() == "ios")
2491 NewII = &S.Context.Idents.get("watchos");
2492 else if (II->getName() == "ios_app_extension")
2493 NewII = &S.Context.Idents.get("watchos_app_extension");
2494
2495 if (NewII) {
2496 auto adjustWatchOSVersion = [](VersionTuple Version) -> VersionTuple {
2497 if (Version.empty())
2498 return Version;
2499 auto Major = Version.getMajor();
2500 auto NewMajor = Major >= 9 ? Major - 7 : 0;
2501 if (NewMajor >= 2) {
2502 if (Version.getMinor().hasValue()) {
2503 if (Version.getSubminor().hasValue())
2504 return VersionTuple(NewMajor, Version.getMinor().getValue(),
2505 Version.getSubminor().getValue());
2506 else
2507 return VersionTuple(NewMajor, Version.getMinor().getValue());
2508 }
2509 }
2510
2511 return VersionTuple(2, 0);
2512 };
2513
2514 auto NewIntroduced = adjustWatchOSVersion(Introduced.Version);
2515 auto NewDeprecated = adjustWatchOSVersion(Deprecated.Version);
2516 auto NewObsoleted = adjustWatchOSVersion(Obsoleted.Version);
2517
2518 AvailabilityAttr *NewAttr = S.mergeAvailabilityAttr(ND,
2519 Attr.getRange(),
2520 NewII,
2521 true/*Implicit*/,
2522 NewIntroduced,
2523 NewDeprecated,
2524 NewObsoleted,
2525 IsUnavailable, Str,
2526 IsStrict,
2527 Replacement,
2528 Sema::AMK_None,
2529 Index);
2530 if (NewAttr)
2531 D->addAttr(NewAttr);
2532 }
2533 } else if (S.Context.getTargetInfo().getTriple().isTvOS()) {
2534 // Transcribe "ios" to "tvos" (and add a new attribute) if the versioning
2535 // matches before the start of the tvOS platform.
2536 IdentifierInfo *NewII = nullptr;
2537 if (II->getName() == "ios")
2538 NewII = &S.Context.Idents.get("tvos");
2539 else if (II->getName() == "ios_app_extension")
2540 NewII = &S.Context.Idents.get("tvos_app_extension");
2541
2542 if (NewII) {
2543 AvailabilityAttr *NewAttr = S.mergeAvailabilityAttr(ND,
2544 Attr.getRange(),
2545 NewII,
2546 true/*Implicit*/,
2547 Introduced.Version,
2548 Deprecated.Version,
2549 Obsoleted.Version,
2550 IsUnavailable, Str,
2551 IsStrict,
2552 Replacement,
2553 Sema::AMK_None,
2554 Index);
2555 if (NewAttr)
2556 D->addAttr(NewAttr);
2557 }
2558 }
2559}
2560
2561static void handleExternalSourceSymbolAttr(Sema &S, Decl *D,
2562 const AttributeList &Attr) {
2563 if (!checkAttributeAtLeastNumArgs(S, Attr, 1))
2564 return;
2565 assert(checkAttributeAtMostNumArgs(S, Attr, 3) &&(static_cast <bool> (checkAttributeAtMostNumArgs(S, Attr
, 3) && "Invalid number of arguments in an external_source_symbol attribute"
) ? void (0) : __assert_fail ("checkAttributeAtMostNumArgs(S, Attr, 3) && \"Invalid number of arguments in an external_source_symbol attribute\""
, "/build/llvm-toolchain-snapshot-6.0~svn318882/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 2566, __extension__ __PRETTY_FUNCTION__))
2566 "Invalid number of arguments in an external_source_symbol attribute")(static_cast <bool> (checkAttributeAtMostNumArgs(S, Attr
, 3) && "Invalid number of arguments in an external_source_symbol attribute"
) ? void (0) : __assert_fail ("checkAttributeAtMostNumArgs(S, Attr, 3) && \"Invalid number of arguments in an external_source_symbol attribute\""
, "/build/llvm-toolchain-snapshot-6.0~svn318882/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 2566, __extension__ __PRETTY_FUNCTION__))
;
2567
2568 StringRef Language;
2569 if (const auto *SE = dyn_cast_or_null<StringLiteral>(Attr.getArgAsExpr(0)))
2570 Language = SE->getString();
2571 StringRef DefinedIn;
2572 if (const auto *SE = dyn_cast_or_null<StringLiteral>(Attr.getArgAsExpr(1)))
2573 DefinedIn = SE->getString();
2574 bool IsGeneratedDeclaration = Attr.getArgAsIdent(2) != nullptr;
2575
2576 D->addAttr(::new (S.Context) ExternalSourceSymbolAttr(
2577 Attr.getRange(), S.Context, Language, DefinedIn, IsGeneratedDeclaration,
2578 Attr.getAttributeSpellingListIndex()));
2579}
2580
2581template <class T>
2582static T *mergeVisibilityAttr(Sema &S, Decl *D, SourceRange range,
2583 typename T::VisibilityType value,
2584 unsigned attrSpellingListIndex) {
2585 T *existingAttr = D->getAttr<T>();
2586 if (existingAttr) {
2587 typename T::VisibilityType existingValue = existingAttr->getVisibility();
2588 if (existingValue == value)
2589 return nullptr;
2590 S.Diag(existingAttr->getLocation(), diag::err_mismatched_visibility);
2591 S.Diag(range.getBegin(), diag::note_previous_attribute);
2592 D->dropAttr<T>();
2593 }
2594 return ::new (S.Context) T(range, S.Context, value, attrSpellingListIndex);
2595}
2596
2597VisibilityAttr *Sema::mergeVisibilityAttr(Decl *D, SourceRange Range,
2598 VisibilityAttr::VisibilityType Vis,
2599 unsigned AttrSpellingListIndex) {
2600 return ::mergeVisibilityAttr<VisibilityAttr>(*this, D, Range, Vis,
2601 AttrSpellingListIndex);
2602}
2603
2604TypeVisibilityAttr *Sema::mergeTypeVisibilityAttr(Decl *D, SourceRange Range,
2605 TypeVisibilityAttr::VisibilityType Vis,
2606 unsigned AttrSpellingListIndex) {
2607 return ::mergeVisibilityAttr<TypeVisibilityAttr>(*this, D, Range, Vis,
2608 AttrSpellingListIndex);
2609}
2610
2611static void handleVisibilityAttr(Sema &S, Decl *D, const AttributeList &Attr,
2612 bool isTypeVisibility) {
2613 // Visibility attributes don't mean anything on a typedef.
2614 if (isa<TypedefNameDecl>(D)) {
2615 S.Diag(Attr.getRange().getBegin(), diag::warn_attribute_ignored)
2616 << Attr.getName();
2617 return;
2618 }
2619
2620 // 'type_visibility' can only go on a type or namespace.
2621 if (isTypeVisibility &&
2622 !(isa<TagDecl>(D) ||
2623 isa<ObjCInterfaceDecl>(D) ||
2624 isa<NamespaceDecl>(D))) {
2625 S.Diag(Attr.getRange().getBegin(), diag::err_attribute_wrong_decl_type)
2626 << Attr.getName() << ExpectedTypeOrNamespace;
2627 return;
2628 }
2629
2630 // Check that the argument is a string literal.
2631 StringRef TypeStr;
2632 SourceLocation LiteralLoc;
2633 if (!S.checkStringLiteralArgumentAttr(Attr, 0, TypeStr, &LiteralLoc))
2634 return;
2635
2636 VisibilityAttr::VisibilityType type;
2637 if (!VisibilityAttr::ConvertStrToVisibilityType(TypeStr, type)) {
2638 S.Diag(LiteralLoc, diag::warn_attribute_type_not_supported)
2639 << Attr.getName() << TypeStr;
2640 return;
2641 }
2642
2643 // Complain about attempts to use protected visibility on targets
2644 // (like Darwin) that don't support it.
2645 if (type == VisibilityAttr::Protected &&
2646 !S.Context.getTargetInfo().hasProtectedVisibility()) {
2647 S.Diag(Attr.getLoc(), diag::warn_attribute_protected_visibility);
2648 type = VisibilityAttr::Default;
2649 }
2650
2651 unsigned Index = Attr.getAttributeSpellingListIndex();
2652 clang::Attr *newAttr;
2653 if (isTypeVisibility) {
2654 newAttr = S.mergeTypeVisibilityAttr(D, Attr.getRange(),
2655 (TypeVisibilityAttr::VisibilityType) type,
2656 Index);
2657 } else {
2658 newAttr = S.mergeVisibilityAttr(D, Attr.getRange(), type, Index);
2659 }
2660 if (newAttr)
2661 D->addAttr(newAttr);
2662}
2663
2664static void handleObjCMethodFamilyAttr(Sema &S, Decl *decl,
2665 const AttributeList &Attr) {
2666 ObjCMethodDecl *method = cast<ObjCMethodDecl>(decl);
2667 if (!Attr.isArgIdent(0)) {
2668 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_type)
2669 << Attr.getName() << 1 << AANT_ArgumentIdentifier;
2670 return;
2671 }
2672
2673 IdentifierLoc *IL = Attr.getArgAsIdent(0);
2674 ObjCMethodFamilyAttr::FamilyKind F;
2675 if (!ObjCMethodFamilyAttr::ConvertStrToFamilyKind(IL->Ident->getName(), F)) {
2676 S.Diag(IL->Loc, diag::warn_attribute_type_not_supported) << Attr.getName()
2677 << IL->Ident;
2678 return;
2679 }
2680
2681 if (F == ObjCMethodFamilyAttr::OMF_init &&
2682 !method->getReturnType()->isObjCObjectPointerType()) {
2683 S.Diag(method->getLocation(), diag::err_init_method_bad_return_type)
2684 << method->getReturnType();
2685 // Ignore the attribute.
2686 return;
2687 }
2688
2689 method->addAttr(new (S.Context) ObjCMethodFamilyAttr(Attr.getRange(),
2690 S.Context, F,
2691 Attr.getAttributeSpellingListIndex()));
2692}
2693
2694static void handleObjCNSObject(Sema &S, Decl *D, const AttributeList &Attr) {
2695 if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) {
2696 QualType T = TD->getUnderlyingType();
2697 if (!T->isCARCBridgableType()) {
2698 S.Diag(TD->getLocation(), diag::err_nsobject_attribute);
2699 return;
2700 }
2701 }
2702 else if (ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(D)) {
2703 QualType T = PD->getType();
2704 if (!T->isCARCBridgableType()) {
2705 S.Diag(PD->getLocation(), diag::err_nsobject_attribute);
2706 return;
2707 }
2708 }
2709 else {
2710 // It is okay to include this attribute on properties, e.g.:
2711 //
2712 // @property (retain, nonatomic) struct Bork *Q __attribute__((NSObject));
2713 //
2714 // In this case it follows tradition and suppresses an error in the above
2715 // case.
2716 S.Diag(D->getLocation(), diag::warn_nsobject_attribute);
2717 }
2718 D->addAttr(::new (S.Context)
2719 ObjCNSObjectAttr(Attr.getRange(), S.Context,
2720 Attr.getAttributeSpellingListIndex()));
2721}
2722
2723static void handleObjCIndependentClass(Sema &S, Decl *D, const AttributeList &Attr) {
2724 if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) {
2725 QualType T = TD->getUnderlyingType();
2726 if (!T->isObjCObjectPointerType()) {
2727 S.Diag(TD->getLocation(), diag::warn_ptr_independentclass_attribute);
2728 return;
2729 }
2730 } else {
2731 S.Diag(D->getLocation(), diag::warn_independentclass_attribute);
2732 return;
2733 }
2734 D->addAttr(::new (S.Context)
2735 ObjCIndependentClassAttr(Attr.getRange(), S.Context,
2736 Attr.getAttributeSpellingListIndex()));
2737}
2738
2739static void handleBlocksAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2740 if (!Attr.isArgIdent(0)) {
2741 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_type)
2742 << Attr.getName() << 1 << AANT_ArgumentIdentifier;
2743 return;
2744 }
2745
2746 IdentifierInfo *II = Attr.getArgAsIdent(0)->Ident;
2747 BlocksAttr::BlockType type;
2748 if (!BlocksAttr::ConvertStrToBlockType(II->getName(), type)) {
2749 S.Diag(Attr.getLoc(), diag::warn_attribute_type_not_supported)
2750 << Attr.getName() << II;
2751 return;
2752 }
2753
2754 D->addAttr(::new (S.Context)
2755 BlocksAttr(Attr.getRange(), S.Context, type,
2756 Attr.getAttributeSpellingListIndex()));
2757}
2758
2759static void handleSentinelAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2760 unsigned sentinel = (unsigned)SentinelAttr::DefaultSentinel;
2761 if (Attr.getNumArgs() > 0) {
2762 Expr *E = Attr.getArgAsExpr(0);
2763 llvm::APSInt Idx(32);
2764 if (E->isTypeDependent() || E->isValueDependent() ||
2765 !E->isIntegerConstantExpr(Idx, S.Context)) {
2766 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_type)
2767 << Attr.getName() << 1 << AANT_ArgumentIntegerConstant
2768 << E->getSourceRange();
2769 return;
2770 }
2771
2772 if (Idx.isSigned() && Idx.isNegative()) {
2773 S.Diag(Attr.getLoc(), diag::err_attribute_sentinel_less_than_zero)
2774 << E->getSourceRange();
2775 return;
2776 }
2777
2778 sentinel = Idx.getZExtValue();
2779 }
2780
2781 unsigned nullPos = (unsigned)SentinelAttr::DefaultNullPos;
2782 if (Attr.getNumArgs() > 1) {
2783 Expr *E = Attr.getArgAsExpr(1);
2784 llvm::APSInt Idx(32);
2785 if (E->isTypeDependent() || E->isValueDependent() ||
2786 !E->isIntegerConstantExpr(Idx, S.Context)) {
2787 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_type)
2788 << Attr.getName() << 2 << AANT_ArgumentIntegerConstant
2789 << E->getSourceRange();
2790 return;
2791 }
2792 nullPos = Idx.getZExtValue();
2793
2794 if ((Idx.isSigned() && Idx.isNegative()) || nullPos > 1) {
2795 // FIXME: This error message could be improved, it would be nice
2796 // to say what the bounds actually are.
2797 S.Diag(Attr.getLoc(), diag::err_attribute_sentinel_not_zero_or_one)
2798 << E->getSourceRange();
2799 return;
2800 }
2801 }
2802
2803 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
2804 const FunctionType *FT = FD->getType()->castAs<FunctionType>();
2805 if (isa<FunctionNoProtoType>(FT)) {
2806 S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_named_arguments);
2807 return;
2808 }
2809
2810 if (!cast<FunctionProtoType>(FT)->isVariadic()) {
2811 S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0;
2812 return;
2813 }
2814 } else if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) {
2815 if (!MD->isVariadic()) {
2816 S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0;
2817 return;
2818 }
2819 } else if (BlockDecl *BD = dyn_cast<BlockDecl>(D)) {
2820 if (!BD->isVariadic()) {
2821 S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 1;
2822 return;
2823 }
2824 } else if (const VarDecl *V = dyn_cast<VarDecl>(D)) {
2825 QualType Ty = V->getType();
2826 if (Ty->isBlockPointerType() || Ty->isFunctionPointerType()) {
2827 const FunctionType *FT = Ty->isFunctionPointerType()
2828 ? D->getFunctionType()
2829 : Ty->getAs<BlockPointerType>()->getPointeeType()->getAs<FunctionType>();
2830 if (!cast<FunctionProtoType>(FT)->isVariadic()) {
2831 int m = Ty->isFunctionPointerType() ? 0 : 1;
2832 S.Diag(Attr.getLoc(), diag::warn_attribute_sentinel_not_variadic) << m;
2833 return;
2834 }
2835 } else {
2836 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2837 << Attr.getName() << ExpectedFunctionMethodOrBlock;
2838 return;
2839 }
2840 } else {
2841 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2842 << Attr.getName() << ExpectedFunctionMethodOrBlock;
2843 return;
2844 }
2845 D->addAttr(::new (S.Context)
2846 SentinelAttr(Attr.getRange(), S.Context, sentinel, nullPos,
2847 Attr.getAttributeSpellingListIndex()));
2848}
2849
2850static void handleWarnUnusedResult(Sema &S, Decl *D, const AttributeList &Attr) {
2851 if (D->getFunctionType() &&
2852 D->getFunctionType()->getReturnType()->isVoidType()) {
2853 S.Diag(Attr.getLoc(), diag::warn_attribute_void_function_method)
2854 << Attr.getName() << 0;
2855 return;
2856 }
2857 if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
2858 if (MD->getReturnType()->isVoidType()) {
2859 S.Diag(Attr.getLoc(), diag::warn_attribute_void_function_method)
2860 << Attr.getName() << 1;
2861 return;
2862 }
2863
2864 // If this is spelled as the standard C++1z attribute, but not in C++1z, warn
2865 // about using it as an extension.
2866 if (!S.getLangOpts().CPlusPlus1z && Attr.isCXX11Attribute() &&
2867 !Attr.getScopeName())
2868 S.Diag(Attr.getLoc(), diag::ext_cxx17_attr) << Attr.getName();
2869
2870 D->addAttr(::new (S.Context)
2871 WarnUnusedResultAttr(Attr.getRange(), S.Context,
2872 Attr.getAttributeSpellingListIndex()));
2873}
2874
2875static void handleWeakImportAttr(Sema &S, Decl *D, const AttributeList &Attr) {
2876 // weak_import only applies to variable & function declarations.
2877 bool isDef = false;
2878 if (!D->canBeWeakImported(isDef)) {
2879 if (isDef)
2880 S.Diag(Attr.getLoc(), diag::warn_attribute_invalid_on_definition)
2881 << "weak_import";
2882 else if (isa<ObjCPropertyDecl>(D) || isa<ObjCMethodDecl>(D) ||
2883 (S.Context.getTargetInfo().getTriple().isOSDarwin() &&
2884 (isa<ObjCInterfaceDecl>(D) || isa<EnumDecl>(D)))) {
2885 // Nothing to warn about here.
2886 } else
2887 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
2888 << Attr.getName() << ExpectedVariableOrFunction;
2889
2890 return;
2891 }
2892
2893 D->addAttr(::new (S.Context)
2894 WeakImportAttr(Attr.getRange(), S.Context,
2895 Attr.getAttributeSpellingListIndex()));
2896}
2897
2898// Handles reqd_work_group_size and work_group_size_hint.
2899template <typename WorkGroupAttr>
2900static void handleWorkGroupSize(Sema &S, Decl *D,
2901 const AttributeList &Attr) {
2902 uint32_t WGSize[3];
2903 for (unsigned i = 0; i < 3; ++i) {
2904 const Expr *E = Attr.getArgAsExpr(i);
2905 if (!checkUInt32Argument(S, Attr, E, WGSize[i], i))
2906 return;
2907 if (WGSize[i] == 0) {
2908 S.Diag(Attr.getLoc(), diag::err_attribute_argument_is_zero)
2909 << Attr.getName() << E->getSourceRange();
2910 return;
2911 }
2912 }
2913
2914 WorkGroupAttr *Existing = D->getAttr<WorkGroupAttr>();
2915 if (Existing && !(Existing->getXDim() == WGSize[0] &&
2916 Existing->getYDim() == WGSize[1] &&
2917 Existing->getZDim() == WGSize[2]))
2918 S.Diag(Attr.getLoc(), diag::warn_duplicate_attribute) << Attr.getName();
2919
2920 D->addAttr(::new (S.Context) WorkGroupAttr(Attr.getRange(), S.Context,
2921 WGSize[0], WGSize[1], WGSize[2],
2922 Attr.getAttributeSpellingListIndex()));
2923}
2924
2925// Handles intel_reqd_sub_group_size.
2926static void handleSubGroupSize(Sema &S, Decl *D, const AttributeList &Attr) {
2927 uint32_t SGSize;
2928 const Expr *E = Attr.getArgAsExpr(0);
2929 if (!checkUInt32Argument(S, Attr, E, SGSize))
2930 return;
2931 if (SGSize == 0) {
2932 S.Diag(Attr.getLoc(), diag::err_attribute_argument_is_zero)
2933 << Attr.getName() << E->getSourceRange();
2934 return;
2935 }
2936
2937 OpenCLIntelReqdSubGroupSizeAttr *Existing =
2938 D->getAttr<OpenCLIntelReqdSubGroupSizeAttr>();
2939 if (Existing && Existing->getSubGroupSize() != SGSize)
2940 S.Diag(Attr.getLoc(), diag::warn_duplicate_attribute) << Attr.getName();
2941
2942 D->addAttr(::new (S.Context) OpenCLIntelReqdSubGroupSizeAttr(
2943 Attr.getRange(), S.Context, SGSize,
2944 Attr.getAttributeSpellingListIndex()));
2945}
2946
2947static void handleVecTypeHint(Sema &S, Decl *D, const AttributeList &Attr) {
2948 if (!Attr.hasParsedType()) {
2949 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments)
2950 << Attr.getName() << 1;
2951 return;
2952 }
2953
2954 TypeSourceInfo *ParmTSI = nullptr;
2955 QualType ParmType = S.GetTypeFromParser(Attr.getTypeArg(), &ParmTSI);
2956 assert(ParmTSI && "no type source info for attribute argument")(static_cast <bool> (ParmTSI && "no type source info for attribute argument"
) ? void (0) : __assert_fail ("ParmTSI && \"no type source info for attribute argument\""
, "/build/llvm-toolchain-snapshot-6.0~svn318882/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 2956, __extension__ __PRETTY_FUNCTION__))
;
2957
2958 if (!ParmType->isExtVectorType() && !ParmType->isFloatingType() &&
2959 (ParmType->isBooleanType() ||
2960 !ParmType->isIntegralType(S.getASTContext()))) {
2961 S.Diag(Attr.getLoc(), diag::err_attribute_argument_vec_type_hint)
2962 << ParmType;
2963 return;
2964 }
2965
2966 if (VecTypeHintAttr *A = D->getAttr<VecTypeHintAttr>()) {
2967 if (!S.Context.hasSameType(A->getTypeHint(), ParmType)) {
2968 S.Diag(Attr.getLoc(), diag::warn_duplicate_attribute) << Attr.getName();
2969 return;
2970 }
2971 }
2972
2973 D->addAttr(::new (S.Context) VecTypeHintAttr(Attr.getLoc(), S.Context,
2974 ParmTSI,
2975 Attr.getAttributeSpellingListIndex()));
2976}
2977
2978SectionAttr *Sema::mergeSectionAttr(Decl *D, SourceRange Range,
2979 StringRef Name,
2980 unsigned AttrSpellingListIndex) {
2981 if (SectionAttr *ExistingAttr = D->getAttr<SectionAttr>()) {
2982 if (ExistingAttr->getName() == Name)
2983 return nullptr;
2984 Diag(ExistingAttr->getLocation(), diag::warn_mismatched_section);
2985 Diag(Range.getBegin(), diag::note_previous_attribute);
2986 return nullptr;
2987 }
2988 return ::new (Context) SectionAttr(Range, Context, Name,
2989 AttrSpellingListIndex);
2990}
2991
2992bool Sema::checkSectionName(SourceLocation LiteralLoc, StringRef SecName) {
2993 std::string Error = Context.getTargetInfo().isValidSectionSpecifier(SecName);
2994 if (!Error.empty()) {
2995 Diag(LiteralLoc, diag::err_attribute_section_invalid_for_target) << Error;
2996 return false;
2997 }
2998 return true;
2999}
3000
3001static void handleSectionAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3002 // Make sure that there is a string literal as the sections's single
3003 // argument.
3004 StringRef Str;
3005 SourceLocation LiteralLoc;
3006 if (!S.checkStringLiteralArgumentAttr(Attr, 0, Str, &LiteralLoc))
3007 return;
3008
3009 if (!S.checkSectionName(LiteralLoc, Str))
3010 return;
3011
3012 // If the target wants to validate the section specifier, make it happen.
3013 std::string Error = S.Context.getTargetInfo().isValidSectionSpecifier(Str);
3014 if (!Error.empty()) {
3015 S.Diag(LiteralLoc, diag::err_attribute_section_invalid_for_target)
3016 << Error;
3017 return;
3018 }
3019
3020 unsigned Index = Attr.getAttributeSpellingListIndex();
3021 SectionAttr *NewAttr = S.mergeSectionAttr(D, Attr.getRange(), Str, Index);
3022 if (NewAttr)
3023 D->addAttr(NewAttr);
3024}
3025
3026// Check for things we'd like to warn about. Multiversioning issues are
3027// handled later in the process, once we know how many exist.
3028bool Sema::checkTargetAttr(SourceLocation LiteralLoc, StringRef AttrStr) {
3029 enum FirstParam { Unsupported, Duplicate };
3030 enum SecondParam { None, Architecture };
3031 for (auto Str : {"tune=", "fpmath="})
3032 if (AttrStr.find(Str) != StringRef::npos)
3033 return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
3034 << Unsupported << None << Str;
3035
3036 TargetAttr::ParsedTargetAttr ParsedAttrs = TargetAttr::parse(AttrStr);
3037
3038 if (!ParsedAttrs.Architecture.empty() &&
3039 !Context.getTargetInfo().isValidCPUName(ParsedAttrs.Architecture))
3040 return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
3041 << Unsupported << Architecture << ParsedAttrs.Architecture;
3042
3043 if (ParsedAttrs.DuplicateArchitecture)
3044 return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
3045 << Duplicate << None << "arch=";
3046
3047 for (const auto &Feature : ParsedAttrs.Features) {
3048 auto CurFeature = StringRef(Feature).drop_front(); // remove + or -.
3049 if (!Context.getTargetInfo().isValidFeatureName(CurFeature))
3050 return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
3051 << Unsupported << None << CurFeature;
3052 }
3053
3054 return true;
3055}
3056
3057static void handleTargetAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3058 StringRef Str;
3059 SourceLocation LiteralLoc;
3060 if (!S.checkStringLiteralArgumentAttr(Attr, 0, Str, &LiteralLoc) ||
3061 !S.checkTargetAttr(LiteralLoc, Str))
3062 return;
3063 unsigned Index = Attr.getAttributeSpellingListIndex();
3064 TargetAttr *NewAttr =
3065 ::new (S.Context) TargetAttr(Attr.getRange(), S.Context, Str, Index);
3066 D->addAttr(NewAttr);
3067}
3068
3069static void handleCleanupAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3070 VarDecl *VD = cast<VarDecl>(D);
3071 if (!VD->hasLocalStorage()) {
3072 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
3073 return;
3074 }
3075
3076 Expr *E = Attr.getArgAsExpr(0);
3077 SourceLocation Loc = E->getExprLoc();
3078 FunctionDecl *FD = nullptr;
3079 DeclarationNameInfo NI;
3080
3081 // gcc only allows for simple identifiers. Since we support more than gcc, we
3082 // will warn the user.
3083 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
3084 if (DRE->hasQualifier())
3085 S.Diag(Loc, diag::warn_cleanup_ext);
3086 FD = dyn_cast<FunctionDecl>(DRE->getDecl());
3087 NI = DRE->getNameInfo();
3088 if (!FD) {
3089 S.Diag(Loc, diag::err_attribute_cleanup_arg_not_function) << 1
3090 << NI.getName();
3091 return;
3092 }
3093 } else if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
3094 if (ULE->hasExplicitTemplateArgs())
3095 S.Diag(Loc, diag::warn_cleanup_ext);
3096 FD = S.ResolveSingleFunctionTemplateSpecialization(ULE, true);
3097 NI = ULE->getNameInfo();
3098 if (!FD) {
3099 S.Diag(Loc, diag::err_attribute_cleanup_arg_not_function) << 2
3100 << NI.getName();
3101 if (ULE->getType() == S.Context.OverloadTy)
3102 S.NoteAllOverloadCandidates(ULE);
3103 return;
3104 }
3105 } else {
3106 S.Diag(Loc, diag::err_attribute_cleanup_arg_not_function) << 0;
3107 return;
3108 }
3109
3110 if (FD->getNumParams() != 1) {
3111 S.Diag(Loc, diag::err_attribute_cleanup_func_must_take_one_arg)
3112 << NI.getName();
3113 return;
3114 }
3115
3116 // We're currently more strict than GCC about what function types we accept.
3117 // If this ever proves to be a problem it should be easy to fix.
3118 QualType Ty = S.Context.getPointerType(VD->getType());
3119 QualType ParamTy = FD->getParamDecl(0)->getType();
3120 if (S.CheckAssignmentConstraints(FD->getParamDecl(0)->getLocation(),
3121 ParamTy, Ty) != Sema::Compatible) {
3122 S.Diag(Loc, diag::err_attribute_cleanup_func_arg_incompatible_type)
3123 << NI.getName() << ParamTy << Ty;
3124 return;
3125 }
3126
3127 D->addAttr(::new (S.Context)
3128 CleanupAttr(Attr.getRange(), S.Context, FD,
3129 Attr.getAttributeSpellingListIndex()));
3130}
3131
3132static void handleEnumExtensibilityAttr(Sema &S, Decl *D,
3133 const AttributeList &Attr) {
3134 if (!Attr.isArgIdent(0)) {
3135 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_type)
3136 << Attr.getName() << 0 << AANT_ArgumentIdentifier;
3137 return;
3138 }
3139
3140 EnumExtensibilityAttr::Kind ExtensibilityKind;
3141 IdentifierInfo *II = Attr.getArgAsIdent(0)->Ident;
3142 if (!EnumExtensibilityAttr::ConvertStrToKind(II->getName(),
3143 ExtensibilityKind)) {
3144 S.Diag(Attr.getLoc(), diag::warn_attribute_type_not_supported)
3145 << Attr.getName() << II;
3146 return;
3147 }
3148
3149 D->addAttr(::new (S.Context) EnumExtensibilityAttr(
3150 Attr.getRange(), S.Context, ExtensibilityKind,
3151 Attr.getAttributeSpellingListIndex()));
3152}
3153
3154/// Handle __attribute__((format_arg((idx)))) attribute based on
3155/// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
3156static void handleFormatArgAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3157 Expr *IdxExpr = Attr.getArgAsExpr(0);
3158 uint64_t Idx;
3159 if (!checkFunctionOrMethodParameterIndex(S, D, Attr, 1, IdxExpr, Idx))
3160 return;
3161
3162 // Make sure the format string is really a string.
3163 QualType Ty = getFunctionOrMethodParamType(D, Idx);
3164
3165 bool NotNSStringTy = !isNSStringType(Ty, S.Context);
3166 if (NotNSStringTy &&
3167 !isCFStringType(Ty, S.Context) &&
3168 (!Ty->isPointerType() ||
3169 !Ty->getAs<PointerType>()->getPointeeType()->isCharType())) {
3170 S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
3171 << "a string type" << IdxExpr->getSourceRange()
3172 << getFunctionOrMethodParamRange(D, 0);
3173 return;
3174 }
3175 Ty = getFunctionOrMethodResultType(D);
3176 if (!isNSStringType(Ty, S.Context) &&
3177 !isCFStringType(Ty, S.Context) &&
3178 (!Ty->isPointerType() ||
3179 !Ty->getAs<PointerType>()->getPointeeType()->isCharType())) {
3180 S.Diag(Attr.getLoc(), diag::err_format_attribute_result_not)
3181 << (NotNSStringTy ? "string type" : "NSString")
3182 << IdxExpr->getSourceRange() << getFunctionOrMethodParamRange(D, 0);
3183 return;
3184 }
3185
3186 // We cannot use the Idx returned from checkFunctionOrMethodParameterIndex
3187 // because that has corrected for the implicit this parameter, and is zero-
3188 // based. The attribute expects what the user wrote explicitly.
3189 llvm::APSInt Val;
3190 IdxExpr->EvaluateAsInt(Val, S.Context);
3191
3192 D->addAttr(::new (S.Context)
3193 FormatArgAttr(Attr.getRange(), S.Context, Val.getZExtValue(),
3194 Attr.getAttributeSpellingListIndex()));
3195}
3196
3197enum FormatAttrKind {
3198 CFStringFormat,
3199 NSStringFormat,
3200 StrftimeFormat,
3201 SupportedFormat,
3202 IgnoredFormat,
3203 InvalidFormat
3204};
3205
3206/// getFormatAttrKind - Map from format attribute names to supported format
3207/// types.
3208static FormatAttrKind getFormatAttrKind(StringRef Format) {
3209 return llvm::StringSwitch<FormatAttrKind>(Format)
3210 // Check for formats that get handled specially.
3211 .Case("NSString", NSStringFormat)
3212 .Case("CFString", CFStringFormat)
3213 .Case("strftime", StrftimeFormat)
3214
3215 // Otherwise, check for supported formats.
3216 .Cases("scanf", "printf", "printf0", "strfmon", SupportedFormat)
3217 .Cases("cmn_err", "vcmn_err", "zcmn_err", SupportedFormat)
3218 .Case("kprintf", SupportedFormat) // OpenBSD.
3219 .Case("freebsd_kprintf", SupportedFormat) // FreeBSD.
3220 .Case("os_trace", SupportedFormat)
3221 .Case("os_log", SupportedFormat)
3222
3223 .Cases("gcc_diag", "gcc_cdiag", "gcc_cxxdiag", "gcc_tdiag", IgnoredFormat)
3224 .Default(InvalidFormat);
3225}
3226
3227/// Handle __attribute__((init_priority(priority))) attributes based on
3228/// http://gcc.gnu.org/onlinedocs/gcc/C_002b_002b-Attributes.html
3229static void handleInitPriorityAttr(Sema &S, Decl *D,
3230 const AttributeList &Attr) {
3231 if (!S.getLangOpts().CPlusPlus) {
3232 S.Diag(Attr.getLoc(), diag::warn_attribute_ignored) << Attr.getName();
3233 return;
3234 }
3235
3236 if (S.getCurFunctionOrMethodDecl()) {
3237 S.Diag(Attr.getLoc(), diag::err_init_priority_object_attr);
3238 Attr.setInvalid();
3239 return;
3240 }
3241 QualType T = cast<VarDecl>(D)->getType();
3242 if (S.Context.getAsArrayType(T))
3243 T = S.Context.getBaseElementType(T);
3244 if (!T->getAs<RecordType>()) {
3245 S.Diag(Attr.getLoc(), diag::err_init_priority_object_attr);
3246 Attr.setInvalid();
3247 return;
3248 }
3249
3250 Expr *E = Attr.getArgAsExpr(0);
3251 uint32_t prioritynum;
3252 if (!checkUInt32Argument(S, Attr, E, prioritynum)) {
3253 Attr.setInvalid();
3254 return;
3255 }
3256
3257 if (prioritynum < 101 || prioritynum > 65535) {
3258 S.Diag(Attr.getLoc(), diag::err_attribute_argument_outof_range)
3259 << E->getSourceRange() << Attr.getName() << 101 << 65535;
3260 Attr.setInvalid();
3261 return;
3262 }
3263 D->addAttr(::new (S.Context)
3264 InitPriorityAttr(Attr.getRange(), S.Context, prioritynum,
3265 Attr.getAttributeSpellingListIndex()));
3266}
3267
3268FormatAttr *Sema::mergeFormatAttr(Decl *D, SourceRange Range,
3269 IdentifierInfo *Format, int FormatIdx,
3270 int FirstArg,
3271 unsigned AttrSpellingListIndex) {
3272 // Check whether we already have an equivalent format attribute.
3273 for (auto *F : D->specific_attrs<FormatAttr>()) {
3274 if (F->getType() == Format &&
3275 F->getFormatIdx() == FormatIdx &&
3276 F->getFirstArg() == FirstArg) {
3277 // If we don't have a valid location for this attribute, adopt the
3278 // location.
3279 if (F->getLocation().isInvalid())
3280 F->setRange(Range);
3281 return nullptr;
3282 }
3283 }
3284
3285 return ::new (Context) FormatAttr(Range, Context, Format, FormatIdx,
3286 FirstArg, AttrSpellingListIndex);
3287}
3288
3289/// Handle __attribute__((format(type,idx,firstarg))) attributes based on
3290/// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
3291static void handleFormatAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3292 if (!Attr.isArgIdent(0)) {
3293 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_type)
3294 << Attr.getName() << 1 << AANT_ArgumentIdentifier;
3295 return;
3296 }
3297
3298 // In C++ the implicit 'this' function parameter also counts, and they are
3299 // counted from one.
3300 bool HasImplicitThisParam = isInstanceMethod(D);
3301 unsigned NumArgs = getFunctionOrMethodNumParams(D) + HasImplicitThisParam;
3302
3303 IdentifierInfo *II = Attr.getArgAsIdent(0)->Ident;
3304 StringRef Format = II->getName();
3305
3306 if (normalizeName(Format)) {
3307 // If we've modified the string name, we need a new identifier for it.
3308 II = &S.Context.Idents.get(Format);
3309 }
3310
3311 // Check for supported formats.
3312 FormatAttrKind Kind = getFormatAttrKind(Format);
3313
3314 if (Kind == IgnoredFormat)
3315 return;
3316
3317 if (Kind == InvalidFormat) {
3318 S.Diag(Attr.getLoc(), diag::warn_attribute_type_not_supported)
3319 << Attr.getName() << II->getName();
3320 return;
3321 }
3322
3323 // checks for the 2nd argument
3324 Expr *IdxExpr = Attr.getArgAsExpr(1);
3325 uint32_t Idx;
3326 if (!checkUInt32Argument(S, Attr, IdxExpr, Idx, 2))
3327 return;
3328
3329 if (Idx < 1 || Idx > NumArgs) {
3330 S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
3331 << Attr.getName() << 2 << IdxExpr->getSourceRange();
3332 return;
3333 }
3334
3335 // FIXME: Do we need to bounds check?
3336 unsigned ArgIdx = Idx - 1;
3337
3338 if (HasImplicitThisParam) {
3339 if (ArgIdx == 0) {
3340 S.Diag(Attr.getLoc(),
3341 diag::err_format_attribute_implicit_this_format_string)
3342 << IdxExpr->getSourceRange();
3343 return;
3344 }
3345 ArgIdx--;
3346 }
3347
3348 // make sure the format string is really a string
3349 QualType Ty = getFunctionOrMethodParamType(D, ArgIdx);
3350
3351 if (Kind == CFStringFormat) {
3352 if (!isCFStringType(Ty, S.Context)) {
3353 S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
3354 << "a CFString" << IdxExpr->getSourceRange()
3355 << getFunctionOrMethodParamRange(D, ArgIdx);
3356 return;
3357 }
3358 } else if (Kind == NSStringFormat) {
3359 // FIXME: do we need to check if the type is NSString*? What are the
3360 // semantics?
3361 if (!isNSStringType(Ty, S.Context)) {
3362 S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
3363 << "an NSString" << IdxExpr->getSourceRange()
3364 << getFunctionOrMethodParamRange(D, ArgIdx);
3365 return;
3366 }
3367 } else if (!Ty->isPointerType() ||
3368 !Ty->getAs<PointerType>()->getPointeeType()->isCharType()) {
3369 S.Diag(Attr.getLoc(), diag::err_format_attribute_not)
3370 << "a string type" << IdxExpr->getSourceRange()
3371 << getFunctionOrMethodParamRange(D, ArgIdx);
3372 return;
3373 }
3374
3375 // check the 3rd argument
3376 Expr *FirstArgExpr = Attr.getArgAsExpr(2);
3377 uint32_t FirstArg;
3378 if (!checkUInt32Argument(S, Attr, FirstArgExpr, FirstArg, 3))
3379 return;
3380
3381 // check if the function is variadic if the 3rd argument non-zero
3382 if (FirstArg != 0) {
3383 if (isFunctionOrMethodVariadic(D)) {
3384 ++NumArgs; // +1 for ...
3385 } else {
3386 S.Diag(D->getLocation(), diag::err_format_attribute_requires_variadic);
3387 return;
3388 }
3389 }
3390
3391 // strftime requires FirstArg to be 0 because it doesn't read from any
3392 // variable the input is just the current time + the format string.
3393 if (Kind == StrftimeFormat) {
3394 if (FirstArg != 0) {
3395 S.Diag(Attr.getLoc(), diag::err_format_strftime_third_parameter)
3396 << FirstArgExpr->getSourceRange();
3397 return;
3398 }
3399 // if 0 it disables parameter checking (to use with e.g. va_list)
3400 } else if (FirstArg != 0 && FirstArg != NumArgs) {
3401 S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
3402 << Attr.getName() << 3 << FirstArgExpr->getSourceRange();
3403 return;
3404 }
3405
3406 FormatAttr *NewAttr = S.mergeFormatAttr(D, Attr.getRange(), II,
3407 Idx, FirstArg,
3408 Attr.getAttributeSpellingListIndex());
3409 if (NewAttr)
3410 D->addAttr(NewAttr);
3411}
3412
3413static void handleTransparentUnionAttr(Sema &S, Decl *D,
3414 const AttributeList &Attr) {
3415 // Try to find the underlying union declaration.
3416 RecordDecl *RD = nullptr;
3417 TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D);
3418 if (TD && TD->getUnderlyingType()->isUnionType())
3419 RD = TD->getUnderlyingType()->getAsUnionType()->getDecl();
3420 else
3421 RD = dyn_cast<RecordDecl>(D);
3422
3423 if (!RD || !RD->isUnion()) {
3424 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
3425 << Attr.getName() << ExpectedUnion;
3426 return;
3427 }
3428
3429 if (!RD->isCompleteDefinition()) {
3430 if (!RD->isBeingDefined())
3431 S.Diag(Attr.getLoc(),
3432 diag::warn_transparent_union_attribute_not_definition);
3433 return;
3434 }
3435
3436 RecordDecl::field_iterator Field = RD->field_begin(),
3437 FieldEnd = RD->field_end();
3438 if (Field == FieldEnd) {
3439 S.Diag(Attr.getLoc(), diag::warn_transparent_union_attribute_zero_fields);
3440 return;
3441 }
3442
3443 FieldDecl *FirstField = *Field;
3444 QualType FirstType = FirstField->getType();
3445 if (FirstType->hasFloatingRepresentation() || FirstType->isVectorType()) {
3446 S.Diag(FirstField->getLocation(),
3447 diag::warn_transparent_union_attribute_floating)
3448 << FirstType->isVectorType() << FirstType;
3449 return;
3450 }
3451
3452 if (FirstType->isIncompleteType())
3453 return;
3454 uint64_t FirstSize = S.Context.getTypeSize(FirstType);
3455 uint64_t FirstAlign = S.Context.getTypeAlign(FirstType);
3456 for (; Field != FieldEnd; ++Field) {
3457 QualType FieldType = Field->getType();
3458 if (FieldType->isIncompleteType())
3459 return;
3460 // FIXME: this isn't fully correct; we also need to test whether the
3461 // members of the union would all have the same calling convention as the
3462 // first member of the union. Checking just the size and alignment isn't
3463 // sufficient (consider structs passed on the stack instead of in registers
3464 // as an example).
3465 if (S.Context.getTypeSize(FieldType) != FirstSize ||
3466 S.Context.getTypeAlign(FieldType) > FirstAlign) {
3467 // Warn if we drop the attribute.
3468 bool isSize = S.Context.getTypeSize(FieldType) != FirstSize;
3469 unsigned FieldBits = isSize? S.Context.getTypeSize(FieldType)
3470 : S.Context.getTypeAlign(FieldType);
3471 S.Diag(Field->getLocation(),
3472 diag::warn_transparent_union_attribute_field_size_align)
3473 << isSize << Field->getDeclName() << FieldBits;
3474 unsigned FirstBits = isSize? FirstSize : FirstAlign;
3475 S.Diag(FirstField->getLocation(),
3476 diag::note_transparent_union_first_field_size_align)
3477 << isSize << FirstBits;
3478 return;
3479 }
3480 }
3481
3482 RD->addAttr(::new (S.Context)
3483 TransparentUnionAttr(Attr.getRange(), S.Context,
3484 Attr.getAttributeSpellingListIndex()));
3485}
3486
3487static void handleAnnotateAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3488 // Make sure that there is a string literal as the annotation's single
3489 // argument.
3490 StringRef Str;
3491 if (!S.checkStringLiteralArgumentAttr(Attr, 0, Str))
3492 return;
3493
3494 // Don't duplicate annotations that are already set.
3495 for (const auto *I : D->specific_attrs<AnnotateAttr>()) {
3496 if (I->getAnnotation() == Str)
3497 return;
3498 }
3499
3500 D->addAttr(::new (S.Context)
3501 AnnotateAttr(Attr.getRange(), S.Context, Str,
3502 Attr.getAttributeSpellingListIndex()));
3503}
3504
3505static void handleAlignValueAttr(Sema &S, Decl *D,
3506 const AttributeList &Attr) {
3507 S.AddAlignValueAttr(Attr.getRange(), D, Attr.getArgAsExpr(0),
3508 Attr.getAttributeSpellingListIndex());
3509}
3510
3511void Sema::AddAlignValueAttr(SourceRange AttrRange, Decl *D, Expr *E,
3512 unsigned SpellingListIndex) {
3513 AlignValueAttr TmpAttr(AttrRange, Context, E, SpellingListIndex);
3514 SourceLocation AttrLoc = AttrRange.getBegin();
3515
3516 QualType T;
3517 if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D))
3518 T = TD->getUnderlyingType();
3519 else if (ValueDecl *VD = dyn_cast<ValueDecl>(D))
3520 T = VD->getType();
3521 else
3522 llvm_unreachable("Unknown decl type for align_value")::llvm::llvm_unreachable_internal("Unknown decl type for align_value"
, "/build/llvm-toolchain-snapshot-6.0~svn318882/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 3522)
;
3523
3524 if (!T->isDependentType() && !T->isAnyPointerType() &&
3525 !T->isReferenceType() && !T->isMemberPointerType()) {
3526 Diag(AttrLoc, diag::warn_attribute_pointer_or_reference_only)
3527 << &TmpAttr /*TmpAttr.getName()*/ << T << D->getSourceRange();
3528 return;
3529 }
3530
3531 if (!E->isValueDependent()) {
3532 llvm::APSInt Alignment;
3533 ExprResult ICE
3534 = VerifyIntegerConstantExpression(E, &Alignment,
3535 diag::err_align_value_attribute_argument_not_int,
3536 /*AllowFold*/ false);
3537 if (ICE.isInvalid())
3538 return;
3539
3540 if (!Alignment.isPowerOf2()) {
3541 Diag(AttrLoc, diag::err_alignment_not_power_of_two)
3542 << E->getSourceRange();
3543 return;
3544 }
3545
3546 D->addAttr(::new (Context)
3547 AlignValueAttr(AttrRange, Context, ICE.get(),
3548 SpellingListIndex));
3549 return;
3550 }
3551
3552 // Save dependent expressions in the AST to be instantiated.
3553 D->addAttr(::new (Context) AlignValueAttr(TmpAttr));
3554}
3555
3556static void handleAlignedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3557 // check the attribute arguments.
3558 if (Attr.getNumArgs() > 1) {
3559 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments)
3560 << Attr.getName() << 1;
3561 return;
3562 }
3563
3564 if (Attr.getNumArgs() == 0) {
3565 D->addAttr(::new (S.Context) AlignedAttr(Attr.getRange(), S.Context,
3566 true, nullptr, Attr.getAttributeSpellingListIndex()));
3567 return;
3568 }
3569
3570 Expr *E = Attr.getArgAsExpr(0);
3571 if (Attr.isPackExpansion() && !E->containsUnexpandedParameterPack()) {
3572 S.Diag(Attr.getEllipsisLoc(),
3573 diag::err_pack_expansion_without_parameter_packs);
3574 return;
3575 }
3576
3577 if (!Attr.isPackExpansion() && S.DiagnoseUnexpandedParameterPack(E))
3578 return;
3579
3580 if (E->isValueDependent()) {
3581 if (const auto *TND = dyn_cast<TypedefNameDecl>(D)) {
3582 if (!TND->getUnderlyingType()->isDependentType()) {
3583 S.Diag(Attr.getLoc(), diag::err_alignment_dependent_typedef_name)
3584 << E->getSourceRange();
3585 return;
3586 }
3587 }
3588 }
3589
3590 S.AddAlignedAttr(Attr.getRange(), D, E, Attr.getAttributeSpellingListIndex(),
3591 Attr.isPackExpansion());
3592}
3593
3594void Sema::AddAlignedAttr(SourceRange AttrRange, Decl *D, Expr *E,
3595 unsigned SpellingListIndex, bool IsPackExpansion) {
3596 AlignedAttr TmpAttr(AttrRange, Context, true, E, SpellingListIndex);
3597 SourceLocation AttrLoc = AttrRange.getBegin();
3598
3599 // C++11 alignas(...) and C11 _Alignas(...) have additional requirements.
3600 if (TmpAttr.isAlignas()) {
3601 // C++11 [dcl.align]p1:
3602 // An alignment-specifier may be applied to a variable or to a class
3603 // data member, but it shall not be applied to a bit-field, a function
3604 // parameter, the formal parameter of a catch clause, or a variable
3605 // declared with the register storage class specifier. An
3606 // alignment-specifier may also be applied to the declaration of a class
3607 // or enumeration type.
3608 // C11 6.7.5/2:
3609 // An alignment attribute shall not be specified in a declaration of
3610 // a typedef, or a bit-field, or a function, or a parameter, or an
3611 // object declared with the register storage-class specifier.
3612 int DiagKind = -1;
3613 if (isa<ParmVarDecl>(D)) {
3614 DiagKind = 0;
3615 } else if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
3616 if (VD->getStorageClass() == SC_Register)
3617 DiagKind = 1;
3618 if (VD->isExceptionVariable())
3619 DiagKind = 2;
3620 } else if (FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
3621 if (FD->isBitField())
3622 DiagKind = 3;
3623 } else if (!isa<TagDecl>(D)) {
3624 Diag(AttrLoc, diag::err_attribute_wrong_decl_type) << &TmpAttr
3625 << (TmpAttr.isC11() ? ExpectedVariableOrField
3626 : ExpectedVariableFieldOrTag);
3627 return;
3628 }
3629 if (DiagKind != -1) {
3630 Diag(AttrLoc, diag::err_alignas_attribute_wrong_decl_type)
3631 << &TmpAttr << DiagKind;
3632 return;
3633 }
3634 }
3635
3636 if (E->isTypeDependent() || E->isValueDependent()) {
3637 // Save dependent expressions in the AST to be instantiated.
3638 AlignedAttr *AA = ::new (Context) AlignedAttr(TmpAttr);
3639 AA->setPackExpansion(IsPackExpansion);
3640 D->addAttr(AA);
3641 return;
3642 }
3643
3644 // FIXME: Cache the number on the Attr object?
3645 llvm::APSInt Alignment;
3646 ExprResult ICE
3647 = VerifyIntegerConstantExpression(E, &Alignment,
3648 diag::err_aligned_attribute_argument_not_int,
3649 /*AllowFold*/ false);
3650 if (ICE.isInvalid())
3651 return;
3652
3653 uint64_t AlignVal = Alignment.getZExtValue();
3654
3655 // C++11 [dcl.align]p2:
3656 // -- if the constant expression evaluates to zero, the alignment
3657 // specifier shall have no effect
3658 // C11 6.7.5p6:
3659 // An alignment specification of zero has no effect.
3660 if (!(TmpAttr.isAlignas() && !Alignment)) {
3661 if (!llvm::isPowerOf2_64(AlignVal)) {
3662 Diag(AttrLoc, diag::err_alignment_not_power_of_two)
3663 << E->getSourceRange();
3664 return;
3665 }
3666 }
3667
3668 // Alignment calculations can wrap around if it's greater than 2**28.
3669 unsigned MaxValidAlignment =
3670 Context.getTargetInfo().getTriple().isOSBinFormatCOFF() ? 8192
3671 : 268435456;
3672 if (AlignVal > MaxValidAlignment) {
3673 Diag(AttrLoc, diag::err_attribute_aligned_too_great) << MaxValidAlignment
3674 << E->getSourceRange();
3675 return;
3676 }
3677
3678 if (Context.getTargetInfo().isTLSSupported()) {
3679 unsigned MaxTLSAlign =
3680 Context.toCharUnitsFromBits(Context.getTargetInfo().getMaxTLSAlign())
3681 .getQuantity();
3682 auto *VD = dyn_cast<VarDecl>(D);
3683 if (MaxTLSAlign && AlignVal > MaxTLSAlign && VD &&
3684 VD->getTLSKind() != VarDecl::TLS_None) {
3685 Diag(VD->getLocation(), diag::err_tls_var_aligned_over_maximum)
3686 << (unsigned)AlignVal << VD << MaxTLSAlign;
3687 return;
3688 }
3689 }
3690
3691 AlignedAttr *AA = ::new (Context) AlignedAttr(AttrRange, Context, true,
3692 ICE.get(), SpellingListIndex);
3693 AA->setPackExpansion(IsPackExpansion);
3694 D->addAttr(AA);
3695}
3696
3697void Sema::AddAlignedAttr(SourceRange AttrRange, Decl *D, TypeSourceInfo *TS,
3698 unsigned SpellingListIndex, bool IsPackExpansion) {
3699 // FIXME: Cache the number on the Attr object if non-dependent?
3700 // FIXME: Perform checking of type validity
3701 AlignedAttr *AA = ::new (Context) AlignedAttr(AttrRange, Context, false, TS,
3702 SpellingListIndex);
3703 AA->setPackExpansion(IsPackExpansion);
3704 D->addAttr(AA);
3705}
3706
3707void Sema::CheckAlignasUnderalignment(Decl *D) {
3708 assert(D->hasAttrs() && "no attributes on decl")(static_cast <bool> (D->hasAttrs() && "no attributes on decl"
) ? void (0) : __assert_fail ("D->hasAttrs() && \"no attributes on decl\""
, "/build/llvm-toolchain-snapshot-6.0~svn318882/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 3708, __extension__ __PRETTY_FUNCTION__))
;
3709
3710 QualType UnderlyingTy, DiagTy;
3711 if (ValueDecl *VD = dyn_cast<ValueDecl>(D)) {
3712 UnderlyingTy = DiagTy = VD->getType();
3713 } else {
3714 UnderlyingTy = DiagTy = Context.getTagDeclType(cast<TagDecl>(D));
3715 if (EnumDecl *ED = dyn_cast<EnumDecl>(D))
3716 UnderlyingTy = ED->getIntegerType();
3717 }
3718 if (DiagTy->isDependentType() || DiagTy->isIncompleteType())
3719 return;
3720
3721 // C++11 [dcl.align]p5, C11 6.7.5/4:
3722 // The combined effect of all alignment attributes in a declaration shall
3723 // not specify an alignment that is less strict than the alignment that
3724 // would otherwise be required for the entity being declared.
3725 AlignedAttr *AlignasAttr = nullptr;
3726 unsigned Align = 0;
3727 for (auto *I : D->specific_attrs<AlignedAttr>()) {
3728 if (I->isAlignmentDependent())
3729 return;
3730 if (I->isAlignas())
3731 AlignasAttr = I;
3732 Align = std::max(Align, I->getAlignment(Context));
3733 }
3734
3735 if (AlignasAttr && Align) {
3736 CharUnits RequestedAlign = Context.toCharUnitsFromBits(Align);
3737 CharUnits NaturalAlign = Context.getTypeAlignInChars(UnderlyingTy);
3738 if (NaturalAlign > RequestedAlign)
3739 Diag(AlignasAttr->getLocation(), diag::err_alignas_underaligned)
3740 << DiagTy << (unsigned)NaturalAlign.getQuantity();
3741 }
3742}
3743
3744bool Sema::checkMSInheritanceAttrOnDefinition(
3745 CXXRecordDecl *RD, SourceRange Range, bool BestCase,
3746 MSInheritanceAttr::Spelling SemanticSpelling) {
3747 assert(RD->hasDefinition() && "RD has no definition!")(static_cast <bool> (RD->hasDefinition() && "RD has no definition!"
) ? void (0) : __assert_fail ("RD->hasDefinition() && \"RD has no definition!\""
, "/build/llvm-toolchain-snapshot-6.0~svn318882/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 3747, __extension__ __PRETTY_FUNCTION__))
;
3748
3749 // We may not have seen base specifiers or any virtual methods yet. We will
3750 // have to wait until the record is defined to catch any mismatches.
3751 if (!RD->getDefinition()->isCompleteDefinition())
3752 return false;
3753
3754 // The unspecified model never matches what a definition could need.
3755 if (SemanticSpelling == MSInheritanceAttr::Keyword_unspecified_inheritance)
3756 return false;
3757
3758 if (BestCase) {
3759 if (RD->calculateInheritanceModel() == SemanticSpelling)
3760 return false;
3761 } else {
3762 if (RD->calculateInheritanceModel() <= SemanticSpelling)
3763 return false;
3764 }
3765
3766 Diag(Range.getBegin(), diag::err_mismatched_ms_inheritance)
3767 << 0 /*definition*/;
3768 Diag(RD->getDefinition()->getLocation(), diag::note_defined_here)
3769 << RD->getNameAsString();
3770 return true;
3771}
3772
3773/// parseModeAttrArg - Parses attribute mode string and returns parsed type
3774/// attribute.
3775static void parseModeAttrArg(Sema &S, StringRef Str, unsigned &DestWidth,
3776 bool &IntegerMode, bool &ComplexMode) {
3777 IntegerMode = true;
3778 ComplexMode = false;
3779 switch (Str.size()) {
3780 case 2:
3781 switch (Str[0]) {
3782 case 'Q':
3783 DestWidth = 8;
3784 break;
3785 case 'H':
3786 DestWidth = 16;
3787 break;
3788 case 'S':
3789 DestWidth = 32;
3790 break;
3791 case 'D':
3792 DestWidth = 64;
3793 break;
3794 case 'X':
3795 DestWidth = 96;
3796 break;
3797 case 'T':
3798 DestWidth = 128;
3799 break;
3800 }
3801 if (Str[1] == 'F') {
3802 IntegerMode = false;
3803 } else if (Str[1] == 'C') {
3804 IntegerMode = false;
3805 ComplexMode = true;
3806 } else if (Str[1] != 'I') {
3807 DestWidth = 0;
3808 }
3809 break;
3810 case 4:
3811 // FIXME: glibc uses 'word' to define register_t; this is narrower than a
3812 // pointer on PIC16 and other embedded platforms.
3813 if (Str == "word")
3814 DestWidth = S.Context.getTargetInfo().getRegisterWidth();
3815 else if (Str == "byte")
3816 DestWidth = S.Context.getTargetInfo().getCharWidth();
3817 break;
3818 case 7:
3819 if (Str == "pointer")
3820 DestWidth = S.Context.getTargetInfo().getPointerWidth(0);
3821 break;
3822 case 11:
3823 if (Str == "unwind_word")
3824 DestWidth = S.Context.getTargetInfo().getUnwindWordWidth();
3825 break;
3826 }
3827}
3828
3829/// handleModeAttr - This attribute modifies the width of a decl with primitive
3830/// type.
3831///
3832/// Despite what would be logical, the mode attribute is a decl attribute, not a
3833/// type attribute: 'int ** __attribute((mode(HI))) *G;' tries to make 'G' be
3834/// HImode, not an intermediate pointer.
3835static void handleModeAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3836 // This attribute isn't documented, but glibc uses it. It changes
3837 // the width of an int or unsigned int to the specified size.
3838 if (!Attr.isArgIdent(0)) {
3839 S.Diag(Attr.getLoc(), diag::err_attribute_argument_type) << Attr.getName()
3840 << AANT_ArgumentIdentifier;
3841 return;
3842 }
3843
3844 IdentifierInfo *Name = Attr.getArgAsIdent(0)->Ident;
3845
3846 S.AddModeAttr(Attr.getRange(), D, Name, Attr.getAttributeSpellingListIndex());
3847}
3848
3849void Sema::AddModeAttr(SourceRange AttrRange, Decl *D, IdentifierInfo *Name,
3850 unsigned SpellingListIndex, bool InInstantiation) {
3851 StringRef Str = Name->getName();
3852 normalizeName(Str);
3853 SourceLocation AttrLoc = AttrRange.getBegin();
3854
3855 unsigned DestWidth = 0;
3856 bool IntegerMode = true;
3857 bool ComplexMode = false;
3858 llvm::APInt VectorSize(64, 0);
3859 if (Str.size() >= 4 && Str[0] == 'V') {
3860 // Minimal length of vector mode is 4: 'V' + NUMBER(>=1) + TYPE(>=2).
3861 size_t StrSize = Str.size();
3862 size_t VectorStringLength = 0;
3863 while ((VectorStringLength + 1) < StrSize &&
3864 isdigit(Str[VectorStringLength + 1]))
3865 ++VectorStringLength;
3866 if (VectorStringLength &&
3867 !Str.substr(1, VectorStringLength).getAsInteger(10, VectorSize) &&
3868 VectorSize.isPowerOf2()) {
3869 parseModeAttrArg(*this, Str.substr(VectorStringLength + 1), DestWidth,
3870 IntegerMode, ComplexMode);
3871 // Avoid duplicate warning from template instantiation.
3872 if (!InInstantiation)
3873 Diag(AttrLoc, diag::warn_vector_mode_deprecated);
3874 } else {
3875 VectorSize = 0;
3876 }
3877 }
3878
3879 if (!VectorSize)
3880 parseModeAttrArg(*this, Str, DestWidth, IntegerMode, ComplexMode);
3881
3882 // FIXME: Sync this with InitializePredefinedMacros; we need to match int8_t
3883 // and friends, at least with glibc.
3884 // FIXME: Make sure floating-point mappings are accurate
3885 // FIXME: Support XF and TF types
3886 if (!DestWidth) {
3887 Diag(AttrLoc, diag::err_machine_mode) << 0 /*Unknown*/ << Name;
3888 return;
3889 }
3890
3891 QualType OldTy;
3892 if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D))
3893 OldTy = TD->getUnderlyingType();
3894 else if (EnumDecl *ED = dyn_cast<EnumDecl>(D)) {
3895 // Something like 'typedef enum { X } __attribute__((mode(XX))) T;'.
3896 // Try to get type from enum declaration, default to int.
3897 OldTy = ED->getIntegerType();
3898 if (OldTy.isNull())
3899 OldTy = Context.IntTy;
3900 } else
3901 OldTy = cast<ValueDecl>(D)->getType();
3902
3903 if (OldTy->isDependentType()) {
3904 D->addAttr(::new (Context)
3905 ModeAttr(AttrRange, Context, Name, SpellingListIndex));
3906 return;
3907 }
3908
3909 // Base type can also be a vector type (see PR17453).
3910 // Distinguish between base type and base element type.
3911 QualType OldElemTy = OldTy;
3912 if (const VectorType *VT = OldTy->getAs<VectorType>())
3913 OldElemTy = VT->getElementType();
3914
3915 // GCC allows 'mode' attribute on enumeration types (even incomplete), except
3916 // for vector modes. So, 'enum X __attribute__((mode(QI)));' forms a complete
3917 // type, 'enum { A } __attribute__((mode(V4SI)))' is rejected.
3918 if ((isa<EnumDecl>(D) || OldElemTy->getAs<EnumType>()) &&
3919 VectorSize.getBoolValue()) {
3920 Diag(AttrLoc, diag::err_enum_mode_vector_type) << Name << AttrRange;
3921 return;
3922 }
3923 bool IntegralOrAnyEnumType =
3924 OldElemTy->isIntegralOrEnumerationType() || OldElemTy->getAs<EnumType>();
3925
3926 if (!OldElemTy->getAs<BuiltinType>() && !OldElemTy->isComplexType() &&
3927 !IntegralOrAnyEnumType)
3928 Diag(AttrLoc, diag::err_mode_not_primitive);
3929 else if (IntegerMode) {
3930 if (!IntegralOrAnyEnumType)
3931 Diag(AttrLoc, diag::err_mode_wrong_type);
3932 } else if (ComplexMode) {
3933 if (!OldElemTy->isComplexType())
3934 Diag(AttrLoc, diag::err_mode_wrong_type);
3935 } else {
3936 if (!OldElemTy->isFloatingType())
3937 Diag(AttrLoc, diag::err_mode_wrong_type);
3938 }
3939
3940 QualType NewElemTy;
3941
3942 if (IntegerMode)
3943 NewElemTy = Context.getIntTypeForBitwidth(DestWidth,
3944 OldElemTy->isSignedIntegerType());
3945 else
3946 NewElemTy = Context.getRealTypeForBitwidth(DestWidth);
3947
3948 if (NewElemTy.isNull()) {
3949 Diag(AttrLoc, diag::err_machine_mode) << 1 /*Unsupported*/ << Name;
3950 return;
3951 }
3952
3953 if (ComplexMode) {
3954 NewElemTy = Context.getComplexType(NewElemTy);
3955 }
3956
3957 QualType NewTy = NewElemTy;
3958 if (VectorSize.getBoolValue()) {
3959 NewTy = Context.getVectorType(NewTy, VectorSize.getZExtValue(),
3960 VectorType::GenericVector);
3961 } else if (const VectorType *OldVT = OldTy->getAs<VectorType>()) {
3962 // Complex machine mode does not support base vector types.
3963 if (ComplexMode) {
3964 Diag(AttrLoc, diag::err_complex_mode_vector_type);
3965 return;
3966 }
3967 unsigned NumElements = Context.getTypeSize(OldElemTy) *
3968 OldVT->getNumElements() /
3969 Context.getTypeSize(NewElemTy);
3970 NewTy =
3971 Context.getVectorType(NewElemTy, NumElements, OldVT->getVectorKind());
3972 }
3973
3974 if (NewTy.isNull()) {
3975 Diag(AttrLoc, diag::err_mode_wrong_type);
3976 return;
3977 }
3978
3979 // Install the new type.
3980 if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D))
3981 TD->setModedTypeSourceInfo(TD->getTypeSourceInfo(), NewTy);
3982 else if (EnumDecl *ED = dyn_cast<EnumDecl>(D))
3983 ED->setIntegerType(NewTy);
3984 else
3985 cast<ValueDecl>(D)->setType(NewTy);
3986
3987 D->addAttr(::new (Context)
3988 ModeAttr(AttrRange, Context, Name, SpellingListIndex));
3989}
3990
3991static void handleNoDebugAttr(Sema &S, Decl *D, const AttributeList &Attr) {
3992 D->addAttr(::new (S.Context)
3993 NoDebugAttr(Attr.getRange(), S.Context,
3994 Attr.getAttributeSpellingListIndex()));
3995}
3996
3997AlwaysInlineAttr *Sema::mergeAlwaysInlineAttr(Decl *D, SourceRange Range,
3998 IdentifierInfo *Ident,
3999 unsigned AttrSpellingListIndex) {
4000 if (OptimizeNoneAttr *Optnone = D->getAttr<OptimizeNoneAttr>()) {
4001 Diag(Range.getBegin(), diag::warn_attribute_ignored) << Ident;
4002 Diag(Optnone->getLocation(), diag::note_conflicting_attribute);
4003 return nullptr;
4004 }
4005
4006 if (D->hasAttr<AlwaysInlineAttr>())
4007 return nullptr;
4008
4009 return ::new (Context) AlwaysInlineAttr(Range, Context,
4010 AttrSpellingListIndex);
4011}
4012
4013CommonAttr *Sema::mergeCommonAttr(Decl *D, SourceRange Range,
4014 IdentifierInfo *Ident,
4015 unsigned AttrSpellingListIndex) {
4016 if (checkAttrMutualExclusion<InternalLinkageAttr>(*this, D, Range, Ident))
4017 return nullptr;
4018
4019 return ::new (Context) CommonAttr(Range, Context, AttrSpellingListIndex);
4020}
4021
4022InternalLinkageAttr *
4023Sema::mergeInternalLinkageAttr(Decl *D, SourceRange Range,
4024 IdentifierInfo *Ident,
4025 unsigned AttrSpellingListIndex) {
4026 if (auto VD = dyn_cast<VarDecl>(D)) {
4027 // Attribute applies to Var but not any subclass of it (like ParmVar,
4028 // ImplicitParm or VarTemplateSpecialization).
4029 if (VD->getKind() != Decl::Var) {
4030 Diag(Range.getBegin(), diag::warn_attribute_wrong_decl_type)
4031 << Ident << (getLangOpts().CPlusPlus ? ExpectedFunctionVariableOrClass
4032 : ExpectedVariableOrFunction);
4033 return nullptr;
4034 }
4035 // Attribute does not apply to non-static local variables.
4036 if (VD->hasLocalStorage()) {
4037 Diag(VD->getLocation(), diag::warn_internal_linkage_local_storage);
4038 return nullptr;
4039 }
4040 }
4041
4042 if (checkAttrMutualExclusion<CommonAttr>(*this, D, Range, Ident))
4043 return nullptr;
4044
4045 return ::new (Context)
4046 InternalLinkageAttr(Range, Context, AttrSpellingListIndex);
4047}
4048
4049MinSizeAttr *Sema::mergeMinSizeAttr(Decl *D, SourceRange Range,
4050 unsigned AttrSpellingListIndex) {
4051 if (OptimizeNoneAttr *Optnone = D->getAttr<OptimizeNoneAttr>()) {
4052 Diag(Range.getBegin(), diag::warn_attribute_ignored) << "'minsize'";
4053 Diag(Optnone->getLocation(), diag::note_conflicting_attribute);
4054 return nullptr;
4055 }
4056
4057 if (D->hasAttr<MinSizeAttr>())
4058 return nullptr;
4059
4060 return ::new (Context) MinSizeAttr(Range, Context, AttrSpellingListIndex);
4061}
4062
4063OptimizeNoneAttr *Sema::mergeOptimizeNoneAttr(Decl *D, SourceRange Range,
4064 unsigned AttrSpellingListIndex) {
4065 if (AlwaysInlineAttr *Inline = D->getAttr<AlwaysInlineAttr>()) {
4066 Diag(Inline->getLocation(), diag::warn_attribute_ignored) << Inline;
4067 Diag(Range.getBegin(), diag::note_conflicting_attribute);
4068 D->dropAttr<AlwaysInlineAttr>();
4069 }
4070 if (MinSizeAttr *MinSize = D->getAttr<MinSizeAttr>()) {
4071 Diag(MinSize->getLocation(), diag::warn_attribute_ignored) << MinSize;
4072 Diag(Range.getBegin(), diag::note_conflicting_attribute);
4073 D->dropAttr<MinSizeAttr>();
4074 }
4075
4076 if (D->hasAttr<OptimizeNoneAttr>())
4077 return nullptr;
4078
4079 return ::new (Context) OptimizeNoneAttr(Range, Context,
4080 AttrSpellingListIndex);
4081}
4082
4083static void handleAlwaysInlineAttr(Sema &S, Decl *D,
4084 const AttributeList &Attr) {
4085 if (checkAttrMutualExclusion<NotTailCalledAttr>(S, D, Attr.getRange(),
4086 Attr.getName()))
4087 return;
4088
4089 if (AlwaysInlineAttr *Inline = S.mergeAlwaysInlineAttr(
4090 D, Attr.getRange(), Attr.getName(),
4091 Attr.getAttributeSpellingListIndex()))
4092 D->addAttr(Inline);
4093}
4094
4095static void handleMinSizeAttr(Sema &S, Decl *D, const AttributeList &Attr) {
4096 if (MinSizeAttr *MinSize = S.mergeMinSizeAttr(
4097 D, Attr.getRange(), Attr.getAttributeSpellingListIndex()))
4098 D->addAttr(MinSize);
4099}
4100
4101static void handleOptimizeNoneAttr(Sema &S, Decl *D,
4102 const AttributeList &Attr) {
4103 if (OptimizeNoneAttr *Optnone = S.mergeOptimizeNoneAttr(
4104 D, Attr.getRange(), Attr.getAttributeSpellingListIndex()))
4105 D->addAttr(Optnone);
4106}
4107
4108static void handleConstantAttr(Sema &S, Decl *D, const AttributeList &Attr) {
4109 if (checkAttrMutualExclusion<CUDASharedAttr>(S, D, Attr.getRange(),
4110 Attr.getName()))
4111 return;
4112 auto *VD = cast<VarDecl>(D);
4113 if (!VD->hasGlobalStorage()) {
4114 S.Diag(Attr.getLoc(), diag::err_cuda_nonglobal_constant);
4115 return;
4116 }
4117 D->addAttr(::new (S.Context) CUDAConstantAttr(
4118 Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
4119}
4120
4121static void handleSharedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
4122 if (checkAttrMutualExclusion<CUDAConstantAttr>(S, D, Attr.getRange(),
1
Taking false branch
4123 Attr.getName()))
4124 return;
4125 auto *VD = cast<VarDecl>(D);
4126 // extern __shared__ is only allowed on arrays with no length (e.g.
4127 // "int x[]").
4128 if (VD->hasExternalStorage() && !isa<IncompleteArrayType>(VD->getType())) {
2
Taking false branch
4129 S.Diag(Attr.getLoc(), diag::err_cuda_extern_shared) << VD;
4130 return;
4131 }
4132 if (S.getLangOpts().CUDA && VD->hasLocalStorage() &&
3
Assuming the condition is true
22
Potential leak of memory pointed to by field 'DiagStorage'
4133 S.CUDADiagIfHostCode(Attr.getLoc(), diag::err_cuda_host_shared)
4
Calling 'operator<<'
21
Returned allocated memory
4134 << S.CurrentCUDATarget())
4135 return;
4136 D->addAttr(::new (S.Context) CUDASharedAttr(
4137 Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
4138}
4139
4140static void handleGlobalAttr(Sema &S, Decl *D, const AttributeList &Attr) {
4141 if (checkAttrMutualExclusion<CUDADeviceAttr>(S, D, Attr.getRange(),
4142 Attr.getName()) ||
4143 checkAttrMutualExclusion<CUDAHostAttr>(S, D, Attr.getRange(),
4144 Attr.getName())) {
4145 return;
4146 }
4147 FunctionDecl *FD = cast<FunctionDecl>(D);
4148 if (!FD->getReturnType()->isVoidType()) {
4149 SourceRange RTRange = FD->getReturnTypeSourceRange();
4150 S.Diag(FD->getTypeSpecStartLoc(), diag::err_kern_type_not_void_return)
4151 << FD->getType()
4152 << (RTRange.isValid() ? FixItHint::CreateReplacement(RTRange, "void")
4153 : FixItHint());
4154 return;
4155 }
4156 if (const auto *Method = dyn_cast<CXXMethodDecl>(FD)) {
4157 if (Method->isInstance()) {
4158 S.Diag(Method->getLocStart(), diag::err_kern_is_nonstatic_method)
4159 << Method;
4160 return;
4161 }
4162 S.Diag(Method->getLocStart(), diag::warn_kern_is_method) << Method;
4163 }
4164 // Only warn for "inline" when compiling for host, to cut down on noise.
4165 if (FD->isInlineSpecified() && !S.getLangOpts().CUDAIsDevice)
4166 S.Diag(FD->getLocStart(), diag::warn_kern_is_inline) << FD;
4167
4168 D->addAttr(::new (S.Context)
4169 CUDAGlobalAttr(Attr.getRange(), S.Context,
4170 Attr.getAttributeSpellingListIndex()));
4171}
4172
4173static void handleGNUInlineAttr(Sema &S, Decl *D, const AttributeList &Attr) {
4174 FunctionDecl *Fn = cast<FunctionDecl>(D);
4175 if (!Fn->isInlineSpecified()) {
4176 S.Diag(Attr.getLoc(), diag::warn_gnu_inline_attribute_requires_inline);
4177 return;
4178 }
4179
4180 D->addAttr(::new (S.Context)
4181 GNUInlineAttr(Attr.getRange(), S.Context,
4182 Attr.getAttributeSpellingListIndex()));
4183}
4184
4185static void handleCallConvAttr(Sema &S, Decl *D, const AttributeList &Attr) {
4186 if (hasDeclarator(D)) return;
4187
4188 // Diagnostic is emitted elsewhere: here we store the (valid) Attr
4189 // in the Decl node for syntactic reasoning, e.g., pretty-printing.
4190 CallingConv CC;
4191 if (S.CheckCallingConvAttr(Attr, CC, /*FD*/nullptr))
4192 return;
4193
4194 if (!isa<ObjCMethodDecl>(D)) {
4195 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
4196 << Attr.getName() << ExpectedFunctionOrMethod;
4197 return;
4198 }
4199
4200 switch (Attr.getKind()) {
4201 case AttributeList::AT_FastCall:
4202 D->addAttr(::new (S.Context)
4203 FastCallAttr(Attr.getRange(), S.Context,
4204 Attr.getAttributeSpellingListIndex()));
4205 return;
4206 case AttributeList::AT_StdCall:
4207 D->addAttr(::new (S.Context)
4208 StdCallAttr(Attr.getRange(), S.Context,
4209 Attr.getAttributeSpellingListIndex()));
4210 return;
4211 case AttributeList::AT_ThisCall:
4212 D->addAttr(::new (S.Context)
4213 ThisCallAttr(Attr.getRange(), S.Context,
4214 Attr.getAttributeSpellingListIndex()));
4215 return;
4216 case AttributeList::AT_CDecl:
4217 D->addAttr(::new (S.Context)
4218 CDeclAttr(Attr.getRange(), S.Context,
4219 Attr.getAttributeSpellingListIndex()));
4220 return;
4221 case AttributeList::AT_Pascal:
4222 D->addAttr(::new (S.Context)
4223 PascalAttr(Attr.getRange(), S.Context,
4224 Attr.getAttributeSpellingListIndex()));
4225 return;
4226 case AttributeList::AT_SwiftCall:
4227 D->addAttr(::new (S.Context)
4228 SwiftCallAttr(Attr.getRange(), S.Context,
4229 Attr.getAttributeSpellingListIndex()));
4230 return;
4231 case AttributeList::AT_VectorCall:
4232 D->addAttr(::new (S.Context)
4233 VectorCallAttr(Attr.getRange(), S.Context,
4234 Attr.getAttributeSpellingListIndex()));
4235 return;
4236 case AttributeList::AT_MSABI:
4237 D->addAttr(::new (S.Context)
4238 MSABIAttr(Attr.getRange(), S.Context,
4239 Attr.getAttributeSpellingListIndex()));
4240 return;
4241 case AttributeList::AT_SysVABI:
4242 D->addAttr(::new (S.Context)
4243 SysVABIAttr(Attr.getRange(), S.Context,
4244 Attr.getAttributeSpellingListIndex()));
4245 return;
4246 case AttributeList::AT_RegCall:
4247 D->addAttr(::new (S.Context) RegCallAttr(
4248 Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
4249 return;
4250 case AttributeList::AT_Pcs: {
4251 PcsAttr::PCSType PCS;
4252 switch (CC) {
4253 case CC_AAPCS:
4254 PCS = PcsAttr::AAPCS;
4255 break;
4256 case CC_AAPCS_VFP:
4257 PCS = PcsAttr::AAPCS_VFP;
4258 break;
4259 default:
4260 llvm_unreachable("unexpected calling convention in pcs attribute")::llvm::llvm_unreachable_internal("unexpected calling convention in pcs attribute"
, "/build/llvm-toolchain-snapshot-6.0~svn318882/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 4260)
;
4261 }
4262
4263 D->addAttr(::new (S.Context)
4264 PcsAttr(Attr.getRange(), S.Context, PCS,
4265 Attr.getAttributeSpellingListIndex()));
4266 return;
4267 }
4268 case AttributeList::AT_IntelOclBicc:
4269 D->addAttr(::new (S.Context)
4270 IntelOclBiccAttr(Attr.getRange(), S.Context,
4271 Attr.getAttributeSpellingListIndex()));
4272 return;
4273 case AttributeList::AT_PreserveMost:
4274 D->addAttr(::new (S.Context) PreserveMostAttr(
4275 Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
4276 return;
4277 case AttributeList::AT_PreserveAll:
4278 D->addAttr(::new (S.Context) PreserveAllAttr(
4279 Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
4280 return;
4281 default:
4282 llvm_unreachable("unexpected attribute kind")::llvm::llvm_unreachable_internal("unexpected attribute kind"
, "/build/llvm-toolchain-snapshot-6.0~svn318882/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 4282)
;
4283 }
4284}
4285
4286static void handleSuppressAttr(Sema &S, Decl *D, const AttributeList &Attr) {
4287 if (!checkAttributeAtLeastNumArgs(S, Attr, 1))
4288 return;
4289
4290 std::vector<StringRef> DiagnosticIdentifiers;
4291 for (unsigned I = 0, E = Attr.getNumArgs(); I != E; ++I) {
4292 StringRef RuleName;
4293
4294 if (!S.checkStringLiteralArgumentAttr(Attr, I, RuleName, nullptr))
4295 return;
4296
4297 // FIXME: Warn if the rule name is unknown. This is tricky because only
4298 // clang-tidy knows about available rules.
4299 DiagnosticIdentifiers.push_back(RuleName);
4300 }
4301 D->addAttr(::new (S.Context) SuppressAttr(
4302 Attr.getRange(), S.Context, DiagnosticIdentifiers.data(),
4303 DiagnosticIdentifiers.size(), Attr.getAttributeSpellingListIndex()));
4304}
4305
4306bool Sema::CheckCallingConvAttr(const AttributeList &Attrs, CallingConv &CC,
4307 const FunctionDecl *FD) {
4308 if (Attrs.isInvalid())
4309 return true;
4310
4311 if (Attrs.hasProcessingCache()) {
4312 CC = (CallingConv) Attrs.getProcessingCache();
4313 return false;
4314 }
4315
4316 unsigned ReqArgs = Attrs.getKind() == AttributeList::AT_Pcs ? 1 : 0;
4317 if (!checkAttributeNumArgs(*this, Attrs, ReqArgs)) {
4318 Attrs.setInvalid();
4319 return true;
4320 }
4321
4322 // TODO: diagnose uses of these conventions on the wrong target.
4323 switch (Attrs.getKind()) {
4324 case AttributeList::AT_CDecl: CC = CC_C; break;
4325 case AttributeList::AT_FastCall: CC = CC_X86FastCall; break;
4326 case AttributeList::AT_StdCall: CC = CC_X86StdCall; break;
4327 case AttributeList::AT_ThisCall: CC = CC_X86ThisCall; break;
4328 case AttributeList::AT_Pascal: CC = CC_X86Pascal; break;
4329 case AttributeList::AT_SwiftCall: CC = CC_Swift; break;
4330 case AttributeList::AT_VectorCall: CC = CC_X86VectorCall; break;
4331 case AttributeList::AT_RegCall: CC = CC_X86RegCall; break;
4332 case AttributeList::AT_MSABI:
4333 CC = Context.getTargetInfo().getTriple().isOSWindows() ? CC_C :
4334 CC_Win64;
4335 break;
4336 case AttributeList::AT_SysVABI:
4337 CC = Context.getTargetInfo().getTriple().isOSWindows() ? CC_X86_64SysV :
4338 CC_C;
4339 break;
4340 case AttributeList::AT_Pcs: {
4341 StringRef StrRef;
4342 if (!checkStringLiteralArgumentAttr(Attrs, 0, StrRef)) {
4343 Attrs.setInvalid();
4344 return true;
4345 }
4346 if (StrRef == "aapcs") {
4347 CC = CC_AAPCS;
4348 break;
4349 } else if (StrRef == "aapcs-vfp") {
4350 CC = CC_AAPCS_VFP;
4351 break;
4352 }
4353
4354 Attrs.setInvalid();
4355 Diag(Attrs.getLoc(), diag::err_invalid_pcs);
4356 return true;
4357 }
4358 case AttributeList::AT_IntelOclBicc: CC = CC_IntelOclBicc; break;
4359 case AttributeList::AT_PreserveMost: CC = CC_PreserveMost; break;
4360 case AttributeList::AT_PreserveAll: CC = CC_PreserveAll; break;
4361 default: llvm_unreachable("unexpected attribute kind")::llvm::llvm_unreachable_internal("unexpected attribute kind"
, "/build/llvm-toolchain-snapshot-6.0~svn318882/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 4361)
;
4362 }
4363
4364 const TargetInfo &TI = Context.getTargetInfo();
4365 TargetInfo::CallingConvCheckResult A = TI.checkCallingConvention(CC);
4366 if (A != TargetInfo::CCCR_OK) {
4367 if (A == TargetInfo::CCCR_Warning)
4368 Diag(Attrs.getLoc(), diag::warn_cconv_ignored) << Attrs.getName();
4369
4370 // This convention is not valid for the target. Use the default function or
4371 // method calling convention.
4372 bool IsCXXMethod = false, IsVariadic = false;
4373 if (FD) {
4374 IsCXXMethod = FD->isCXXInstanceMember();
4375 IsVariadic = FD->isVariadic();
4376 }
4377 CC = Context.getDefaultCallingConvention(IsVariadic, IsCXXMethod);
4378 }
4379
4380 Attrs.setProcessingCache((unsigned) CC);
4381 return false;
4382}
4383
4384/// Pointer-like types in the default address space.
4385static bool isValidSwiftContextType(QualType type) {
4386 if (!type->hasPointerRepresentation())
4387 return type->isDependentType();
4388 return type->getPointeeType().getAddressSpace() == LangAS::Default;
4389}
4390
4391/// Pointers and references in the default address space.
4392static bool isValidSwiftIndirectResultType(QualType type) {
4393 if (auto ptrType = type->getAs<PointerType>()) {
4394 type = ptrType->getPointeeType();
4395 } else if (auto refType = type->getAs<ReferenceType>()) {
4396 type = refType->getPointeeType();
4397 } else {
4398 return type->isDependentType();
4399 }
4400 return type.getAddressSpace() == LangAS::Default;
4401}
4402
4403/// Pointers and references to pointers in the default address space.
4404static bool isValidSwiftErrorResultType(QualType type) {
4405 if (auto ptrType = type->getAs<PointerType>()) {
4406 type = ptrType->getPointeeType();
4407 } else if (auto refType = type->getAs<ReferenceType>()) {
4408 type = refType->getPointeeType();
4409 } else {
4410 return type->isDependentType();
4411 }
4412 if (!type.getQualifiers().empty())
4413 return false;
4414 return isValidSwiftContextType(type);
4415}
4416
4417static void handleParameterABIAttr(Sema &S, Decl *D, const AttributeList &Attrs,
4418 ParameterABI Abi) {
4419 S.AddParameterABIAttr(Attrs.getRange(), D, Abi,
4420 Attrs.getAttributeSpellingListIndex());
4421}
4422
4423void Sema::AddParameterABIAttr(SourceRange range, Decl *D, ParameterABI abi,
4424 unsigned spellingIndex) {
4425
4426 QualType type = cast<ParmVarDecl>(D)->getType();
4427
4428 if (auto existingAttr = D->getAttr<ParameterABIAttr>()) {
4429 if (existingAttr->getABI() != abi) {
4430 Diag(range.getBegin(), diag::err_attributes_are_not_compatible)
4431 << getParameterABISpelling(abi) << existingAttr;
4432 Diag(existingAttr->getLocation(), diag::note_conflicting_attribute);
4433 return;
4434 }
4435 }
4436
4437 switch (abi) {
4438 case ParameterABI::Ordinary:
4439 llvm_unreachable("explicit attribute for ordinary parameter ABI?")::llvm::llvm_unreachable_internal("explicit attribute for ordinary parameter ABI?"
, "/build/llvm-toolchain-snapshot-6.0~svn318882/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 4439)
;
4440
4441 case ParameterABI::SwiftContext:
4442 if (!isValidSwiftContextType(type)) {
4443 Diag(range.getBegin(), diag::err_swift_abi_parameter_wrong_type)
4444 << getParameterABISpelling(abi)
4445 << /*pointer to pointer */ 0 << type;
4446 }
4447 D->addAttr(::new (Context)
4448 SwiftContextAttr(range, Context, spellingIndex));
4449 return;
4450
4451 case ParameterABI::SwiftErrorResult:
4452 if (!isValidSwiftErrorResultType(type)) {
4453 Diag(range.getBegin(), diag::err_swift_abi_parameter_wrong_type)
4454 << getParameterABISpelling(abi)
4455 << /*pointer to pointer */ 1 << type;
4456 }
4457 D->addAttr(::new (Context)
4458 SwiftErrorResultAttr(range, Context, spellingIndex));
4459 return;
4460
4461 case ParameterABI::SwiftIndirectResult:
4462 if (!isValidSwiftIndirectResultType(type)) {
4463 Diag(range.getBegin(), diag::err_swift_abi_parameter_wrong_type)
4464 << getParameterABISpelling(abi)
4465 << /*pointer*/ 0 << type;
4466 }
4467 D->addAttr(::new (Context)
4468 SwiftIndirectResultAttr(range, Context, spellingIndex));
4469 return;
4470 }
4471 llvm_unreachable("bad parameter ABI attribute")::llvm::llvm_unreachable_internal("bad parameter ABI attribute"
, "/build/llvm-toolchain-snapshot-6.0~svn318882/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 4471)
;
4472}
4473
4474/// Checks a regparm attribute, returning true if it is ill-formed and
4475/// otherwise setting numParams to the appropriate value.
4476bool Sema::CheckRegparmAttr(const AttributeList &Attr, unsigned &numParams) {
4477 if (Attr.isInvalid())
4478 return true;
4479
4480 if (!checkAttributeNumArgs(*this, Attr, 1)) {
4481 Attr.setInvalid();
4482 return true;
4483 }
4484
4485 uint32_t NP;
4486 Expr *NumParamsExpr = Attr.getArgAsExpr(0);
4487 if (!checkUInt32Argument(*this, Attr, NumParamsExpr, NP)) {
4488 Attr.setInvalid();
4489 return true;
4490 }
4491
4492 if (Context.getTargetInfo().getRegParmMax() == 0) {
4493 Diag(Attr.getLoc(), diag::err_attribute_regparm_wrong_platform)
4494 << NumParamsExpr->getSourceRange();
4495 Attr.setInvalid();
4496 return true;
4497 }
4498
4499 numParams = NP;
4500 if (numParams > Context.getTargetInfo().getRegParmMax()) {
4501 Diag(Attr.getLoc(), diag::err_attribute_regparm_invalid_number)
4502 << Context.getTargetInfo().getRegParmMax() << NumParamsExpr->getSourceRange();
4503 Attr.setInvalid();
4504 return true;
4505 }
4506
4507 return false;
4508}
4509
4510// Checks whether an argument of launch_bounds attribute is
4511// acceptable, performs implicit conversion to Rvalue, and returns
4512// non-nullptr Expr result on success. Otherwise, it returns nullptr
4513// and may output an error.
4514static Expr *makeLaunchBoundsArgExpr(Sema &S, Expr *E,
4515 const CUDALaunchBoundsAttr &Attr,
4516 const unsigned Idx) {
4517 if (S.DiagnoseUnexpandedParameterPack(E))
4518 return nullptr;
4519
4520 // Accept template arguments for now as they depend on something else.
4521 // We'll get to check them when they eventually get instantiated.
4522 if (E->isValueDependent())
4523 return E;
4524
4525 llvm::APSInt I(64);
4526 if (!E->isIntegerConstantExpr(I, S.Context)) {
4527 S.Diag(E->getExprLoc(), diag::err_attribute_argument_n_type)
4528 << &Attr << Idx << AANT_ArgumentIntegerConstant << E->getSourceRange();
4529 return nullptr;
4530 }
4531 // Make sure we can fit it in 32 bits.
4532 if (!I.isIntN(32)) {
4533 S.Diag(E->getExprLoc(), diag::err_ice_too_large) << I.toString(10, false)
4534 << 32 << /* Unsigned */ 1;
4535 return nullptr;
4536 }
4537 if (I < 0)
4538 S.Diag(E->getExprLoc(), diag::warn_attribute_argument_n_negative)
4539 << &Attr << Idx << E->getSourceRange();
4540
4541 // We may need to perform implicit conversion of the argument.
4542 InitializedEntity Entity = InitializedEntity::InitializeParameter(
4543 S.Context, S.Context.getConstType(S.Context.IntTy), /*consume*/ false);
4544 ExprResult ValArg = S.PerformCopyInitialization(Entity, SourceLocation(), E);
4545 assert(!ValArg.isInvalid() &&(static_cast <bool> (!ValArg.isInvalid() && "Unexpected PerformCopyInitialization() failure."
) ? void (0) : __assert_fail ("!ValArg.isInvalid() && \"Unexpected PerformCopyInitialization() failure.\""
, "/build/llvm-toolchain-snapshot-6.0~svn318882/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 4546, __extension__ __PRETTY_FUNCTION__))
4546 "Unexpected PerformCopyInitialization() failure.")(static_cast <bool> (!ValArg.isInvalid() && "Unexpected PerformCopyInitialization() failure."
) ? void (0) : __assert_fail ("!ValArg.isInvalid() && \"Unexpected PerformCopyInitialization() failure.\""
, "/build/llvm-toolchain-snapshot-6.0~svn318882/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 4546, __extension__ __PRETTY_FUNCTION__))
;
4547
4548 return ValArg.getAs<Expr>();
4549}
4550
4551void Sema::AddLaunchBoundsAttr(SourceRange AttrRange, Decl *D, Expr *MaxThreads,
4552 Expr *MinBlocks, unsigned SpellingListIndex) {
4553 CUDALaunchBoundsAttr TmpAttr(AttrRange, Context, MaxThreads, MinBlocks,
4554 SpellingListIndex);
4555 MaxThreads = makeLaunchBoundsArgExpr(*this, MaxThreads, TmpAttr, 0);
4556 if (MaxThreads == nullptr)
4557 return;
4558
4559 if (MinBlocks) {
4560 MinBlocks = makeLaunchBoundsArgExpr(*this, MinBlocks, TmpAttr, 1);
4561 if (MinBlocks == nullptr)
4562 return;
4563 }
4564
4565 D->addAttr(::new (Context) CUDALaunchBoundsAttr(
4566 AttrRange, Context, MaxThreads, MinBlocks, SpellingListIndex));
4567}
4568
4569static void handleLaunchBoundsAttr(Sema &S, Decl *D,
4570 const AttributeList &Attr) {
4571 if (!checkAttributeAtLeastNumArgs(S, Attr, 1) ||
4572 !checkAttributeAtMostNumArgs(S, Attr, 2))
4573 return;
4574
4575 S.AddLaunchBoundsAttr(Attr.getRange(), D, Attr.getArgAsExpr(0),
4576 Attr.getNumArgs() > 1 ? Attr.getArgAsExpr(1) : nullptr,
4577 Attr.getAttributeSpellingListIndex());
4578}
4579
4580static void handleArgumentWithTypeTagAttr(Sema &S, Decl *D,
4581 const AttributeList &Attr) {
4582 if (!Attr.isArgIdent(0)) {
4583 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_type)
4584 << Attr.getName() << /* arg num = */ 1 << AANT_ArgumentIdentifier;
4585 return;
4586 }
4587
4588 if (!checkAttributeNumArgs(S, Attr, 3))
4589 return;
4590
4591 IdentifierInfo *ArgumentKind = Attr.getArgAsIdent(0)->Ident;
4592
4593 if (!isFunctionOrMethod(D) || !hasFunctionProto(D)) {
4594 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type)
4595 << Attr.getName() << ExpectedFunctionOrMethod;
4596 return;
4597 }
4598
4599 uint64_t ArgumentIdx;
4600 if (!checkFunctionOrMethodParameterIndex(S, D, Attr, 2, Attr.getArgAsExpr(1),
4601 ArgumentIdx))
4602 return;
4603
4604 uint64_t TypeTagIdx;
4605 if (!checkFunctionOrMethodParameterIndex(S, D, Attr, 3, Attr.getArgAsExpr(2),
4606 TypeTagIdx))
4607 return;
4608
4609 bool IsPointer = (Attr.getName()->getName() == "pointer_with_type_tag");
4610 if (IsPointer) {
4611 // Ensure that buffer has a pointer type.
4612 QualType BufferTy = getFunctionOrMethodParamType(D, ArgumentIdx);
4613 if (!BufferTy->isPointerType()) {
4614 S.Diag(Attr.getLoc(), diag::err_attribute_pointers_only)
4615 << Attr.getName() << 0;
4616 }
4617 }
4618
4619 D->addAttr(::new (S.Context)
4620 ArgumentWithTypeTagAttr(Attr.getRange(), S.Context, ArgumentKind,
4621 ArgumentIdx, TypeTagIdx, IsPointer,
4622 Attr.getAttributeSpellingListIndex()));
4623}
4624
4625static void handleTypeTagForDatatypeAttr(Sema &S, Decl *D,
4626 const AttributeList &Attr) {
4627 if (!Attr.isArgIdent(0)) {
4628 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_type)
4629 << Attr.getName() << 1 << AANT_ArgumentIdentifier;
4630 return;
4631 }
4632
4633 if (!checkAttributeNumArgs(S, Attr, 1))
4634 return;
4635
4636 if (!isa<VarDecl>(D)) {
4637 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_decl_type)
4638 << Attr.getName() << ExpectedVariable;
4639 return;
4640 }
4641
4642 IdentifierInfo *PointerKind = Attr.getArgAsIdent(0)->Ident;
4643 TypeSourceInfo *MatchingCTypeLoc = nullptr;
4644 S.GetTypeFromParser(Attr.getMatchingCType(), &MatchingCTypeLoc);
4645 assert(MatchingCTypeLoc && "no type source info for attribute argument")(static_cast <bool> (MatchingCTypeLoc && "no type source info for attribute argument"
) ? void (0) : __assert_fail ("MatchingCTypeLoc && \"no type source info for attribute argument\""
, "/build/llvm-toolchain-snapshot-6.0~svn318882/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 4645, __extension__ __PRETTY_FUNCTION__))
;
4646
4647 D->addAttr(::new (S.Context)
4648 TypeTagForDatatypeAttr(Attr.getRange(), S.Context, PointerKind,
4649 MatchingCTypeLoc,
4650 Attr.getLayoutCompatible(),
4651 Attr.getMustBeNull(),
4652 Attr.getAttributeSpellingListIndex()));
4653}
4654
4655static void handleXRayLogArgsAttr(Sema &S, Decl *D,
4656 const AttributeList &Attr) {
4657 uint64_t ArgCount;
4658
4659 if (!checkFunctionOrMethodParameterIndex(S, D, Attr, 1, Attr.getArgAsExpr(0),
4660 ArgCount,
4661 true /* AllowImplicitThis*/))
4662 return;
4663
4664 // ArgCount isn't a parameter index [0;n), it's a count [1;n] - hence + 1.
4665 D->addAttr(::new (S.Context)
4666 XRayLogArgsAttr(Attr.getRange(), S.Context, ++ArgCount,
4667 Attr.getAttributeSpellingListIndex()));
4668}
4669
4670//===----------------------------------------------------------------------===//
4671// Checker-specific attribute handlers.
4672//===----------------------------------------------------------------------===//
4673
4674static bool isValidSubjectOfNSReturnsRetainedAttribute(QualType type) {
4675 return type->isDependentType() ||
4676 type->isObjCRetainableType();
4677}
4678
4679static bool isValidSubjectOfNSAttribute(Sema &S, QualType type) {
4680 return type->isDependentType() ||
4681 type->isObjCObjectPointerType() ||
4682 S.Context.isObjCNSObjectType(type);
4683}
4684
4685static bool isValidSubjectOfCFAttribute(Sema &S, QualType type) {
4686 return type->isDependentType() ||
4687 type->isPointerType() ||
4688 isValidSubjectOfNSAttribute(S, type);
4689}
4690
4691static void handleNSConsumedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
4692 S.AddNSConsumedAttr(Attr.getRange(), D, Attr.getAttributeSpellingListIndex(),
4693 Attr.getKind() == AttributeList::AT_NSConsumed,
4694 /*template instantiation*/ false);
4695}
4696
4697void Sema::AddNSConsumedAttr(SourceRange attrRange, Decl *D,
4698 unsigned spellingIndex, bool isNSConsumed,
4699 bool isTemplateInstantiation) {
4700 ParmVarDecl *param = cast<ParmVarDecl>(D);
4701 bool typeOK;
4702
4703 if (isNSConsumed) {
4704 typeOK = isValidSubjectOfNSAttribute(*this, param->getType());
4705 } else {
4706 typeOK = isValidSubjectOfCFAttribute(*this, param->getType());
4707 }
4708
4709 if (!typeOK) {
4710 // These attributes are normally just advisory, but in ARC, ns_consumed
4711 // is significant. Allow non-dependent code to contain inappropriate
4712 // attributes even in ARC, but require template instantiations to be
4713 // set up correctly.
4714 Diag(D->getLocStart(),
4715 (isTemplateInstantiation && isNSConsumed &&
4716 getLangOpts().ObjCAutoRefCount
4717 ? diag::err_ns_attribute_wrong_parameter_type
4718 : diag::warn_ns_attribute_wrong_parameter_type))
4719 << attrRange
4720 << (isNSConsumed ? "ns_consumed" : "cf_consumed")
4721 << (isNSConsumed ? /*objc pointers*/ 0 : /*cf pointers*/ 1);
4722 return;
4723 }
4724
4725 if (isNSConsumed)
4726 param->addAttr(::new (Context)
4727 NSConsumedAttr(attrRange, Context, spellingIndex));
4728 else
4729 param->addAttr(::new (Context)
4730 CFConsumedAttr(attrRange, Context, spellingIndex));
4731}
4732
4733bool Sema::checkNSReturnsRetainedReturnType(SourceLocation loc,
4734 QualType type) {
4735 if (isValidSubjectOfNSReturnsRetainedAttribute(type))
4736 return false;
4737
4738 Diag(loc, diag::warn_ns_attribute_wrong_return_type)
4739 << "'ns_returns_retained'" << 0 << 0;
4740 return true;
4741}
4742
4743static void handleNSReturnsRetainedAttr(Sema &S, Decl *D,
4744 const AttributeList &Attr) {
4745 QualType returnType;
4746
4747 if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
4748 returnType = MD->getReturnType();
4749 else if (S.getLangOpts().ObjCAutoRefCount && hasDeclarator(D) &&
4750 (Attr.getKind() == AttributeList::AT_NSReturnsRetained))
4751 return; // ignore: was handled as a type attribute
4752 else if (ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(D))
4753 returnType = PD->getType();
4754 else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
4755 returnType = FD->getReturnType();
4756 else if (auto *Param = dyn_cast<ParmVarDecl>(D)) {
4757 returnType = Param->getType()->getPointeeType();
4758 if (returnType.isNull()) {
4759 S.Diag(D->getLocStart(), diag::warn_ns_attribute_wrong_parameter_type)
4760 << Attr.getName() << /*pointer-to-CF*/2
4761 << Attr.getRange();
4762 return;
4763 }
4764 } else if (Attr.isUsedAsTypeAttr()) {
4765 return;
4766 } else {
4767 AttributeDeclKind ExpectedDeclKind;
4768 switch (Attr.getKind()) {
4769 default: llvm_unreachable("invalid ownership attribute")::llvm::llvm_unreachable_internal("invalid ownership attribute"
, "/build/llvm-toolchain-snapshot-6.0~svn318882/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 4769)
;
4770 case AttributeList::AT_NSReturnsRetained:
4771 case AttributeList::AT_NSReturnsAutoreleased:
4772 case AttributeList::AT_NSReturnsNotRetained:
4773 ExpectedDeclKind = ExpectedFunctionOrMethod;
4774 break;
4775
4776 case AttributeList::AT_CFReturnsRetained:
4777 case AttributeList::AT_CFReturnsNotRetained:
4778 ExpectedDeclKind = ExpectedFunctionMethodOrParameter;
4779 break;
4780 }
4781 S.Diag(D->getLocStart(), diag::warn_attribute_wrong_decl_type)
4782 << Attr.getRange() << Attr.getName() << ExpectedDeclKind;
4783 return;
4784 }
4785
4786 bool typeOK;
4787 bool cf;
4788 switch (Attr.getKind()) {
4789 default: llvm_unreachable("invalid ownership attribute")::llvm::llvm_unreachable_internal("invalid ownership attribute"
, "/build/llvm-toolchain-snapshot-6.0~svn318882/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 4789)
;
4790 case AttributeList::AT_NSReturnsRetained:
4791 typeOK = isValidSubjectOfNSReturnsRetainedAttribute(returnType);
4792 cf = false;
4793 break;
4794
4795 case AttributeList::AT_NSReturnsAutoreleased:
4796 case AttributeList::AT_NSReturnsNotRetained:
4797 typeOK = isValidSubjectOfNSAttribute(S, returnType);
4798 cf = false;
4799 break;
4800
4801 case AttributeList::AT_CFReturnsRetained:
4802 case AttributeList::AT_CFReturnsNotRetained:
4803 typeOK = isValidSubjectOfCFAttribute(S, returnType);
4804 cf = true;
4805 break;
4806 }
4807
4808 if (!typeOK) {
4809 if (Attr.isUsedAsTypeAttr())
4810 return;
4811
4812 if (isa<ParmVarDecl>(D)) {
4813 S.Diag(D->getLocStart(), diag::warn_ns_attribute_wrong_parameter_type)
4814 << Attr.getName() << /*pointer-to-CF*/2
4815 << Attr.getRange();
4816 } else {
4817 // Needs to be kept in sync with warn_ns_attribute_wrong_return_type.
4818 enum : unsigned {
4819 Function,
4820 Method,
4821 Property
4822 } SubjectKind = Function;
4823 if (isa<ObjCMethodDecl>(D))
4824 SubjectKind = Method;
4825 else if (isa<ObjCPropertyDecl>(D))
4826 SubjectKind = Property;
4827 S.Diag(D->getLocStart(), diag::warn_ns_attribute_wrong_return_type)
4828 << Attr.getName() << SubjectKind << cf
4829 << Attr.getRange();
4830 }
4831 return;
4832 }
4833
4834 switch (Attr.getKind()) {
4835 default:
4836 llvm_unreachable("invalid ownership attribute")::llvm::llvm_unreachable_internal("invalid ownership attribute"
, "/build/llvm-toolchain-snapshot-6.0~svn318882/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 4836)
;
4837 case AttributeList::AT_NSReturnsAutoreleased:
4838 D->addAttr(::new (S.Context) NSReturnsAutoreleasedAttr(
4839 Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
4840 return;
4841 case AttributeList::AT_CFReturnsNotRetained:
4842 D->addAttr(::new (S.Context) CFReturnsNotRetainedAttr(
4843 Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
4844 return;
4845 case AttributeList::AT_NSReturnsNotRetained:
4846 D->addAttr(::new (S.Context) NSReturnsNotRetainedAttr(
4847 Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
4848 return;
4849 case AttributeList::AT_CFReturnsRetained:
4850 D->addAttr(::new (S.Context) CFReturnsRetainedAttr(
4851 Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
4852 return;
4853 case AttributeList::AT_NSReturnsRetained:
4854 D->addAttr(::new (S.Context) NSReturnsRetainedAttr(
4855 Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
4856 return;
4857 };
4858}
4859
4860static void handleObjCReturnsInnerPointerAttr(Sema &S, Decl *D,
4861 const AttributeList &Attrs) {
4862 const int EP_ObjCMethod = 1;
4863 const int EP_ObjCProperty = 2;
4864
4865 SourceLocation loc = Attrs.getLoc();
4866 QualType resultType;
4867 if (isa<ObjCMethodDecl>(D))
4868 resultType = cast<ObjCMethodDecl>(D)->getReturnType();
4869 else
4870 resultType = cast<ObjCPropertyDecl>(D)->getType();
4871
4872 if (!resultType->isReferenceType() &&
4873 (!resultType->isPointerType() || resultType->isObjCRetainableType())) {
4874 S.Diag(D->getLocStart(), diag::warn_ns_attribute_wrong_return_type)
4875 << SourceRange(loc)
4876 << Attrs.getName()
4877 << (isa<ObjCMethodDecl>(D) ? EP_ObjCMethod : EP_ObjCProperty)
4878 << /*non-retainable pointer*/ 2;
4879
4880 // Drop the attribute.
4881 return;
4882 }
4883
4884 D->addAttr(::new (S.Context) ObjCReturnsInnerPointerAttr(
4885 Attrs.getRange(), S.Context, Attrs.getAttributeSpellingListIndex()));
4886}
4887
4888static void handleObjCRequiresSuperAttr(Sema &S, Decl *D,
4889 const AttributeList &Attrs) {
4890 ObjCMethodDecl *method = cast<ObjCMethodDecl>(D);
4891
4892 DeclContext *DC = method->getDeclContext();
4893 if (const ObjCProtocolDecl *PDecl = dyn_cast_or_null<ObjCProtocolDecl>(DC)) {
4894 S.Diag(D->getLocStart(), diag::warn_objc_requires_super_protocol)
4895 << Attrs.getName() << 0;
4896 S.Diag(PDecl->getLocation(), diag::note_protocol_decl);
4897 return;
4898 }
4899 if (method->getMethodFamily() == OMF_dealloc) {
4900 S.Diag(D->getLocStart(), diag::warn_objc_requires_super_protocol)
4901 << Attrs.getName() << 1;
4902 return;
4903 }
4904
4905 method->addAttr(::new (S.Context)
4906 ObjCRequiresSuperAttr(Attrs.getRange(), S.Context,
4907 Attrs.getAttributeSpellingListIndex()));
4908}
4909
4910static void handleCFAuditedTransferAttr(Sema &S, Decl *D,
4911 const AttributeList &Attr) {
4912 if (checkAttrMutualExclusion<CFUnknownTransferAttr>(S, D, Attr.getRange(),
4913 Attr.getName()))
4914 return;
4915
4916 D->addAttr(::new (S.Context)
4917 CFAuditedTransferAttr(Attr.getRange(), S.Context,
4918 Attr.getAttributeSpellingListIndex()));
4919}
4920
4921static void handleCFUnknownTransferAttr(Sema &S, Decl *D,
4922 const AttributeList &Attr) {
4923 if (checkAttrMutualExclusion<CFAuditedTransferAttr>(S, D, Attr.getRange(),
4924 Attr.getName()))
4925 return;
4926
4927 D->addAttr(::new (S.Context)
4928 CFUnknownTransferAttr(Attr.getRange(), S.Context,
4929 Attr.getAttributeSpellingListIndex()));
4930}
4931
4932static void handleObjCBridgeAttr(Sema &S, Scope *Sc, Decl *D,
4933 const AttributeList &Attr) {
4934 IdentifierLoc * Parm = Attr.isArgIdent(0) ? Attr.getArgAsIdent(0) : nullptr;
4935
4936 if (!Parm) {
4937 S.Diag(D->getLocStart(), diag::err_objc_attr_not_id) << Attr.getName() << 0;
4938 return;
4939 }
4940
4941 // Typedefs only allow objc_bridge(id) and have some additional checking.
4942 if (auto TD = dyn_cast<TypedefNameDecl>(D)) {
4943 if (!Parm->Ident->isStr("id")) {
4944 S.Diag(Attr.getLoc(), diag::err_objc_attr_typedef_not_id)
4945 << Attr.getName();
4946 return;
4947 }
4948
4949 // Only allow 'cv void *'.
4950 QualType T = TD->getUnderlyingType();
4951 if (!T->isVoidPointerType()) {
4952 S.Diag(Attr.getLoc(), diag::err_objc_attr_typedef_not_void_pointer);
4953 return;
4954 }
4955 }
4956
4957 D->addAttr(::new (S.Context)
4958 ObjCBridgeAttr(Attr.getRange(), S.Context, Parm->Ident,
4959 Attr.getAttributeSpellingListIndex()));
4960}
4961
4962static void handleObjCBridgeMutableAttr(Sema &S, Scope *Sc, Decl *D,
4963 const AttributeList &Attr) {
4964 IdentifierLoc * Parm = Attr.isArgIdent(0) ? Attr.getArgAsIdent(0) : nullptr;
4965
4966 if (!Parm) {
4967 S.Diag(D->getLocStart(), diag::err_objc_attr_not_id) << Attr.getName() << 0;
4968 return;
4969 }
4970
4971 D->addAttr(::new (S.Context)
4972 ObjCBridgeMutableAttr(Attr.getRange(), S.Context, Parm->Ident,
4973 Attr.getAttributeSpellingListIndex()));
4974}
4975
4976static void handleObjCBridgeRelatedAttr(Sema &S, Scope *Sc, Decl *D,
4977 const AttributeList &Attr) {
4978 IdentifierInfo *RelatedClass =
4979 Attr.isArgIdent(0) ? Attr.getArgAsIdent(0)->Ident : nullptr;
4980 if (!RelatedClass) {
4981 S.Diag(D->getLocStart(), diag::err_objc_attr_not_id) << Attr.getName() << 0;
4982 return;
4983 }
4984 IdentifierInfo *ClassMethod =
4985 Attr.getArgAsIdent(1) ? Attr.getArgAsIdent(1)->Ident : nullptr;
4986 IdentifierInfo *InstanceMethod =
4987 Attr.getArgAsIdent(2) ? Attr.getArgAsIdent(2)->Ident : nullptr;
4988 D->addAttr(::new (S.Context)
4989 ObjCBridgeRelatedAttr(Attr.getRange(), S.Context, RelatedClass,
4990 ClassMethod, InstanceMethod,
4991 Attr.getAttributeSpellingListIndex()));
4992}
4993
4994static void handleObjCDesignatedInitializer(Sema &S, Decl *D,
4995 const AttributeList &Attr) {
4996 ObjCInterfaceDecl *IFace;
4997 if (ObjCCategoryDecl *CatDecl =
4998 dyn_cast<ObjCCategoryDecl>(D->getDeclContext()))
4999 IFace = CatDecl->getClassInterface();
5000 else
5001 IFace = cast<ObjCInterfaceDecl>(D->getDeclContext());
5002
5003 if (!IFace)
5004 return;
5005
5006 IFace->setHasDesignatedInitializers();
5007 D->addAttr(::new (S.Context)
5008 ObjCDesignatedInitializerAttr(Attr.getRange(), S.Context,
5009 Attr.getAttributeSpellingListIndex()));
5010}
5011
5012static void handleObjCRuntimeName(Sema &S, Decl *D,
5013 const AttributeList &Attr) {
5014 StringRef MetaDataName;
5015 if (!S.checkStringLiteralArgumentAttr(Attr, 0, MetaDataName))
5016 return;
5017 D->addAttr(::new (S.Context)
5018 ObjCRuntimeNameAttr(Attr.getRange(), S.Context,
5019 MetaDataName,
5020 Attr.getAttributeSpellingListIndex()));
5021}
5022
5023// When a user wants to use objc_boxable with a union or struct
5024// but they don't have access to the declaration (legacy/third-party code)
5025// then they can 'enable' this feature with a typedef:
5026// typedef struct __attribute((objc_boxable)) legacy_struct legacy_struct;
5027static void handleObjCBoxable(Sema &S, Decl *D, const AttributeList &Attr) {
5028 bool notify = false;
5029
5030 RecordDecl *RD = dyn_cast<RecordDecl>(D);
5031 if (RD && RD->getDefinition()) {
5032 RD = RD->getDefinition();
5033 notify = true;
5034 }
5035
5036 if (RD) {
5037 ObjCBoxableAttr *BoxableAttr = ::new (S.Context)
5038 ObjCBoxableAttr(Attr.getRange(), S.Context,
5039 Attr.getAttributeSpellingListIndex());
5040 RD->addAttr(BoxableAttr);
5041 if (notify) {
5042 // we need to notify ASTReader/ASTWriter about
5043 // modification of existing declaration
5044 if (ASTMutationListener *L = S.getASTMutationListener())
5045 L->AddedAttributeToRecord(BoxableAttr, RD);
5046 }
5047 }
5048}
5049
5050static void handleObjCOwnershipAttr(Sema &S, Decl *D,
5051 const AttributeList &Attr) {
5052 if (hasDeclarator(D)) return;
5053
5054 S.Diag(D->getLocStart(), diag::err_attribute_wrong_decl_type)
5055 << Attr.getRange() << Attr.getName() << ExpectedVariable;
5056}
5057
5058static void handleObjCPreciseLifetimeAttr(Sema &S, Decl *D,
5059 const AttributeList &Attr) {
5060 ValueDecl *vd = cast<ValueDecl>(D);
5061 QualType type = vd->getType();
5062
5063 if (!type->isDependentType() &&
5064 !type->isObjCLifetimeType()) {
5065 S.Diag(Attr.getLoc(), diag::err_objc_precise_lifetime_bad_type)
5066 << type;
5067 return;
5068 }
5069
5070 Qualifiers::ObjCLifetime lifetime = type.getObjCLifetime();
5071
5072 // If we have no lifetime yet, check the lifetime we're presumably
5073 // going to infer.
5074 if (lifetime == Qualifiers::OCL_None && !type->isDependentType())
5075 lifetime = type->getObjCARCImplicitLifetime();
5076
5077 switch (lifetime) {
5078 case Qualifiers::OCL_None:
5079 assert(type->isDependentType() &&(static_cast <bool> (type->isDependentType() &&
"didn't infer lifetime for non-dependent type?") ? void (0) :
__assert_fail ("type->isDependentType() && \"didn't infer lifetime for non-dependent type?\""
, "/build/llvm-toolchain-snapshot-6.0~svn318882/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 5080, __extension__ __PRETTY_FUNCTION__))
5080 "didn't infer lifetime for non-dependent type?")(static_cast <bool> (type->isDependentType() &&
"didn't infer lifetime for non-dependent type?") ? void (0) :
__assert_fail ("type->isDependentType() && \"didn't infer lifetime for non-dependent type?\""
, "/build/llvm-toolchain-snapshot-6.0~svn318882/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 5080, __extension__ __PRETTY_FUNCTION__))
;
5081 break;
5082
5083 case Qualifiers::OCL_Weak: // meaningful
5084 case Qualifiers::OCL_Strong: // meaningful
5085 break;
5086
5087 case Qualifiers::OCL_ExplicitNone:
5088 case Qualifiers::OCL_Autoreleasing:
5089 S.Diag(Attr.getLoc(), diag::warn_objc_precise_lifetime_meaningless)
5090 << (lifetime == Qualifiers::OCL_Autoreleasing);
5091 break;
5092 }
5093
5094 D->addAttr(::new (S.Context)
5095 ObjCPreciseLifetimeAttr(Attr.getRange(), S.Context,
5096 Attr.getAttributeSpellingListIndex()));
5097}
5098
5099//===----------------------------------------------------------------------===//
5100// Microsoft specific attribute handlers.
5101//===----------------------------------------------------------------------===//
5102
5103UuidAttr *Sema::mergeUuidAttr(Decl *D, SourceRange Range,
5104 unsigned AttrSpellingListIndex, StringRef Uuid) {
5105 if (const auto *UA = D->getAttr<UuidAttr>()) {
5106 if (UA->getGuid().equals_lower(Uuid))
5107 return nullptr;
5108 Diag(UA->getLocation(), diag::err_mismatched_uuid);
5109 Diag(Range.getBegin(), diag::note_previous_uuid);
5110 D->dropAttr<UuidAttr>();
5111 }
5112
5113 return ::new (Context) UuidAttr(Range, Context, Uuid, AttrSpellingListIndex);
5114}
5115
5116static void handleUuidAttr(Sema &S, Decl *D, const AttributeList &Attr) {
5117 if (!S.LangOpts.CPlusPlus) {
5118 S.Diag(Attr.getLoc(), diag::err_attribute_not_supported_in_lang)
5119 << Attr.getName() << AttributeLangSupport::C;
5120 return;
5121 }
5122
5123 StringRef StrRef;
5124 SourceLocation LiteralLoc;
5125 if (!S.checkStringLiteralArgumentAttr(Attr, 0, StrRef, &LiteralLoc))
5126 return;
5127
5128 // GUID format is "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX" or
5129 // "{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}", normalize to the former.
5130 if (StrRef.size() == 38 && StrRef.front() == '{' && StrRef.back() == '}')
5131 StrRef = StrRef.drop_front().drop_back();
5132
5133 // Validate GUID length.
5134 if (StrRef.size() != 36) {
5135 S.Diag(LiteralLoc, diag::err_attribute_uuid_malformed_guid);
5136 return;
5137 }
5138
5139 for (unsigned i = 0; i < 36; ++i) {
5140 if (i == 8 || i == 13 || i == 18 || i == 23) {
5141 if (StrRef[i] != '-') {
5142 S.Diag(LiteralLoc, diag::err_attribute_uuid_malformed_guid);
5143 return;
5144 }
5145 } else if (!isHexDigit(StrRef[i])) {
5146 S.Diag(LiteralLoc, diag::err_attribute_uuid_malformed_guid);
5147 return;
5148 }
5149 }
5150
5151 // FIXME: It'd be nice to also emit a fixit removing uuid(...) (and, if it's
5152 // the only thing in the [] list, the [] too), and add an insertion of
5153 // __declspec(uuid(...)). But sadly, neither the SourceLocs of the commas
5154 // separating attributes nor of the [ and the ] are in the AST.
5155 // Cf "SourceLocations of attribute list delimiters - [[ ... , ... ]] etc"
5156 // on cfe-dev.
5157 if (Attr.isMicrosoftAttribute()) // Check for [uuid(...)] spelling.
5158 S.Diag(Attr.getLoc(), diag::warn_atl_uuid_deprecated);
5159
5160 UuidAttr *UA = S.mergeUuidAttr(D, Attr.getRange(),
5161 Attr.getAttributeSpellingListIndex(), StrRef);
5162 if (UA)
5163 D->addAttr(UA);
5164}
5165
5166static void handleMSInheritanceAttr(Sema &S, Decl *D, const AttributeList &Attr) {
5167 if (!S.LangOpts.CPlusPlus) {
5168 S.Diag(Attr.getLoc(), diag::err_attribute_not_supported_in_lang)
5169 << Attr.getName() << AttributeLangSupport::C;
5170 return;
5171 }
5172 MSInheritanceAttr *IA = S.mergeMSInheritanceAttr(
5173 D, Attr.getRange(), /*BestCase=*/true,
5174 Attr.getAttributeSpellingListIndex(),
5175 (MSInheritanceAttr::Spelling)Attr.getSemanticSpelling());
5176 if (IA) {
5177 D->addAttr(IA);
5178 S.Consumer.AssignInheritanceModel(cast<CXXRecordDecl>(D));
5179 }
5180}
5181
5182static void handleDeclspecThreadAttr(Sema &S, Decl *D,
5183 const AttributeList &Attr) {
5184 VarDecl *VD = cast<VarDecl>(D);
5185 if (!S.Context.getTargetInfo().isTLSSupported()) {
5186 S.Diag(Attr.getLoc(), diag::err_thread_unsupported);
5187 return;
5188 }
5189 if (VD->getTSCSpec() != TSCS_unspecified) {
5190 S.Diag(Attr.getLoc(), diag::err_declspec_thread_on_thread_variable);
5191 return;
5192 }
5193 if (VD->hasLocalStorage()) {
5194 S.Diag(Attr.getLoc(), diag::err_thread_non_global) << "__declspec(thread)";
5195 return;
5196 }
5197 VD->addAttr(::new (S.Context) ThreadAttr(
5198 Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
5199}
5200
5201static void handleAbiTagAttr(Sema &S, Decl *D, const AttributeList &Attr) {
5202 SmallVector<StringRef, 4> Tags;
5203 for (unsigned I = 0, E = Attr.getNumArgs(); I != E; ++I) {
5204 StringRef Tag;
5205 if (!S.checkStringLiteralArgumentAttr(Attr, I, Tag))
5206 return;
5207 Tags.push_back(Tag);
5208 }
5209
5210 if (const auto *NS = dyn_cast<NamespaceDecl>(D)) {
5211 if (!NS->isInline()) {
5212 S.Diag(Attr.getLoc(), diag::warn_attr_abi_tag_namespace) << 0;
5213 return;
5214 }
5215 if (NS->isAnonymousNamespace()) {
5216 S.Diag(Attr.getLoc(), diag::warn_attr_abi_tag_namespace) << 1;
5217 return;
5218 }
5219 if (Attr.getNumArgs() == 0)
5220 Tags.push_back(NS->getName());
5221 } else if (!checkAttributeAtLeastNumArgs(S, Attr, 1))
5222 return;
5223
5224 // Store tags sorted and without duplicates.
5225 std::sort(Tags.begin(), Tags.end());
5226 Tags.erase(std::unique(Tags.begin(), Tags.end()), Tags.end());
5227
5228 D->addAttr(::new (S.Context)
5229 AbiTagAttr(Attr.getRange(), S.Context, Tags.data(), Tags.size(),
5230 Attr.getAttributeSpellingListIndex()));
5231}
5232
5233static void handleARMInterruptAttr(Sema &S, Decl *D,
5234 const AttributeList &Attr) {
5235 // Check the attribute arguments.
5236 if (Attr.getNumArgs() > 1) {
5237 S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments)
5238 << Attr.getName() << 1;
5239 return;
5240 }
5241
5242 StringRef Str;
5243 SourceLocation ArgLoc;
5244
5245 if (Attr.getNumArgs() == 0)
5246 Str = "";
5247 else if (!S.checkStringLiteralArgumentAttr(Attr, 0, Str, &ArgLoc))
5248 return;
5249
5250 ARMInterruptAttr::InterruptType Kind;
5251 if (!ARMInterruptAttr::ConvertStrToInterruptType(Str, Kind)) {
5252 S.Diag(Attr.getLoc(), diag::warn_attribute_type_not_supported)
5253 << Attr.getName() << Str << ArgLoc;
5254 return;
5255 }
5256
5257 unsigned Index = Attr.getAttributeSpellingListIndex();
5258 D->addAttr(::new (S.Context)
5259 ARMInterruptAttr(Attr.getLoc(), S.Context, Kind, Index));
5260}
5261
5262static void handleMSP430InterruptAttr(Sema &S, Decl *D,
5263 const AttributeList &Attr) {
5264 if (!checkAttributeNumArgs(S, Attr, 1))
5265 return;
5266
5267 if (!Attr.isArgExpr(0)) {
5268 S.Diag(Attr.getLoc(), diag::err_attribute_argument_type) << Attr.getName()
5269 << AANT_ArgumentIntegerConstant;
5270 return;
5271 }
5272
5273 // FIXME: Check for decl - it should be void ()(void).
5274
5275 Expr *NumParamsExpr = static_cast<Expr *>(Attr.getArgAsExpr(0));
5276 llvm::APSInt NumParams(32);
5277 if (!NumParamsExpr->isIntegerConstantExpr(NumParams, S.Context)) {
5278 S.Diag(Attr.getLoc(), diag::err_attribute_argument_type)
5279 << Attr.getName() << AANT_ArgumentIntegerConstant
5280 << NumParamsExpr->getSourceRange();
5281 return;
5282 }
5283
5284 unsigned Num = NumParams.getLimitedValue(255);
5285 if ((Num & 1) || Num > 30) {
5286 S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
5287 << Attr.getName() << (int)NumParams.getSExtValue()
5288 << NumParamsExpr->getSourceRange();
5289 return;
5290 }
5291
5292 D->addAttr(::new (S.Context)
5293 MSP430InterruptAttr(Attr.getLoc(), S.Context, Num,
5294 Attr.getAttributeSpellingListIndex()));
5295 D->addAttr(UsedAttr::CreateImplicit(S.Context));
5296}
5297
5298static void handleMipsInterruptAttr(Sema &S, Decl *D,
5299 const AttributeList &Attr) {
5300 // Only one optional argument permitted.
5301 if (Attr.getNumArgs() > 1) {
5302 S.Diag(Attr.getLoc(), diag::err_attribute_too_many_arguments)
5303 << Attr.getName() << 1;
5304 return;
5305 }
5306
5307 StringRef Str;
5308 SourceLocation ArgLoc;
5309
5310 if (Attr.getNumArgs() == 0)
5311 Str = "";
5312 else if (!S.checkStringLiteralArgumentAttr(Attr, 0, Str, &ArgLoc))
5313 return;
5314
5315 // Semantic checks for a function with the 'interrupt' attribute for MIPS:
5316 // a) Must be a function.
5317 // b) Must have no parameters.
5318 // c) Must have the 'void' return type.
5319 // d) Cannot have the 'mips16' attribute, as that instruction set
5320 // lacks the 'eret' instruction.
5321 // e) The attribute itself must either have no argument or one of the
5322 // valid interrupt types, see [MipsInterruptDocs].
5323
5324 if (!isFunctionOrMethod(D)) {
5325 S.Diag(D->getLocation(), diag::warn_attribute_wrong_decl_type)
5326 << "'interrupt'" << ExpectedFunctionOrMethod;
5327 return;
5328 }
5329
5330 if (hasFunctionProto(D) && getFunctionOrMethodNumParams(D) != 0) {
5331 S.Diag(D->getLocation(), diag::warn_mips_interrupt_attribute)
5332 << 0;
5333 return;
5334 }
5335
5336 if (!getFunctionOrMethodResultType(D)->isVoidType()) {
5337 S.Diag(D->getLocation(), diag::warn_mips_interrupt_attribute)
5338 << 1;
5339 return;
5340 }
5341
5342 if (checkAttrMutualExclusion<Mips16Attr>(S, D, Attr.getRange(),
5343 Attr.getName()))
5344 return;
5345
5346 MipsInterruptAttr::InterruptType Kind;
5347 if (!MipsInterruptAttr::ConvertStrToInterruptType(Str, Kind)) {
5348 S.Diag(Attr.getLoc(), diag::warn_attribute_type_not_supported)
5349 << Attr.getName() << "'" + std::string(Str) + "'";
5350 return;
5351 }
5352
5353 D->addAttr(::new (S.Context) MipsInterruptAttr(
5354 Attr.getLoc(), S.Context, Kind, Attr.getAttributeSpellingListIndex()));
5355}
5356
5357static void handleAnyX86InterruptAttr(Sema &S, Decl *D,
5358 const AttributeList &Attr) {
5359 // Semantic checks for a function with the 'interrupt' attribute.
5360 // a) Must be a function.
5361 // b) Must have the 'void' return type.
5362 // c) Must take 1 or 2 arguments.
5363 // d) The 1st argument must be a pointer.
5364 // e) The 2nd argument (if any) must be an unsigned integer.
5365 if (!isFunctionOrMethod(D) || !hasFunctionProto(D) || isInstanceMethod(D) ||
5366 CXXMethodDecl::isStaticOverloadedOperator(
5367 cast<NamedDecl>(D)->getDeclName().getCXXOverloadedOperator())) {
5368 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
5369 << Attr.getName() << ExpectedFunctionWithProtoType;
5370 return;
5371 }
5372 // Interrupt handler must have void return type.
5373 if (!getFunctionOrMethodResultType(D)->isVoidType()) {
5374 S.Diag(getFunctionOrMethodResultSourceRange(D).getBegin(),
5375 diag::err_anyx86_interrupt_attribute)
5376 << (S.Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86
5377 ? 0
5378 : 1)
5379 << 0;
5380 return;
5381 }
5382 // Interrupt handler must have 1 or 2 parameters.
5383 unsigned NumParams = getFunctionOrMethodNumParams(D);
5384 if (NumParams < 1 || NumParams > 2) {
5385 S.Diag(D->getLocStart(), diag::err_anyx86_interrupt_attribute)
5386 << (S.Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86
5387 ? 0
5388 : 1)
5389 << 1;
5390 return;
5391 }
5392 // The first argument must be a pointer.
5393 if (!getFunctionOrMethodParamType(D, 0)->isPointerType()) {
5394 S.Diag(getFunctionOrMethodParamRange(D, 0).getBegin(),
5395 diag::err_anyx86_interrupt_attribute)
5396 << (S.Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86
5397 ? 0
5398 : 1)
5399 << 2;
5400 return;
5401 }
5402 // The second argument, if present, must be an unsigned integer.
5403 unsigned TypeSize =
5404 S.Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86_64
5405 ? 64
5406 : 32;
5407 if (NumParams == 2 &&
5408 (!getFunctionOrMethodParamType(D, 1)->isUnsignedIntegerType() ||
5409 S.Context.getTypeSize(getFunctionOrMethodParamType(D, 1)) != TypeSize)) {
5410 S.Diag(getFunctionOrMethodParamRange(D, 1).getBegin(),
5411 diag::err_anyx86_interrupt_attribute)
5412 << (S.Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86
5413 ? 0
5414 : 1)
5415 << 3 << S.Context.getIntTypeForBitwidth(TypeSize, /*Signed=*/false);
5416 return;
5417 }
5418 D->addAttr(::new (S.Context) AnyX86InterruptAttr(
5419 Attr.getLoc(), S.Context, Attr.getAttributeSpellingListIndex()));
5420 D->addAttr(UsedAttr::CreateImplicit(S.Context));
5421}
5422
5423static void handleAVRInterruptAttr(Sema &S, Decl *D, const AttributeList &Attr) {
5424 if (!isFunctionOrMethod(D)) {
5425 S.Diag(D->getLocation(), diag::warn_attribute_wrong_decl_type)
5426 << "'interrupt'" << ExpectedFunction;
5427 return;
5428 }
5429
5430 if (!checkAttributeNumArgs(S, Attr, 0))
5431 return;
5432
5433 handleSimpleAttribute<AVRInterruptAttr>(S, D, Attr);
5434}
5435
5436static void handleAVRSignalAttr(Sema &S, Decl *D, const AttributeList &Attr) {
5437 if (!isFunctionOrMethod(D)) {
5438 S.Diag(D->getLocation(), diag::warn_attribute_wrong_decl_type)
5439 << "'signal'" << ExpectedFunction;
5440 return;
5441 }
5442
5443 if (!checkAttributeNumArgs(S, Attr, 0))
5444 return;
5445
5446 handleSimpleAttribute<AVRSignalAttr>(S, D, Attr);
5447}
5448
5449static void handleInterruptAttr(Sema &S, Decl *D, const AttributeList &Attr) {
5450 // Dispatch the interrupt attribute based on the current target.
5451 switch (S.Context.getTargetInfo().getTriple().getArch()) {
5452 case llvm::Triple::msp430:
5453 handleMSP430InterruptAttr(S, D, Attr);
5454 break;
5455 case llvm::Triple::mipsel:
5456 case llvm::Triple::mips:
5457 handleMipsInterruptAttr(S, D, Attr);
5458 break;
5459 case llvm::Triple::x86:
5460 case llvm::Triple::x86_64:
5461 handleAnyX86InterruptAttr(S, D, Attr);
5462 break;
5463 case llvm::Triple::avr:
5464 handleAVRInterruptAttr(S, D, Attr);
5465 break;
5466 default:
5467 handleARMInterruptAttr(S, D, Attr);
5468 break;
5469 }
5470}
5471
5472static void handleAMDGPUFlatWorkGroupSizeAttr(Sema &S, Decl *D,
5473 const AttributeList &Attr) {
5474 uint32_t Min = 0;
5475 Expr *MinExpr = Attr.getArgAsExpr(0);
5476 if (!checkUInt32Argument(S, Attr, MinExpr, Min))
5477 return;
5478
5479 uint32_t Max = 0;
5480 Expr *MaxExpr = Attr.getArgAsExpr(1);
5481 if (!checkUInt32Argument(S, Attr, MaxExpr, Max))
5482 return;
5483
5484 if (Min == 0 && Max != 0) {
5485 S.Diag(Attr.getLoc(), diag::err_attribute_argument_invalid)
5486 << Attr.getName() << 0;
5487 return;
5488 }
5489 if (Min > Max) {
5490 S.Diag(Attr.getLoc(), diag::err_attribute_argument_invalid)
5491 << Attr.getName() << 1;
5492 return;
5493 }
5494
5495 D->addAttr(::new (S.Context)
5496 AMDGPUFlatWorkGroupSizeAttr(Attr.getLoc(), S.Context, Min, Max,
5497 Attr.getAttributeSpellingListIndex()));
5498}
5499
5500static void handleAMDGPUWavesPerEUAttr(Sema &S, Decl *D,
5501 const AttributeList &Attr) {
5502 uint32_t Min = 0;
5503 Expr *MinExpr = Attr.getArgAsExpr(0);
5504 if (!checkUInt32Argument(S, Attr, MinExpr, Min))
5505 return;
5506
5507 uint32_t Max = 0;
5508 if (Attr.getNumArgs() == 2) {
5509 Expr *MaxExpr = Attr.getArgAsExpr(1);
5510 if (!checkUInt32Argument(S, Attr, MaxExpr, Max))
5511 return;
5512 }
5513
5514 if (Min == 0 && Max != 0) {
5515 S.Diag(Attr.getLoc(), diag::err_attribute_argument_invalid)
5516 << Attr.getName() << 0;
5517 return;
5518 }
5519 if (Max != 0 && Min > Max) {
5520 S.Diag(Attr.getLoc(), diag::err_attribute_argument_invalid)
5521 << Attr.getName() << 1;
5522 return;
5523 }
5524
5525 D->addAttr(::new (S.Context)
5526 AMDGPUWavesPerEUAttr(Attr.getLoc(), S.Context, Min, Max,
5527 Attr.getAttributeSpellingListIndex()));
5528}
5529
5530static void handleAMDGPUNumSGPRAttr(Sema &S, Decl *D,
5531 const AttributeList &Attr) {
5532 uint32_t NumSGPR = 0;
5533 Expr *NumSGPRExpr = Attr.getArgAsExpr(0);
5534 if (!checkUInt32Argument(S, Attr, NumSGPRExpr, NumSGPR))
5535 return;
5536
5537 D->addAttr(::new (S.Context)
5538 AMDGPUNumSGPRAttr(Attr.getLoc(), S.Context, NumSGPR,
5539 Attr.getAttributeSpellingListIndex()));
5540}
5541
5542static void handleAMDGPUNumVGPRAttr(Sema &S, Decl *D,
5543 const AttributeList &Attr) {
5544 uint32_t NumVGPR = 0;
5545 Expr *NumVGPRExpr = Attr.getArgAsExpr(0);
5546 if (!checkUInt32Argument(S, Attr, NumVGPRExpr, NumVGPR))
5547 return;
5548
5549 D->addAttr(::new (S.Context)
5550 AMDGPUNumVGPRAttr(Attr.getLoc(), S.Context, NumVGPR,
5551 Attr.getAttributeSpellingListIndex()));
5552}
5553
5554static void handleX86ForceAlignArgPointerAttr(Sema &S, Decl *D,
5555 const AttributeList& Attr) {
5556 // If we try to apply it to a function pointer, don't warn, but don't
5557 // do anything, either. It doesn't matter anyway, because there's nothing
5558 // special about calling a force_align_arg_pointer function.
5559 ValueDecl *VD = dyn_cast<ValueDecl>(D);
5560 if (VD && VD->getType()->isFunctionPointerType())
5561 return;
5562 // Also don't warn on function pointer typedefs.
5563 TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D);
5564 if (TD && (TD->getUnderlyingType()->isFunctionPointerType() ||
5565 TD->getUnderlyingType()->isFunctionType()))
5566 return;
5567 // Attribute can only be applied to function types.
5568 if (!isa<FunctionDecl>(D)) {
5569 S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
5570 << Attr.getName() << /* function */0;
5571 return;
5572 }
5573
5574 D->addAttr(::new (S.Context)
5575 X86ForceAlignArgPointerAttr(Attr.getRange(), S.Context,
5576 Attr.getAttributeSpellingListIndex()));
5577}
5578
5579static void handleLayoutVersion(Sema &S, Decl *D, const AttributeList &Attr) {
5580 uint32_t Version;
5581 Expr *VersionExpr = static_cast<Expr *>(Attr.getArgAsExpr(0));
5582 if (!checkUInt32Argument(S, Attr, Attr.getArgAsExpr(0), Version))
5583 return;
5584
5585 // TODO: Investigate what happens with the next major version of MSVC.
5586 if (Version != LangOptions::MSVC2015) {
5587 S.Diag(Attr.getLoc(), diag::err_attribute_argument_out_of_bounds)
5588 << Attr.getName() << Version << VersionExpr->getSourceRange();
5589 return;
5590 }
5591
5592 D->addAttr(::new (S.Context)
5593 LayoutVersionAttr(Attr.getRange(), S.Context, Version,
5594 Attr.getAttributeSpellingListIndex()));
5595}
5596
5597DLLImportAttr *Sema::mergeDLLImportAttr(Decl *D, SourceRange Range,
5598 unsigned AttrSpellingListIndex) {
5599 if (D->hasAttr<DLLExportAttr>()) {
5600 Diag(Range.getBegin(), diag::warn_attribute_ignored) << "'dllimport'";
5601 return nullptr;
5602 }
5603
5604 if (D->hasAttr<DLLImportAttr>())
5605 return nullptr;
5606
5607 return ::new (Context) DLLImportAttr(Range, Context, AttrSpellingListIndex);
5608}
5609
5610DLLExportAttr *Sema::mergeDLLExportAttr(Decl *D, SourceRange Range,
5611 unsigned AttrSpellingListIndex) {
5612 if (DLLImportAttr *Import = D->getAttr<DLLImportAttr>()) {
5613 Diag(Import->getLocation(), diag::warn_attribute_ignored) << Import;
5614 D->dropAttr<DLLImportAttr>();
5615 }
5616
5617 if (D->hasAttr<DLLExportAttr>())
5618 return nullptr;
5619
5620 return ::new (Context) DLLExportAttr(Range, Context, AttrSpellingListIndex);
5621}
5622
5623static void handleDLLAttr(Sema &S, Decl *D, const AttributeList &A) {
5624 if (isa<ClassTemplatePartialSpecializationDecl>(D) &&
5625 S.Context.getTargetInfo().getCXXABI().isMicrosoft()) {
5626 S.Diag(A.getRange().getBegin(), diag::warn_attribute_ignored)
5627 << A.getName();
5628 return;
5629 }
5630
5631 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
5632 if (FD->isInlined() && A.getKind() == AttributeList::AT_DLLImport &&
5633 !S.Context.getTargetInfo().getCXXABI().isMicrosoft()) {
5634 // MinGW doesn't allow dllimport on inline functions.
5635 S.Diag(A.getRange().getBegin(), diag::warn_attribute_ignored_on_inline)
5636 << A.getName();
5637 return;
5638 }
5639 }
5640
5641 if (auto *MD = dyn_cast<CXXMethodDecl>(D)) {
5642 if (S.Context.getTargetInfo().getCXXABI().isMicrosoft() &&
5643 MD->getParent()->isLambda()) {
5644 S.Diag(A.getRange().getBegin(), diag::err_attribute_dll_lambda) << A.getName();
5645 return;
5646 }
5647 }
5648
5649 unsigned Index = A.getAttributeSpellingListIndex();
5650 Attr *NewAttr = A.getKind() == AttributeList::AT_DLLExport
5651 ? (Attr *)S.mergeDLLExportAttr(D, A.getRange(), Index)
5652 : (Attr *)S.mergeDLLImportAttr(D, A.getRange(), Index);
5653 if (NewAttr)
5654 D->addAttr(NewAttr);
5655}
5656
5657MSInheritanceAttr *
5658Sema::mergeMSInheritanceAttr(Decl *D, SourceRange Range, bool BestCase,
5659 unsigned AttrSpellingListIndex,
5660 MSInheritanceAttr::Spelling SemanticSpelling) {
5661 if (MSInheritanceAttr *IA = D->getAttr<MSInheritanceAttr>()) {
5662 if (IA->getSemanticSpelling() == SemanticSpelling)
5663 return nullptr;
5664 Diag(IA->getLocation(), diag::err_mismatched_ms_inheritance)
5665 << 1 /*previous declaration*/;
5666 Diag(Range.getBegin(), diag::note_previous_ms_inheritance);
5667 D->dropAttr<MSInheritanceAttr>();
5668 }
5669
5670 CXXRecordDecl *RD = cast<CXXRecordDecl>(D);
5671 if (RD->hasDefinition()) {
5672 if (checkMSInheritanceAttrOnDefinition(RD, Range, BestCase,
5673 SemanticSpelling)) {
5674 return nullptr;
5675 }
5676 } else {
5677 if (isa<ClassTemplatePartialSpecializationDecl>(RD)) {
5678 Diag(Range.getBegin(), diag::warn_ignored_ms_inheritance)
5679 << 1 /*partial specialization*/;
5680 return nullptr;
5681 }
5682 if (RD->getDescribedClassTemplate()) {
5683 Diag(Range.getBegin(), diag::warn_ignored_ms_inheritance)
5684 << 0 /*primary template*/;
5685 return nullptr;
5686 }
5687 }
5688
5689 return ::new (Context)
5690 MSInheritanceAttr(Range, Context, BestCase, AttrSpellingListIndex);
5691}
5692
5693static void handleCapabilityAttr(Sema &S, Decl *D, const AttributeList &Attr) {
5694 // The capability attributes take a single string parameter for the name of
5695 // the capability they represent. The lockable attribute does not take any
5696 // parameters. However, semantically, both attributes represent the same
5697 // concept, and so they use the same semantic attribute. Eventually, the
5698 // lockable attribute will be removed.
5699 //
5700 // For backward compatibility, any capability which has no specified string
5701 // literal will be considered a "mutex."
5702 StringRef N("mutex");
5703 SourceLocation LiteralLoc;
5704 if (Attr.getKind() == AttributeList::AT_Capability &&
5705 !S.checkStringLiteralArgumentAttr(Attr, 0, N, &LiteralLoc))
5706 return;
5707
5708 // Currently, there are only two names allowed for a capability: role and
5709 // mutex (case insensitive). Diagnose other capability names.
5710 if (!N.equals_lower("mutex") && !N.equals_lower("role"))
5711 S.Diag(LiteralLoc, diag::warn_invalid_capability_name) << N;
5712
5713 D->addAttr(::new (S.Context) CapabilityAttr(Attr.getRange(), S.Context, N,
5714 Attr.getAttributeSpellingListIndex()));
5715}
5716
5717static void handleAssertCapabilityAttr(Sema &S, Decl *D,
5718 const AttributeList &Attr) {
5719 SmallVector<Expr*, 1> Args;
5720 if (!checkLockFunAttrCommon(S, D, Attr, Args))
5721 return;
5722
5723 D->addAttr(::new (S.Context) AssertCapabilityAttr(Attr.getRange(), S.Context,
5724 Args.data(), Args.size(),
5725 Attr.getAttributeSpellingListIndex()));
5726}
5727
5728static void handleAcquireCapabilityAttr(Sema &S, Decl *D,
5729 const AttributeList &Attr) {
5730 SmallVector<Expr*, 1> Args;
5731 if (!checkLockFunAttrCommon(S, D, Attr, Args))
5732 return;
5733
5734 D->addAttr(::new (S.Context) AcquireCapabilityAttr(Attr.getRange(),
5735 S.Context,
5736 Args.data(), Args.size(),
5737 Attr.getAttributeSpellingListIndex()));
5738}
5739
5740static void handleTryAcquireCapabilityAttr(Sema &S, Decl *D,
5741 const AttributeList &Attr) {
5742 SmallVector<Expr*, 2> Args;
5743 if (!checkTryLockFunAttrCommon(S, D, Attr, Args))
5744 return;
5745
5746 D->addAttr(::new (S.Context) TryAcquireCapabilityAttr(Attr.getRange(),
5747 S.Context,
5748 Attr.getArgAsExpr(0),
5749 Args.data(),
5750 Args.size(),
5751 Attr.getAttributeSpellingListIndex()));
5752}
5753
5754static void handleReleaseCapabilityAttr(Sema &S, Decl *D,
5755 const AttributeList &Attr) {
5756 // Check that all arguments are lockable objects.
5757 SmallVector<Expr *, 1> Args;
5758 checkAttrArgsAreCapabilityObjs(S, D, Attr, Args, 0, true);
5759
5760 D->addAttr(::new (S.Context) ReleaseCapabilityAttr(
5761 Attr.getRange(), S.Context, Args.data(), Args.size(),
5762 Attr.getAttributeSpellingListIndex()));
5763}
5764
5765static void handleRequiresCapabilityAttr(Sema &S, Decl *D,
5766 const AttributeList &Attr) {
5767 if (!checkAttributeAtLeastNumArgs(S, Attr, 1))
5768 return;
5769
5770 // check that all arguments are lockable objects
5771 SmallVector<Expr*, 1> Args;
5772 checkAttrArgsAreCapabilityObjs(S, D, Attr, Args);
5773 if (Args.empty())
5774 return;
5775
5776 RequiresCapabilityAttr *RCA = ::new (S.Context)
5777 RequiresCapabilityAttr(Attr.getRange(), S.Context, Args.data(),
5778 Args.size(), Attr.getAttributeSpellingListIndex());
5779
5780 D->addAttr(RCA);
5781}
5782
5783static void handleDeprecatedAttr(Sema &S, Decl *D, const AttributeList &Attr) {
5784 if (auto *NSD = dyn_cast<NamespaceDecl>(D)) {
5785 if (NSD->isAnonymousNamespace()) {
5786 S.Diag(Attr.getLoc(), diag::warn_deprecated_anonymous_namespace);
5787 // Do not want to attach the attribute to the namespace because that will
5788 // cause confusing diagnostic reports for uses of declarations within the
5789 // namespace.
5790 return;
5791 }
5792 }
5793
5794 // Handle the cases where the attribute has a text message.
5795 StringRef Str, Replacement;
5796 if (Attr.isArgExpr(0) && Attr.getArgAsExpr(0) &&
5797 !S.checkStringLiteralArgumentAttr(Attr, 0, Str))
5798 return;
5799
5800 // Only support a single optional message for Declspec and CXX11.
5801 if (Attr.isDeclspecAttribute() || Attr.isCXX11Attribute())
5802 checkAttributeAtMostNumArgs(S, Attr, 1);
5803 else if (Attr.isArgExpr(1) && Attr.getArgAsExpr(1) &&
5804 !S.checkStringLiteralArgumentAttr(Attr, 1, Replacement))
5805 return;
5806
5807 if (!S.getLangOpts().CPlusPlus14)
5808 if (Attr.isCXX11Attribute() &&
5809 !(Attr.hasScope() && Attr.getScopeName()->isStr("gnu")))
5810 S.Diag(Attr.getLoc(), diag::ext_cxx14_attr) << Attr.getName();
5811
5812 D->addAttr(::new (S.Context)
5813 DeprecatedAttr(Attr.getRange(), S.Context, Str, Replacement,
5814 Attr.getAttributeSpellingListIndex()));
5815}
5816
5817static bool isGlobalVar(const Decl *D) {
5818 if (const auto *S = dyn_cast<VarDecl>(D))
5819 return S->hasGlobalStorage();
5820 return false;
5821}
5822
5823static void handleNoSanitizeAttr(Sema &S, Decl *D, const AttributeList &Attr) {
5824 if (!checkAttributeAtLeastNumArgs(S, Attr, 1))
5825 return;
5826
5827 std::vector<StringRef> Sanitizers;
5828
5829 for (unsigned I = 0, E = Attr.getNumArgs(); I != E; ++I) {
5830 StringRef SanitizerName;
5831 SourceLocation LiteralLoc;
5832
5833 if (!S.checkStringLiteralArgumentAttr(Attr, I, SanitizerName, &LiteralLoc))
5834 return;
5835
5836 if (parseSanitizerValue(SanitizerName, /*AllowGroups=*/true) == 0)
5837 S.Diag(LiteralLoc, diag::warn_unknown_sanitizer_ignored) << SanitizerName;
5838 else if (isGlobalVar(D) && SanitizerName != "address")
5839 S.Diag(D->getLocation(), diag::err_attribute_wrong_decl_type)
5840 << Attr.getName() << ExpectedFunctionOrMethod;
5841 Sanitizers.push_back(SanitizerName);
5842 }
5843
5844 D->addAttr(::new (S.Context) NoSanitizeAttr(
5845 Attr.getRange(), S.Context, Sanitizers.data(), Sanitizers.size(),
5846 Attr.getAttributeSpellingListIndex()));
5847}
5848
5849static void handleNoSanitizeSpecificAttr(Sema &S, Decl *D,
5850 const AttributeList &Attr) {
5851 StringRef AttrName = Attr.getName()->getName();
5852 normalizeName(AttrName);
5853 StringRef SanitizerName = llvm::StringSwitch<StringRef>(AttrName)
5854 .Case("no_address_safety_analysis", "address")
5855 .Case("no_sanitize_address", "address")
5856 .Case("no_sanitize_thread", "thread")
5857 .Case("no_sanitize_memory", "memory");
5858 if (isGlobalVar(D) && SanitizerName != "address")
5859 S.Diag(D->getLocation(), diag::err_attribute_wrong_decl_type)
5860 << Attr.getName() << ExpectedFunction;
5861 D->addAttr(::new (S.Context)
5862 NoSanitizeAttr(Attr.getRange(), S.Context, &SanitizerName, 1,
5863 Attr.getAttributeSpellingListIndex()));
5864}
5865
5866static void handleInternalLinkageAttr(Sema &S, Decl *D,
5867 const AttributeList &Attr) {
5868 if (InternalLinkageAttr *Internal =
5869 S.mergeInternalLinkageAttr(D, Attr.getRange(), Attr.getName(),
5870 Attr.getAttributeSpellingListIndex()))
5871 D->addAttr(Internal);
5872}
5873
5874static void handleOpenCLNoSVMAttr(Sema &S, Decl *D, const AttributeList &Attr) {
5875 if (S.LangOpts.OpenCLVersion != 200)
5876 S.Diag(Attr.getLoc(), diag::err_attribute_requires_opencl_version)
5877 << Attr.getName() << "2.0" << 0;
5878 else
5879 S.Diag(Attr.getLoc(), diag::warn_opencl_attr_deprecated_ignored)
5880 << Attr.getName() << "2.0";
5881}
5882
5883/// Handles semantic checking for features that are common to all attributes,
5884/// such as checking whether a parameter was properly specified, or the correct
5885/// number of arguments were passed, etc.
5886static bool handleCommonAttributeFeatures(Sema &S, Scope *scope, Decl *D,
5887 const AttributeList &Attr) {
5888 // Several attributes carry different semantics than the parsing requires, so
5889 // those are opted out of the common argument checks.
5890 //
5891 // We also bail on unknown and ignored attributes because those are handled
5892 // as part of the target-specific handling logic.
5893 if (Attr.getKind() == AttributeList::UnknownAttribute)
5894 return false;
5895 // Check whether the attribute requires specific language extensions to be
5896 // enabled.
5897 if (!Attr.diagnoseLangOpts(S))
5898 return true;
5899 // Check whether the attribute appertains to the given subject.
5900 if (!Attr.diagnoseAppertainsTo(S, D))
5901 return true;
5902 if (Attr.hasCustomParsing())
5903 return false;
5904
5905 if (Attr.getMinArgs() == Attr.getMaxArgs()) {
5906 // If there are no optional arguments, then checking for the argument count
5907 // is trivial.
5908 if (!checkAttributeNumArgs(S, Attr, Attr.getMinArgs()))
5909 return true;
5910 } else {
5911 // There are optional arguments, so checking is slightly more involved.
5912 if (Attr.getMinArgs() &&
5913 !checkAttributeAtLeastNumArgs(S, Attr, Attr.getMinArgs()))
5914 return true;
5915 else if (!Attr.hasVariadicArg() && Attr.getMaxArgs() &&
5916 !checkAttributeAtMostNumArgs(S, Attr, Attr.getMaxArgs()))
5917 return true;
5918 }
5919
5920 return false;
5921}
5922
5923static void handleOpenCLAccessAttr(Sema &S, Decl *D,
5924 const AttributeList &Attr) {
5925 if (D->isInvalidDecl())
5926 return;
5927
5928 // Check if there is only one access qualifier.
5929 if (D->hasAttr<OpenCLAccessAttr>()) {
5930 S.Diag(Attr.getLoc(), diag::err_opencl_multiple_access_qualifiers)
5931 << D->getSourceRange();
5932 D->setInvalidDecl(true);
5933 return;
5934 }
5935
5936 // OpenCL v2.0 s6.6 - read_write can be used for image types to specify that an
5937 // image object can be read and written.
5938 // OpenCL v2.0 s6.13.6 - A kernel cannot read from and write to the same pipe
5939 // object. Using the read_write (or __read_write) qualifier with the pipe
5940 // qualifier is a compilation error.
5941 if (const ParmVarDecl *PDecl = dyn_cast<ParmVarDecl>(D)) {
5942 const Type *DeclTy = PDecl->getType().getCanonicalType().getTypePtr();
5943 if (Attr.getName()->getName().find("read_write") != StringRef::npos) {
5944 if (S.getLangOpts().OpenCLVersion < 200 || DeclTy->isPipeType()) {
5945 S.Diag(Attr.getLoc(), diag::err_opencl_invalid_read_write)
5946 << Attr.getName() << PDecl->getType() << DeclTy->isImageType();
5947 D->setInvalidDecl(true);
5948 return;
5949 }
5950 }
5951 }
5952
5953 D->addAttr(::new (S.Context) OpenCLAccessAttr(
5954 Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
5955}
5956
5957//===----------------------------------------------------------------------===//
5958// Top Level Sema Entry Points
5959//===----------------------------------------------------------------------===//
5960
5961/// ProcessDeclAttribute - Apply the specific attribute to the specified decl if
5962/// the attribute applies to decls. If the attribute is a type attribute, just
5963/// silently ignore it if a GNU attribute.
5964static void ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D,
5965 const AttributeList &Attr,
5966 bool IncludeCXX11Attributes) {
5967 if (Attr.isInvalid() || Attr.getKind() == AttributeList::IgnoredAttribute)
5968 return;
5969
5970 // Ignore C++11 attributes on declarator chunks: they appertain to the type
5971 // instead.
5972 if (Attr.isCXX11Attribute() && !IncludeCXX11Attributes)
5973 return;
5974
5975 // Unknown attributes are automatically warned on. Target-specific attributes
5976 // which do not apply to the current target architecture are treated as
5977 // though they were unknown attributes.
5978 if (Attr.getKind() == AttributeList::UnknownAttribute ||
5979 !Attr.existsInTarget(S.Context.getTargetInfo())) {
5980 S.Diag(Attr.getLoc(), Attr.isDeclspecAttribute()
5981 ? diag::warn_unhandled_ms_attribute_ignored
5982 : diag::warn_unknown_attribute_ignored)
5983 << Attr.getName();
5984 return;
5985 }
5986
5987 if (handleCommonAttributeFeatures(S, scope, D, Attr))
5988 return;
5989
5990 switch (Attr.getKind()) {
5991 default:
5992 if (!Attr.isStmtAttr()) {
5993 // Type attributes are handled elsewhere; silently move on.
5994 assert(Attr.isTypeAttr() && "Non-type attribute not handled")(static_cast <bool> (Attr.isTypeAttr() && "Non-type attribute not handled"
) ? void (0) : __assert_fail ("Attr.isTypeAttr() && \"Non-type attribute not handled\""
, "/build/llvm-toolchain-snapshot-6.0~svn318882/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 5994, __extension__ __PRETTY_FUNCTION__))
;
5995 break;
5996 }
5997 S.Diag(Attr.getLoc(), diag::err_stmt_attribute_invalid_on_decl)
5998 << Attr.getName() << D->getLocation();
5999 break;
6000 case AttributeList::AT_Interrupt:
6001 handleInterruptAttr(S, D, Attr);
6002 break;
6003 case AttributeList::AT_X86ForceAlignArgPointer:
6004 handleX86ForceAlignArgPointerAttr(S, D, Attr);
6005 break;
6006 case AttributeList::AT_DLLExport:
6007 case AttributeList::AT_DLLImport:
6008 handleDLLAttr(S, D, Attr);
6009 break;
6010 case AttributeList::AT_Mips16:
6011 handleSimpleAttributeWithExclusions<Mips16Attr, MicroMipsAttr,
6012 MipsInterruptAttr>(S, D, Attr);
6013 break;
6014 case AttributeList::AT_NoMips16:
6015 handleSimpleAttribute<NoMips16Attr>(S, D, Attr);
6016 break;
6017 case AttributeList::AT_MicroMips:
6018 handleSimpleAttributeWithExclusions<MicroMipsAttr, Mips16Attr>(S, D, Attr);
6019 break;
6020 case AttributeList::AT_NoMicroMips:
6021 handleSimpleAttribute<NoMicroMipsAttr>(S, D, Attr);
6022 break;
6023 case AttributeList::AT_MipsLongCall:
6024 handleSimpleAttributeWithExclusions<MipsLongCallAttr, MipsShortCallAttr>(
6025 S, D, Attr);
6026 break;
6027 case AttributeList::AT_MipsShortCall:
6028 handleSimpleAttributeWithExclusions<MipsShortCallAttr, MipsLongCallAttr>(
6029 S, D, Attr);
6030 break;
6031 case AttributeList::AT_AMDGPUFlatWorkGroupSize:
6032 handleAMDGPUFlatWorkGroupSizeAttr(S, D, Attr);
6033 break;
6034 case AttributeList::AT_AMDGPUWavesPerEU:
6035 handleAMDGPUWavesPerEUAttr(S, D, Attr);
6036 break;
6037 case AttributeList::AT_AMDGPUNumSGPR:
6038 handleAMDGPUNumSGPRAttr(S, D, Attr);
6039 break;
6040 case AttributeList::AT_AMDGPUNumVGPR:
6041 handleAMDGPUNumVGPRAttr(S, D, Attr);
6042 break;
6043 case AttributeList::AT_AVRSignal:
6044 handleAVRSignalAttr(S, D, Attr);
6045 break;
6046 case AttributeList::AT_IBAction:
6047 handleSimpleAttribute<IBActionAttr>(S, D, Attr);
6048 break;
6049 case AttributeList::AT_IBOutlet:
6050 handleIBOutlet(S, D, Attr);
6051 break;
6052 case AttributeList::AT_IBOutletCollection:
6053 handleIBOutletCollection(S, D, Attr);
6054 break;
6055 case AttributeList::AT_IFunc:
6056 handleIFuncAttr(S, D, Attr);
6057 break;
6058 case AttributeList::AT_Alias:
6059 handleAliasAttr(S, D, Attr);
6060 break;
6061 case AttributeList::AT_Aligned:
6062 handleAlignedAttr(S, D, Attr);
6063 break;
6064 case AttributeList::AT_AlignValue:
6065 handleAlignValueAttr(S, D, Attr);
6066 break;
6067 case AttributeList::AT_AllocSize:
6068 handleAllocSizeAttr(S, D, Attr);
6069 break;
6070 case AttributeList::AT_AlwaysInline:
6071 handleAlwaysInlineAttr(S, D, Attr);
6072 break;
6073 case AttributeList::AT_AnalyzerNoReturn:
6074 handleAnalyzerNoReturnAttr(S, D, Attr);
6075 break;
6076 case AttributeList::AT_TLSModel:
6077 handleTLSModelAttr(S, D, Attr);
6078 break;
6079 case AttributeList::AT_Annotate:
6080 handleAnnotateAttr(S, D, Attr);
6081 break;
6082 case AttributeList::AT_Availability:
6083 handleAvailabilityAttr(S, D, Attr);
6084 break;
6085 case AttributeList::AT_CarriesDependency:
6086 handleDependencyAttr(S, scope, D, Attr);
6087 break;
6088 case AttributeList::AT_Common:
6089 handleCommonAttr(S, D, Attr);
6090 break;
6091 case AttributeList::AT_CUDAConstant:
6092 handleConstantAttr(S, D, Attr);
6093 break;
6094 case AttributeList::AT_PassObjectSize:
6095 handlePassObjectSizeAttr(S, D, Attr);
6096 break;
6097 case AttributeList::AT_Constructor:
6098 handleConstructorAttr(S, D, Attr);
6099 break;
6100 case AttributeList::AT_CXX11NoReturn:
6101 handleSimpleAttribute<CXX11NoReturnAttr>(S, D, Attr);
6102 break;
6103 case AttributeList::AT_Deprecated:
6104 handleDeprecatedAttr(S, D, Attr);
6105 break;
6106 case AttributeList::AT_Destructor:
6107 handleDestructorAttr(S, D, Attr);
6108 break;
6109 case AttributeList::AT_EnableIf:
6110 handleEnableIfAttr(S, D, Attr);
6111 break;
6112 case AttributeList::AT_DiagnoseIf:
6113 handleDiagnoseIfAttr(S, D, Attr);
6114 break;
6115 case AttributeList::AT_ExtVectorType:
6116 handleExtVectorTypeAttr(S, scope, D, Attr);
6117 break;
6118 case AttributeList::AT_ExternalSourceSymbol:
6119 handleExternalSourceSymbolAttr(S, D, Attr);
6120 break;
6121 case AttributeList::AT_MinSize:
6122 handleMinSizeAttr(S, D, Attr);
6123 break;
6124 case AttributeList::AT_OptimizeNone:
6125 handleOptimizeNoneAttr(S, D, Attr);
6126 break;
6127 case AttributeList::AT_FlagEnum:
6128 handleSimpleAttribute<FlagEnumAttr>(S, D, Attr);
6129 break;
6130 case AttributeList::AT_EnumExtensibility:
6131 handleEnumExtensibilityAttr(S, D, Attr);
6132 break;
6133 case AttributeList::AT_Flatten:
6134 handleSimpleAttribute<FlattenAttr>(S, D, Attr);
6135 break;
6136 case AttributeList::AT_Format:
6137 handleFormatAttr(S, D, Attr);
6138 break;
6139 case AttributeList::AT_FormatArg:
6140 handleFormatArgAttr(S, D, Attr);
6141 break;
6142 case AttributeList::AT_CUDAGlobal:
6143 handleGlobalAttr(S, D, Attr);
6144 break;
6145 case AttributeList::AT_CUDADevice:
6146 handleSimpleAttributeWithExclusions<CUDADeviceAttr, CUDAGlobalAttr>(S, D,
6147 Attr);
6148 break;
6149 case AttributeList::AT_CUDAHost:
6150 handleSimpleAttributeWithExclusions<CUDAHostAttr, CUDAGlobalAttr>(S, D,
6151 Attr);
6152 break;
6153 case AttributeList::AT_GNUInline:
6154 handleGNUInlineAttr(S, D, Attr);
6155 break;
6156 case AttributeList::AT_CUDALaunchBounds:
6157 handleLaunchBoundsAttr(S, D, Attr);
6158 break;
6159 case AttributeList::AT_Restrict:
6160 handleRestrictAttr(S, D, Attr);
6161 break;
6162 case AttributeList::AT_MayAlias:
6163 handleSimpleAttribute<MayAliasAttr>(S, D, Attr);
6164 break;
6165 case AttributeList::AT_Mode:
6166 handleModeAttr(S, D, Attr);
6167 break;
6168 case AttributeList::AT_NoAlias:
6169 handleSimpleAttribute<NoAliasAttr>(S, D, Attr);
6170 break;
6171 case AttributeList::AT_NoCommon:
6172 handleSimpleAttribute<NoCommonAttr>(S, D, Attr);
6173 break;
6174 case AttributeList::AT_NoSplitStack:
6175 handleSimpleAttribute<NoSplitStackAttr>(S, D, Attr);
6176 break;
6177 case AttributeList::AT_NonNull:
6178 if (ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(D))
6179 handleNonNullAttrParameter(S, PVD, Attr);
6180 else
6181 handleNonNullAttr(S, D, Attr);
6182 break;
6183 case AttributeList::AT_ReturnsNonNull:
6184 handleReturnsNonNullAttr(S, D, Attr);
6185 break;
6186 case AttributeList::AT_NoEscape:
6187 handleNoEscapeAttr(S, D, Attr);
6188 break;
6189 case AttributeList::AT_AssumeAligned:
6190 handleAssumeAlignedAttr(S, D, Attr);
6191 break;
6192 case AttributeList::AT_AllocAlign:
6193 handleAllocAlignAttr(S, D, Attr);
6194 break;
6195 case AttributeList::AT_Overloadable:
6196 handleSimpleAttribute<OverloadableAttr>(S, D, Attr);
6197 break;
6198 case AttributeList::AT_Ownership:
6199 handleOwnershipAttr(S, D, Attr);
6200 break;
6201 case AttributeList::AT_Cold:
6202 handleColdAttr(S, D, Attr);
6203 break;
6204 case AttributeList::AT_Hot:
6205 handleHotAttr(S, D, Attr);
6206 break;
6207 case AttributeList::AT_Naked:
6208 handleNakedAttr(S, D, Attr);
6209 break;
6210 case AttributeList::AT_NoReturn:
6211 handleNoReturnAttr(S, D, Attr);
6212 break;
6213 case AttributeList::AT_NoThrow:
6214 handleSimpleAttribute<NoThrowAttr>(S, D, Attr);
6215 break;
6216 case AttributeList::AT_CUDAShared:
6217 handleSharedAttr(S, D, Attr);
6218 break;
6219 case AttributeList::AT_VecReturn:
6220 handleVecReturnAttr(S, D, Attr);
6221 break;
6222 case AttributeList::AT_ObjCOwnership:
6223 handleObjCOwnershipAttr(S, D, Attr);
6224 break;
6225 case AttributeList::AT_ObjCPreciseLifetime:
6226 handleObjCPreciseLifetimeAttr(S, D, Attr);
6227 break;
6228 case AttributeList::AT_ObjCReturnsInnerPointer:
6229 handleObjCReturnsInnerPointerAttr(S, D, Attr);
6230 break;
6231 case AttributeList::AT_ObjCRequiresSuper:
6232 handleObjCRequiresSuperAttr(S, D, Attr);
6233 break;
6234 case AttributeList::AT_ObjCBridge:
6235 handleObjCBridgeAttr(S, scope, D, Attr);
6236 break;
6237 case AttributeList::AT_ObjCBridgeMutable:
6238 handleObjCBridgeMutableAttr(S, scope, D, Attr);
6239 break;
6240 case AttributeList::AT_ObjCBridgeRelated:
6241 handleObjCBridgeRelatedAttr(S, scope, D, Attr);
6242 break;
6243 case AttributeList::AT_ObjCDesignatedInitializer:
6244 handleObjCDesignatedInitializer(S, D, Attr);
6245 break;
6246 case AttributeList::AT_ObjCRuntimeName:
6247 handleObjCRuntimeName(S, D, Attr);
6248 break;
6249 case AttributeList::AT_ObjCRuntimeVisible:
6250 handleSimpleAttribute<ObjCRuntimeVisibleAttr>(S, D, Attr);
6251 break;
6252 case AttributeList::AT_ObjCBoxable:
6253 handleObjCBoxable(S, D, Attr);
6254 break;
6255 case AttributeList::AT_CFAuditedTransfer:
6256 handleCFAuditedTransferAttr(S, D, Attr);
6257 break;
6258 case AttributeList::AT_CFUnknownTransfer:
6259 handleCFUnknownTransferAttr(S, D, Attr);
6260 break;
6261 case AttributeList::AT_CFConsumed:
6262 case AttributeList::AT_NSConsumed:
6263 handleNSConsumedAttr(S, D, Attr);
6264 break;
6265 case AttributeList::AT_NSConsumesSelf:
6266 handleSimpleAttribute<NSConsumesSelfAttr>(S, D, Attr);
6267 break;
6268 case AttributeList::AT_NSReturnsAutoreleased:
6269 case AttributeList::AT_NSReturnsNotRetained:
6270 case AttributeList::AT_CFReturnsNotRetained:
6271 case AttributeList::AT_NSReturnsRetained:
6272 case AttributeList::AT_CFReturnsRetained:
6273 handleNSReturnsRetainedAttr(S, D, Attr);
6274 break;
6275 case AttributeList::AT_WorkGroupSizeHint:
6276 handleWorkGroupSize<WorkGroupSizeHintAttr>(S, D, Attr);
6277 break;
6278 case AttributeList::AT_ReqdWorkGroupSize:
6279 handleWorkGroupSize<ReqdWorkGroupSizeAttr>(S, D, Attr);
6280 break;
6281 case AttributeList::AT_OpenCLIntelReqdSubGroupSize:
6282 handleSubGroupSize(S, D, Attr);
6283 break;
6284 case AttributeList::AT_VecTypeHint:
6285 handleVecTypeHint(S, D, Attr);
6286 break;
6287 case AttributeList::AT_RequireConstantInit:
6288 handleSimpleAttribute<RequireConstantInitAttr>(S, D, Attr);
6289 break;
6290 case AttributeList::AT_InitPriority:
6291 handleInitPriorityAttr(S, D, Attr);
6292 break;
6293 case AttributeList::AT_Packed:
6294 handlePackedAttr(S, D, Attr);
6295 break;
6296 case AttributeList::AT_Section:
6297 handleSectionAttr(S, D, Attr);
6298 break;
6299 case AttributeList::AT_Target:
6300 handleTargetAttr(S, D, Attr);
6301 break;
6302 case AttributeList::AT_Unavailable:
6303 handleAttrWithMessage<UnavailableAttr>(S, D, Attr);
6304 break;
6305 case AttributeList::AT_ArcWeakrefUnavailable:
6306 handleSimpleAttribute<ArcWeakrefUnavailableAttr>(S, D, Attr);
6307 break;
6308 case AttributeList::AT_ObjCRootClass:
6309 handleSimpleAttribute<ObjCRootClassAttr>(S, D, Attr);
6310 break;
6311 case AttributeList::AT_ObjCSubclassingRestricted:
6312 handleSimpleAttribute<ObjCSubclassingRestrictedAttr>(S, D, Attr);
6313 break;
6314 case AttributeList::AT_ObjCExplicitProtocolImpl:
6315 handleObjCSuppresProtocolAttr(S, D, Attr);
6316 break;
6317 case AttributeList::AT_ObjCRequiresPropertyDefs:
6318 handleSimpleAttribute<ObjCRequiresPropertyDefsAttr>(S, D, Attr);
6319 break;
6320 case AttributeList::AT_Unused:
6321 handleUnusedAttr(S, D, Attr);
6322 break;
6323 case AttributeList::AT_ReturnsTwice:
6324 handleSimpleAttribute<ReturnsTwiceAttr>(S, D, Attr);
6325 break;
6326 case AttributeList::AT_NotTailCalled:
6327 handleNotTailCalledAttr(S, D, Attr);
6328 break;
6329 case AttributeList::AT_DisableTailCalls:
6330 handleDisableTailCallsAttr(S, D, Attr);
6331 break;
6332 case AttributeList::AT_Used:
6333 handleUsedAttr(S, D, Attr);
6334 break;
6335 case AttributeList::AT_Visibility:
6336 handleVisibilityAttr(S, D, Attr, false);
6337 break;
6338 case AttributeList::AT_TypeVisibility:
6339 handleVisibilityAttr(S, D, Attr, true);
6340 break;
6341 case AttributeList::AT_WarnUnused:
6342 handleSimpleAttribute<WarnUnusedAttr>(S, D, Attr);
6343 break;
6344 case AttributeList::AT_WarnUnusedResult:
6345 handleWarnUnusedResult(S, D, Attr);
6346 break;
6347 case AttributeList::AT_Weak:
6348 handleSimpleAttribute<WeakAttr>(S, D, Attr);
6349 break;
6350 case AttributeList::AT_WeakRef:
6351 handleWeakRefAttr(S, D, Attr);
6352 break;
6353 case AttributeList::AT_WeakImport:
6354 handleWeakImportAttr(S, D, Attr);
6355 break;
6356 case AttributeList::AT_TransparentUnion:
6357 handleTransparentUnionAttr(S, D, Attr);
6358 break;
6359 case AttributeList::AT_ObjCException:
6360 handleSimpleAttribute<ObjCExceptionAttr>(S, D, Attr);
6361 break;
6362 case AttributeList::AT_ObjCMethodFamily:
6363 handleObjCMethodFamilyAttr(S, D, Attr);
6364 break;
6365 case AttributeList::AT_ObjCNSObject:
6366 handleObjCNSObject(S, D, Attr);
6367 break;
6368 case AttributeList::AT_ObjCIndependentClass:
6369 handleObjCIndependentClass(S, D, Attr);
6370 break;
6371 case AttributeList::AT_Blocks:
6372 handleBlocksAttr(S, D, Attr);
6373 break;
6374 case AttributeList::AT_Sentinel:
6375 handleSentinelAttr(S, D, Attr);
6376 break;
6377 case AttributeList::AT_Const:
6378 handleSimpleAttribute<ConstAttr>(S, D, Attr);
6379 break;
6380 case AttributeList::AT_Pure:
6381 handleSimpleAttribute<PureAttr>(S, D, Attr);
6382 break;
6383 case AttributeList::AT_Cleanup:
6384 handleCleanupAttr(S, D, Attr);
6385 break;
6386 case AttributeList::AT_NoDebug:
6387 handleNoDebugAttr(S, D, Attr);
6388 break;
6389 case AttributeList::AT_NoDuplicate:
6390 handleSimpleAttribute<NoDuplicateAttr>(S, D, Attr);
6391 break;
6392 case AttributeList::AT_Convergent:
6393 handleSimpleAttribute<ConvergentAttr>(S, D, Attr);
6394 break;
6395 case AttributeList::AT_NoInline:
6396 handleSimpleAttribute<NoInlineAttr>(S, D, Attr);
6397 break;
6398 case AttributeList::AT_NoInstrumentFunction: // Interacts with -pg.
6399 handleSimpleAttribute<NoInstrumentFunctionAttr>(S, D, Attr);
6400 break;
6401 case AttributeList::AT_StdCall:
6402 case AttributeList::AT_CDecl:
6403 case AttributeList::AT_FastCall:
6404 case AttributeList::AT_ThisCall:
6405 case AttributeList::AT_Pascal:
6406 case AttributeList::AT_RegCall:
6407 case AttributeList::AT_SwiftCall:
6408 case AttributeList::AT_VectorCall:
6409 case AttributeList::AT_MSABI:
6410 case AttributeList::AT_SysVABI:
6411 case AttributeList::AT_Pcs:
6412 case AttributeList::AT_IntelOclBicc:
6413 case AttributeList::AT_PreserveMost:
6414 case AttributeList::AT_PreserveAll:
6415 handleCallConvAttr(S, D, Attr);
6416 break;
6417 case AttributeList::AT_Suppress:
6418 handleSuppressAttr(S, D, Attr);
6419 break;
6420 case AttributeList::AT_OpenCLKernel:
6421 handleSimpleAttribute<OpenCLKernelAttr>(S, D, Attr);
6422 break;
6423 case AttributeList::AT_OpenCLAccess:
6424 handleOpenCLAccessAttr(S, D, Attr);
6425 break;
6426 case AttributeList::AT_OpenCLNoSVM:
6427 handleOpenCLNoSVMAttr(S, D, Attr);
6428 break;
6429 case AttributeList::AT_SwiftContext:
6430 handleParameterABIAttr(S, D, Attr, ParameterABI::SwiftContext);
6431 break;
6432 case AttributeList::AT_SwiftErrorResult:
6433 handleParameterABIAttr(S, D, Attr, ParameterABI::SwiftErrorResult);
6434 break;
6435 case AttributeList::AT_SwiftIndirectResult:
6436 handleParameterABIAttr(S, D, Attr, ParameterABI::SwiftIndirectResult);
6437 break;
6438 case AttributeList::AT_InternalLinkage:
6439 handleInternalLinkageAttr(S, D, Attr);
6440 break;
6441 case AttributeList::AT_LTOVisibilityPublic:
6442 handleSimpleAttribute<LTOVisibilityPublicAttr>(S, D, Attr);
6443 break;
6444
6445 // Microsoft attributes:
6446 case AttributeList::AT_EmptyBases:
6447 handleSimpleAttribute<EmptyBasesAttr>(S, D, Attr);
6448 break;
6449 case AttributeList::AT_LayoutVersion:
6450 handleLayoutVersion(S, D, Attr);
6451 break;
6452 case AttributeList::AT_MSNoVTable:
6453 handleSimpleAttribute<MSNoVTableAttr>(S, D, Attr);
6454 break;
6455 case AttributeList::AT_MSStruct:
6456 handleSimpleAttribute<MSStructAttr>(S, D, Attr);
6457 break;
6458 case AttributeList::AT_Uuid:
6459 handleUuidAttr(S, D, Attr);
6460 break;
6461 case AttributeList::AT_MSInheritance:
6462 handleMSInheritanceAttr(S, D, Attr);
6463 break;
6464 case AttributeList::AT_SelectAny:
6465 handleSimpleAttribute<SelectAnyAttr>(S, D, Attr);
6466 break;
6467 case AttributeList::AT_Thread:
6468 handleDeclspecThreadAttr(S, D, Attr);
6469 break;
6470
6471 case AttributeList::AT_AbiTag:
6472 handleAbiTagAttr(S, D, Attr);
6473 break;
6474
6475 // Thread safety attributes:
6476 case AttributeList::AT_AssertExclusiveLock:
6477 handleAssertExclusiveLockAttr(S, D, Attr);
6478 break;
6479 case AttributeList::AT_AssertSharedLock:
6480 handleAssertSharedLockAttr(S, D, Attr);
6481 break;
6482 case AttributeList::AT_GuardedVar:
6483 handleSimpleAttribute<GuardedVarAttr>(S, D, Attr);
6484 break;
6485 case AttributeList::AT_PtGuardedVar:
6486 handlePtGuardedVarAttr(S, D, Attr);
6487 break;
6488 case AttributeList::AT_ScopedLockable:
6489 handleSimpleAttribute<ScopedLockableAttr>(S, D, Attr);
6490 break;
6491 case AttributeList::AT_NoSanitize:
6492 handleNoSanitizeAttr(S, D, Attr);
6493 break;
6494 case AttributeList::AT_NoSanitizeSpecific:
6495 handleNoSanitizeSpecificAttr(S, D, Attr);
6496 break;
6497 case AttributeList::AT_NoThreadSafetyAnalysis:
6498 handleSimpleAttribute<NoThreadSafetyAnalysisAttr>(S, D, Attr);
6499 break;
6500 case AttributeList::AT_GuardedBy:
6501 handleGuardedByAttr(S, D, Attr);
6502 break;
6503 case AttributeList::AT_PtGuardedBy:
6504 handlePtGuardedByAttr(S, D, Attr);
6505 break;
6506 case AttributeList::AT_ExclusiveTrylockFunction:
6507 handleExclusiveTrylockFunctionAttr(S, D, Attr);
6508 break;
6509 case AttributeList::AT_LockReturned:
6510 handleLockReturnedAttr(S, D, Attr);
6511 break;
6512 case AttributeList::AT_LocksExcluded:
6513 handleLocksExcludedAttr(S, D, Attr);
6514 break;
6515 case AttributeList::AT_SharedTrylockFunction:
6516 handleSharedTrylockFunctionAttr(S, D, Attr);
6517 break;
6518 case AttributeList::AT_AcquiredBefore:
6519 handleAcquiredBeforeAttr(S, D, Attr);
6520 break;
6521 case AttributeList::AT_AcquiredAfter:
6522 handleAcquiredAfterAttr(S, D, Attr);
6523 break;
6524
6525 // Capability analysis attributes.
6526 case AttributeList::AT_Capability:
6527 case AttributeList::AT_Lockable:
6528 handleCapabilityAttr(S, D, Attr);
6529 break;
6530 case AttributeList::AT_RequiresCapability:
6531 handleRequiresCapabilityAttr(S, D, Attr);
6532 break;
6533
6534 case AttributeList::AT_AssertCapability:
6535 handleAssertCapabilityAttr(S, D, Attr);
6536 break;
6537 case AttributeList::AT_AcquireCapability:
6538 handleAcquireCapabilityAttr(S, D, Attr);
6539 break;
6540 case AttributeList::AT_ReleaseCapability:
6541 handleReleaseCapabilityAttr(S, D, Attr);
6542 break;
6543 case AttributeList::AT_TryAcquireCapability:
6544 handleTryAcquireCapabilityAttr(S, D, Attr);
6545 break;
6546
6547 // Consumed analysis attributes.
6548 case AttributeList::AT_Consumable:
6549 handleConsumableAttr(S, D, Attr);
6550 break;
6551 case AttributeList::AT_ConsumableAutoCast:
6552 handleSimpleAttribute<ConsumableAutoCastAttr>(S, D, Attr);
6553 break;
6554 case AttributeList::AT_ConsumableSetOnRead:
6555 handleSimpleAttribute<ConsumableSetOnReadAttr>(S, D, Attr);
6556 break;
6557 case AttributeList::AT_CallableWhen:
6558 handleCallableWhenAttr(S, D, Attr);
6559 break;
6560 case AttributeList::AT_ParamTypestate:
6561 handleParamTypestateAttr(S, D, Attr);
6562 break;
6563 case AttributeList::AT_ReturnTypestate:
6564 handleReturnTypestateAttr(S, D, Attr);
6565 break;
6566 case AttributeList::AT_SetTypestate:
6567 handleSetTypestateAttr(S, D, Attr);
6568 break;
6569 case AttributeList::AT_TestTypestate:
6570 handleTestTypestateAttr(S, D, Attr);
6571 break;
6572
6573 // Type safety attributes.
6574 case AttributeList::AT_ArgumentWithTypeTag:
6575 handleArgumentWithTypeTagAttr(S, D, Attr);
6576 break;
6577 case AttributeList::AT_TypeTagForDatatype:
6578 handleTypeTagForDatatypeAttr(S, D, Attr);
6579 break;
6580 case AttributeList::AT_AnyX86NoCallerSavedRegisters:
6581 handleNoCallerSavedRegsAttr(S, D, Attr);
6582 break;
6583 case AttributeList::AT_RenderScriptKernel:
6584 handleSimpleAttribute<RenderScriptKernelAttr>(S, D, Attr);
6585 break;
6586 // XRay attributes.
6587 case AttributeList::AT_XRayInstrument:
6588 handleSimpleAttribute<XRayInstrumentAttr>(S, D, Attr);
6589 break;
6590 case AttributeList::AT_XRayLogArgs:
6591 handleXRayLogArgsAttr(S, D, Attr);
6592 break;
6593 }
6594}
6595
6596/// ProcessDeclAttributeList - Apply all the decl attributes in the specified
6597/// attribute list to the specified decl, ignoring any type attributes.
6598void Sema::ProcessDeclAttributeList(Scope *S, Decl *D,
6599 const AttributeList *AttrList,
6600 bool IncludeCXX11Attributes) {
6601 for (const AttributeList* l = AttrList; l; l = l->getNext())
6602 ProcessDeclAttribute(*this, S, D, *l, IncludeCXX11Attributes);
6603
6604 // FIXME: We should be able to handle these cases in TableGen.
6605 // GCC accepts
6606 // static int a9 __attribute__((weakref));
6607 // but that looks really pointless. We reject it.
6608 if (D->hasAttr<WeakRefAttr>() && !D->hasAttr<AliasAttr>()) {
6609 Diag(AttrList->getLoc(), diag::err_attribute_weakref_without_alias)
6610 << cast<NamedDecl>(D);
6611 D->dropAttr<WeakRefAttr>();
6612 return;
6613 }
6614
6615 // FIXME: We should be able to handle this in TableGen as well. It would be
6616 // good to have a way to specify "these attributes must appear as a group",
6617 // for these. Additionally, it would be good to have a way to specify "these
6618 // attribute must never appear as a group" for attributes like cold and hot.
6619 if (!D->hasAttr<OpenCLKernelAttr>()) {
6620 // These attributes cannot be applied to a non-kernel function.
6621 if (Attr *A = D->getAttr<ReqdWorkGroupSizeAttr>()) {
6622 // FIXME: This emits a different error message than
6623 // diag::err_attribute_wrong_decl_type + ExpectedKernelFunction.
6624 Diag(D->getLocation(), diag::err_opencl_kernel_attr) << A;
6625 D->setInvalidDecl();
6626 } else if (Attr *A = D->getAttr<WorkGroupSizeHintAttr>()) {
6627 Diag(D->getLocation(), diag::err_opencl_kernel_attr) << A;
6628 D->setInvalidDecl();
6629 } else if (Attr *A = D->getAttr<VecTypeHintAttr>()) {
6630 Diag(D->getLocation(), diag::err_opencl_kernel_attr) << A;
6631 D->setInvalidDecl();
6632 } else if (Attr *A = D->getAttr<AMDGPUFlatWorkGroupSizeAttr>()) {
6633 Diag(D->getLocation(), diag::err_attribute_wrong_decl_type)
6634 << A << ExpectedKernelFunction;
6635 D->setInvalidDecl();
6636 } else if (Attr *A = D->getAttr<AMDGPUWavesPerEUAttr>()) {
6637 Diag(D->getLocation(), diag::err_attribute_wrong_decl_type)
6638 << A << ExpectedKernelFunction;
6639 D->setInvalidDecl();
6640 } else if (Attr *A = D->getAttr<AMDGPUNumSGPRAttr>()) {
6641 Diag(D->getLocation(), diag::err_attribute_wrong_decl_type)
6642 << A << ExpectedKernelFunction;
6643 D->setInvalidDecl();
6644 } else if (Attr *A = D->getAttr<AMDGPUNumVGPRAttr>()) {
6645 Diag(D->getLocation(), diag::err_attribute_wrong_decl_type)
6646 << A << ExpectedKernelFunction;
6647 D->setInvalidDecl();
6648 } else if (Attr *A = D->getAttr<OpenCLIntelReqdSubGroupSizeAttr>()) {
6649 Diag(D->getLocation(), diag::err_opencl_kernel_attr) << A;
6650 D->setInvalidDecl();
6651 }
6652 }
6653}
6654
6655// Helper for delayed processing TransparentUnion attribute.
6656void Sema::ProcessDeclAttributeDelayed(Decl *D, const AttributeList *AttrList) {
6657 for (const AttributeList *Attr = AttrList; Attr; Attr = Attr->getNext())
6658 if (Attr->getKind() == AttributeList::AT_TransparentUnion) {
6659 handleTransparentUnionAttr(*this, D, *Attr);
6660 break;
6661 }
6662}
6663
6664// Annotation attributes are the only attributes allowed after an access
6665// specifier.
6666bool Sema::ProcessAccessDeclAttributeList(AccessSpecDecl *ASDecl,
6667 const AttributeList *AttrList) {
6668 for (const AttributeList* l = AttrList; l; l = l->getNext()) {
6669 if (l->getKind() == AttributeList::AT_Annotate) {
6670 ProcessDeclAttribute(*this, nullptr, ASDecl, *l, l->isCXX11Attribute());
6671 } else {
6672 Diag(l->getLoc(), diag::err_only_annotate_after_access_spec);
6673 return true;
6674 }
6675 }
6676
6677 return false;
6678}
6679
6680/// checkUnusedDeclAttributes - Check a list of attributes to see if it
6681/// contains any decl attributes that we should warn about.
6682static void checkUnusedDeclAttributes(Sema &S, const AttributeList *A) {
6683 for ( ; A; A = A->getNext()) {
6684 // Only warn if the attribute is an unignored, non-type attribute.
6685 if (A->isUsedAsTypeAttr() || A->isInvalid()) continue;
6686 if (A->getKind() == AttributeList::IgnoredAttribute) continue;
6687
6688 if (A->getKind() == AttributeList::UnknownAttribute) {
6689 S.Diag(A->getLoc(), diag::warn_unknown_attribute_ignored)
6690 << A->getName() << A->getRange();
6691 } else {
6692 S.Diag(A->getLoc(), diag::warn_attribute_not_on_decl)
6693 << A->getName() << A->getRange();
6694 }
6695 }
6696}
6697
6698/// checkUnusedDeclAttributes - Given a declarator which is not being
6699/// used to build a declaration, complain about any decl attributes
6700/// which might be lying around on it.
6701void Sema::checkUnusedDeclAttributes(Declarator &D) {
6702 ::checkUnusedDeclAttributes(*this, D.getDeclSpec().getAttributes().getList());
6703 ::checkUnusedDeclAttributes(*this, D.getAttributes());
6704 for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i)
6705 ::checkUnusedDeclAttributes(*this, D.getTypeObject(i).getAttrs());
6706}
6707
6708/// DeclClonePragmaWeak - clone existing decl (maybe definition),
6709/// \#pragma weak needs a non-definition decl and source may not have one.
6710NamedDecl * Sema::DeclClonePragmaWeak(NamedDecl *ND, IdentifierInfo *II,
6711 SourceLocation Loc) {
6712 assert(isa<FunctionDecl>(ND) || isa<VarDecl>(ND))(static_cast <bool> (isa<FunctionDecl>(ND) || isa
<VarDecl>(ND)) ? void (0) : __assert_fail ("isa<FunctionDecl>(ND) || isa<VarDecl>(ND)"
, "/build/llvm-toolchain-snapshot-6.0~svn318882/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 6712, __extension__ __PRETTY_FUNCTION__))
;
6713 NamedDecl *NewD = nullptr;
6714 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
6715 FunctionDecl *NewFD;
6716 // FIXME: Missing call to CheckFunctionDeclaration().
6717 // FIXME: Mangling?
6718 // FIXME: Is the qualifier info correct?
6719 // FIXME: Is the DeclContext correct?
6720 NewFD = FunctionDecl::Create(FD->getASTContext(), FD->getDeclContext(),
6721 Loc, Loc, DeclarationName(II),
6722 FD->getType(), FD->getTypeSourceInfo(),
6723 SC_None, false/*isInlineSpecified*/,
6724 FD->hasPrototype(),
6725 false/*isConstexprSpecified*/);
6726 NewD = NewFD;
6727
6728 if (FD->getQualifier())
6729 NewFD->setQualifierInfo(FD->getQualifierLoc());
6730
6731 // Fake up parameter variables; they are declared as if this were
6732 // a typedef.
6733 QualType FDTy = FD->getType();
6734 if (const FunctionProtoType *FT = FDTy->getAs<FunctionProtoType>()) {
6735 SmallVector<ParmVarDecl*, 16> Params;
6736 for (const auto &AI : FT->param_types()) {
6737 ParmVarDecl *Param = BuildParmVarDeclForTypedef(NewFD, Loc, AI);
6738 Param->setScopeInfo(0, Params.size());
6739 Params.push_back(Param);
6740 }
6741 NewFD->setParams(Params);
6742 }
6743 } else if (VarDecl *VD = dyn_cast<VarDecl>(ND)) {
6744 NewD = VarDecl::Create(VD->getASTContext(), VD->getDeclContext(),
6745 VD->getInnerLocStart(), VD->getLocation(), II,
6746 VD->getType(), VD->getTypeSourceInfo(),
6747 VD->getStorageClass());
6748 if (VD->getQualifier()) {
6749 VarDecl *NewVD = cast<VarDecl>(NewD);
6750 NewVD->setQualifierInfo(VD->getQualifierLoc());
6751 }
6752 }
6753 return NewD;
6754}
6755
6756/// DeclApplyPragmaWeak - A declaration (maybe definition) needs \#pragma weak
6757/// applied to it, possibly with an alias.
6758void Sema::DeclApplyPragmaWeak(Scope *S, NamedDecl *ND, WeakInfo &W) {
6759 if (W.getUsed()) return; // only do this once
6760 W.setUsed(true);
6761 if (W.getAlias()) { // clone decl, impersonate __attribute(weak,alias(...))
6762 IdentifierInfo *NDId = ND->getIdentifier();
6763 NamedDecl *NewD = DeclClonePragmaWeak(ND, W.getAlias(), W.getLocation());
6764 NewD->addAttr(AliasAttr::CreateImplicit(Context, NDId->getName(),
6765 W.getLocation()));
6766 NewD->addAttr(WeakAttr::CreateImplicit(Context, W.getLocation()));
6767 WeakTopLevelDecl.push_back(NewD);
6768 // FIXME: "hideous" code from Sema::LazilyCreateBuiltin
6769 // to insert Decl at TU scope, sorry.
6770 DeclContext *SavedContext = CurContext;
6771 CurContext = Context.getTranslationUnitDecl();
6772 NewD->setDeclContext(CurContext);
6773 NewD->setLexicalDeclContext(CurContext);
6774 PushOnScopeChains(NewD, S);
6775 CurContext = SavedContext;
6776 } else { // just add weak to existing
6777 ND->addAttr(WeakAttr::CreateImplicit(Context, W.getLocation()));
6778 }
6779}
6780
6781void Sema::ProcessPragmaWeak(Scope *S, Decl *D) {
6782 // It's valid to "forward-declare" #pragma weak, in which case we
6783 // have to do this.
6784 LoadExternalWeakUndeclaredIdentifiers();
6785 if (!WeakUndeclaredIdentifiers.empty()) {
6786 NamedDecl *ND = nullptr;
6787 if (VarDecl *VD = dyn_cast<VarDecl>(D))
6788 if (VD->isExternC())
6789 ND = VD;
6790 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
6791 if (FD->isExternC())
6792 ND = FD;
6793 if (ND) {
6794 if (IdentifierInfo *Id = ND->getIdentifier()) {
6795 auto I = WeakUndeclaredIdentifiers.find(Id);
6796 if (I != WeakUndeclaredIdentifiers.end()) {
6797 WeakInfo W = I->second;
6798 DeclApplyPragmaWeak(S, ND, W);
6799 WeakUndeclaredIdentifiers[Id] = W;
6800 }
6801 }
6802 }
6803 }
6804}
6805
6806/// ProcessDeclAttributes - Given a declarator (PD) with attributes indicated in
6807/// it, apply them to D. This is a bit tricky because PD can have attributes
6808/// specified in many different places, and we need to find and apply them all.
6809void Sema::ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD) {
6810 // Apply decl attributes from the DeclSpec if present.
6811 if (const AttributeList *Attrs = PD.getDeclSpec().getAttributes().getList())
6812 ProcessDeclAttributeList(S, D, Attrs);
6813
6814 // Walk the declarator structure, applying decl attributes that were in a type
6815 // position to the decl itself. This handles cases like:
6816 // int *__attr__(x)** D;
6817 // when X is a decl attribute.
6818 for (unsigned i = 0, e = PD.getNumTypeObjects(); i != e; ++i)
6819 if (const AttributeList *Attrs = PD.getTypeObject(i).getAttrs())
6820 ProcessDeclAttributeList(S, D, Attrs, /*IncludeCXX11Attributes=*/false);
6821
6822 // Finally, apply any attributes on the decl itself.
6823 if (const AttributeList *Attrs = PD.getAttributes())
6824 ProcessDeclAttributeList(S, D, Attrs);
6825
6826 // Apply additional attributes specified by '#pragma clang attribute'.
6827 AddPragmaAttributes(S, D);
6828}
6829
6830/// Is the given declaration allowed to use a forbidden type?
6831/// If so, it'll still be annotated with an attribute that makes it
6832/// illegal to actually use.
6833static bool isForbiddenTypeAllowed(Sema &S, Decl *decl,
6834 const DelayedDiagnostic &diag,
6835 UnavailableAttr::ImplicitReason &reason) {
6836 // Private ivars are always okay. Unfortunately, people don't
6837 // always properly make their ivars private, even in system headers.
6838 // Plus we need to make fields okay, too.
6839 if (!isa<FieldDecl>(decl) && !isa<ObjCPropertyDecl>(decl) &&
6840 !isa<FunctionDecl>(decl))
6841 return false;
6842
6843 // Silently accept unsupported uses of __weak in both user and system
6844 // declarations when it's been disabled, for ease of integration with
6845 // -fno-objc-arc files. We do have to take some care against attempts
6846 // to define such things; for now, we've only done that for ivars
6847 // and properties.
6848 if ((isa<ObjCIvarDecl>(decl) || isa<ObjCPropertyDecl>(decl))) {
6849 if (diag.getForbiddenTypeDiagnostic() == diag::err_arc_weak_disabled ||
6850 diag.getForbiddenTypeDiagnostic() == diag::err_arc_weak_no_runtime) {
6851 reason = UnavailableAttr::IR_ForbiddenWeak;
6852 return true;
6853 }
6854 }
6855
6856 // Allow all sorts of things in system headers.
6857 if (S.Context.getSourceManager().isInSystemHeader(decl->getLocation())) {
6858 // Currently, all the failures dealt with this way are due to ARC
6859 // restrictions.
6860 reason = UnavailableAttr::IR_ARCForbiddenType;
6861 return true;
6862 }
6863
6864 return false;
6865}
6866
6867/// Handle a delayed forbidden-type diagnostic.
6868static void handleDelayedForbiddenType(Sema &S, DelayedDiagnostic &diag,
6869 Decl *decl) {
6870 auto reason = UnavailableAttr::IR_None;
6871 if (decl && isForbiddenTypeAllowed(S, decl, diag, reason)) {
6872 assert(reason && "didn't set reason?")(static_cast <bool> (reason && "didn't set reason?"
) ? void (0) : __assert_fail ("reason && \"didn't set reason?\""
, "/build/llvm-toolchain-snapshot-6.0~svn318882/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 6872, __extension__ __PRETTY_FUNCTION__))
;
6873 decl->addAttr(UnavailableAttr::CreateImplicit(S.Context, "", reason,
6874 diag.Loc));
6875 return;
6876 }
6877 if (S.getLangOpts().ObjCAutoRefCount)
6878 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(decl)) {
6879 // FIXME: we may want to suppress diagnostics for all
6880 // kind of forbidden type messages on unavailable functions.
6881 if (FD->hasAttr<UnavailableAttr>() &&
6882 diag.getForbiddenTypeDiagnostic() ==
6883 diag::err_arc_array_param_no_ownership) {
6884 diag.Triggered = true;
6885 return;
6886 }
6887 }
6888
6889 S.Diag(diag.Loc, diag.getForbiddenTypeDiagnostic())
6890 << diag.getForbiddenTypeOperand() << diag.getForbiddenTypeArgument();
6891 diag.Triggered = true;
6892}
6893
6894static const AvailabilityAttr *getAttrForPlatform(ASTContext &Context,
6895 const Decl *D) {
6896 // Check each AvailabilityAttr to find the one for this platform.
6897 for (const auto *A : D->attrs()) {
6898 if (const auto *Avail = dyn_cast<AvailabilityAttr>(A)) {
6899 // FIXME: this is copied from CheckAvailability. We should try to
6900 // de-duplicate.
6901
6902 // Check if this is an App Extension "platform", and if so chop off
6903 // the suffix for matching with the actual platform.
6904 StringRef ActualPlatform = Avail->getPlatform()->getName();
6905 StringRef RealizedPlatform = ActualPlatform;
6906 if (Context.getLangOpts().AppExt) {
6907 size_t suffix = RealizedPlatform.rfind("_app_extension");
6908 if (suffix != StringRef::npos)
6909 RealizedPlatform = RealizedPlatform.slice(0, suffix);
6910 }
6911
6912 StringRef TargetPlatform = Context.getTargetInfo().getPlatformName();
6913
6914 // Match the platform name.
6915 if (RealizedPlatform == TargetPlatform)
6916 return Avail;
6917 }
6918 }
6919 return nullptr;
6920}
6921
6922/// The diagnostic we should emit for \c D, and the declaration that
6923/// originated it, or \c AR_Available.
6924///
6925/// \param D The declaration to check.
6926/// \param Message If non-null, this will be populated with the message from
6927/// the availability attribute that is selected.
6928static std::pair<AvailabilityResult, const NamedDecl *>
6929ShouldDiagnoseAvailabilityOfDecl(const NamedDecl *D, std::string *Message) {
6930 AvailabilityResult Result = D->getAvailability(Message);
6931
6932 // For typedefs, if the typedef declaration appears available look
6933 // to the underlying type to see if it is more restrictive.
6934 while (const TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) {
6935 if (Result == AR_Available) {
6936 if (const TagType *TT = TD->getUnderlyingType()->getAs<TagType>()) {
6937 D = TT->getDecl();
6938 Result = D->getAvailability(Message);
6939 continue;
6940 }
6941 }
6942 break;
6943 }
6944
6945 // Forward class declarations get their attributes from their definition.
6946 if (const ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(D)) {
6947 if (IDecl->getDefinition()) {
6948 D = IDecl->getDefinition();
6949 Result = D->getAvailability(Message);
6950 }
6951 }
6952
6953 if (const auto *ECD = dyn_cast<EnumConstantDecl>(D))
6954 if (Result == AR_Available) {
6955 const DeclContext *DC = ECD->getDeclContext();
6956 if (const auto *TheEnumDecl = dyn_cast<EnumDecl>(DC)) {
6957 Result = TheEnumDecl->getAvailability(Message);
6958 D = TheEnumDecl;
6959 }
6960 }
6961
6962 return {Result, D};
6963}
6964
6965
6966/// \brief whether we should emit a diagnostic for \c K and \c DeclVersion in
6967/// the context of \c Ctx. For example, we should emit an unavailable diagnostic
6968/// in a deprecated context, but not the other way around.
6969static bool ShouldDiagnoseAvailabilityInContext(Sema &S, AvailabilityResult K,
6970 VersionTuple DeclVersion,
6971 Decl *Ctx) {
6972 assert(K != AR_Available && "Expected an unavailable declaration here!")(static_cast <bool> (K != AR_Available && "Expected an unavailable declaration here!"
) ? void (0) : __assert_fail ("K != AR_Available && \"Expected an unavailable declaration here!\""
, "/build/llvm-toolchain-snapshot-6.0~svn318882/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 6972, __extension__ __PRETTY_FUNCTION__))
;
6973
6974 // Checks if we should emit the availability diagnostic in the context of C.
6975 auto CheckContext = [&](const Decl *C) {
6976 if (K == AR_NotYetIntroduced) {
6977 if (const AvailabilityAttr *AA = getAttrForPlatform(S.Context, C))
6978 if (AA->getIntroduced() >= DeclVersion)
6979 return true;
6980 } else if (K == AR_Deprecated)
6981 if (C->isDeprecated())
6982 return true;
6983
6984 if (C->isUnavailable())
6985 return true;
6986 return false;
6987 };
6988
6989 // FIXME: This is a temporary workaround! Some existing Apple headers depends
6990 // on nested declarations in an @interface having the availability of the
6991 // interface when they really shouldn't: they are members of the enclosing
6992 // context, and can referenced from there.
6993 if (S.OriginalLexicalContext && cast<Decl>(S.OriginalLexicalContext) != Ctx) {
6994 auto *OrigCtx = cast<Decl>(S.OriginalLexicalContext);
6995 if (CheckContext(OrigCtx))
6996 return false;
6997
6998 // An implementation implicitly has the availability of the interface.
6999 if (auto *CatOrImpl = dyn_cast<ObjCImplDecl>(OrigCtx)) {
7000 if (const ObjCInterfaceDecl *Interface = CatOrImpl->getClassInterface())
7001 if (CheckContext(Interface))
7002 return false;
7003 }
7004 // A category implicitly has the availability of the interface.
7005 else if (auto *CatD = dyn_cast<ObjCCategoryDecl>(OrigCtx))
7006 if (const ObjCInterfaceDecl *Interface = CatD->getClassInterface())
7007 if (CheckContext(Interface))
7008 return false;
7009 }
7010
7011 do {
7012 if (CheckContext(Ctx))
7013 return false;
7014
7015 // An implementation implicitly has the availability of the interface.
7016 if (auto *CatOrImpl = dyn_cast<ObjCImplDecl>(Ctx)) {
7017 if (const ObjCInterfaceDecl *Interface = CatOrImpl->getClassInterface())
7018 if (CheckContext(Interface))
7019 return false;
7020 }
7021 // A category implicitly has the availability of the interface.
7022 else if (auto *CatD = dyn_cast<ObjCCategoryDecl>(Ctx))
7023 if (const ObjCInterfaceDecl *Interface = CatD->getClassInterface())
7024 if (CheckContext(Interface))
7025 return false;
7026 } while ((Ctx = cast_or_null<Decl>(Ctx->getDeclContext())));
7027
7028 return true;
7029}
7030
7031static bool
7032shouldDiagnoseAvailabilityByDefault(const ASTContext &Context,
7033 const VersionTuple &DeploymentVersion,
7034 const VersionTuple &DeclVersion) {
7035 const auto &Triple = Context.getTargetInfo().getTriple();
7036 VersionTuple ForceAvailabilityFromVersion;
7037 switch (Triple.getOS()) {
7038 case llvm::Triple::IOS:
7039 case llvm::Triple::TvOS:
7040 ForceAvailabilityFromVersion = VersionTuple(/*Major=*/11);
7041 break;
7042 case llvm::Triple::WatchOS:
7043 ForceAvailabilityFromVersion = VersionTuple(/*Major=*/4);
7044 break;
7045 case llvm::Triple::Darwin:
7046 case llvm::Triple::MacOSX:
7047 ForceAvailabilityFromVersion = VersionTuple(/*Major=*/10, /*Minor=*/13);
7048 break;
7049 default:
7050 // New targets should always warn about availability.
7051 return Triple.getVendor() == llvm::Triple::Apple;
7052 }
7053 return DeploymentVersion >= ForceAvailabilityFromVersion ||
7054 DeclVersion >= ForceAvailabilityFromVersion;
7055}
7056
7057static NamedDecl *findEnclosingDeclToAnnotate(Decl *OrigCtx) {
7058 for (Decl *Ctx = OrigCtx; Ctx;
7059 Ctx = cast_or_null<Decl>(Ctx->getDeclContext())) {
7060 if (isa<TagDecl>(Ctx) || isa<FunctionDecl>(Ctx) || isa<ObjCMethodDecl>(Ctx))
7061 return cast<NamedDecl>(Ctx);
7062 if (auto *CD = dyn_cast<ObjCContainerDecl>(Ctx)) {
7063 if (auto *Imp = dyn_cast<ObjCImplDecl>(Ctx))
7064 return Imp->getClassInterface();
7065 return CD;
7066 }
7067 }
7068
7069 return dyn_cast<NamedDecl>(OrigCtx);
7070}
7071
7072namespace {
7073
7074struct AttributeInsertion {
7075 StringRef Prefix;
7076 SourceLocation Loc;
7077 StringRef Suffix;
7078
7079 static AttributeInsertion createInsertionAfter(const NamedDecl *D) {
7080 return {" ", D->getLocEnd(), ""};
7081 }
7082 static AttributeInsertion createInsertionAfter(SourceLocation Loc) {
7083 return {" ", Loc, ""};
7084 }
7085 static AttributeInsertion createInsertionBefore(const NamedDecl *D) {
7086 return {"", D->getLocStart(), "\n"};
7087 }
7088};
7089
7090} // end anonymous namespace
7091
7092/// Returns a source location in which it's appropriate to insert a new
7093/// attribute for the given declaration \D.
7094static Optional<AttributeInsertion>
7095createAttributeInsertion(const NamedDecl *D, const SourceManager &SM,
7096 const LangOptions &LangOpts) {
7097 if (isa<ObjCPropertyDecl>(D))
7098 return AttributeInsertion::createInsertionAfter(D);
7099 if (const auto *MD = dyn_cast<ObjCMethodDecl>(D)) {
7100 if (MD->hasBody())
7101 return None;
7102 return AttributeInsertion::createInsertionAfter(D);
7103 }
7104 if (const auto *TD = dyn_cast<TagDecl>(D)) {
7105 SourceLocation Loc =
7106 Lexer::getLocForEndOfToken(TD->getInnerLocStart(), 0, SM, LangOpts);
7107 if (Loc.isInvalid())
7108 return None;
7109 // Insert after the 'struct'/whatever keyword.
7110 return AttributeInsertion::createInsertionAfter(Loc);
7111 }
7112 return AttributeInsertion::createInsertionBefore(D);
7113}
7114
7115/// Actually emit an availability diagnostic for a reference to an unavailable
7116/// decl.
7117///
7118/// \param Ctx The context that the reference occurred in
7119/// \param ReferringDecl The exact declaration that was referenced.
7120/// \param OffendingDecl A related decl to \c ReferringDecl that has an
7121/// availability attribute corrisponding to \c K attached to it. Note that this
7122/// may not be the same as ReferringDecl, i.e. if an EnumDecl is annotated and
7123/// we refer to a member EnumConstantDecl, ReferringDecl is the EnumConstantDecl
7124/// and OffendingDecl is the EnumDecl.
7125static void DoEmitAvailabilityWarning(Sema &S, AvailabilityResult K,
7126 Decl *Ctx, const NamedDecl *ReferringDecl,
7127 const NamedDecl *OffendingDecl,
7128 StringRef Message, SourceLocation Loc,
7129 const ObjCInterfaceDecl *UnknownObjCClass,
7130 const ObjCPropertyDecl *ObjCProperty,
7131 bool ObjCPropertyAccess) {
7132 // Diagnostics for deprecated or unavailable.
7133 unsigned diag, diag_message, diag_fwdclass_message;
7134 unsigned diag_available_here = diag::note_availability_specified_here;
7135 SourceLocation NoteLocation = OffendingDecl->getLocation();
7136
7137 // Matches 'diag::note_property_attribute' options.
7138 unsigned property_note_select;
7139
7140 // Matches diag::note_availability_specified_here.
7141 unsigned available_here_select_kind;
7142
7143 VersionTuple DeclVersion;
7144 if (const AvailabilityAttr *AA = getAttrForPlatform(S.Context, OffendingDecl))
7145 DeclVersion = AA->getIntroduced();
7146
7147 if (!ShouldDiagnoseAvailabilityInContext(S, K, DeclVersion, Ctx))
7148 return;
7149
7150 // The declaration can have multiple availability attributes, we are looking
7151 // at one of them.
7152 const AvailabilityAttr *A = getAttrForPlatform(S.Context, OffendingDecl);
7153 if (A && A->isInherited()) {
7154 for (const Decl *Redecl = OffendingDecl->getMostRecentDecl(); Redecl;
7155 Redecl = Redecl->getPreviousDecl()) {
7156 const AvailabilityAttr *AForRedecl =
7157 getAttrForPlatform(S.Context, Redecl);
7158 if (AForRedecl && !AForRedecl->isInherited()) {
7159 // If D is a declaration with inherited attributes, the note should
7160 // point to the declaration with actual attributes.
7161 NoteLocation = Redecl->getLocation();
7162 break;
7163 }
7164 }
7165 }
7166
7167 switch (K) {
7168 case AR_NotYetIntroduced: {
7169 // We would like to emit the diagnostic even if -Wunguarded-availability is
7170 // not specified for deployment targets >= to iOS 11 or equivalent or
7171 // for declarations that were introduced in iOS 11 (macOS 10.13, ...) or
7172 // later.
7173 const AvailabilityAttr *AA =
7174 getAttrForPlatform(S.getASTContext(), OffendingDecl);
7175 VersionTuple Introduced = AA->getIntroduced();
7176
7177 bool UseNewWarning = shouldDiagnoseAvailabilityByDefault(
7178 S.Context, S.Context.getTargetInfo().getPlatformMinVersion(),
7179 Introduced);
7180 unsigned Warning = UseNewWarning ? diag::warn_unguarded_availability_new
7181 : diag::warn_unguarded_availability;
7182
7183 S.Diag(Loc, Warning)
7184 << OffendingDecl
7185 << AvailabilityAttr::getPrettyPlatformName(
7186 S.getASTContext().getTargetInfo().getPlatformName())
7187 << Introduced.getAsString();
7188
7189 S.Diag(OffendingDecl->getLocation(), diag::note_availability_specified_here)
7190 << OffendingDecl << /* partial */ 3;
7191
7192 if (const auto *Enclosing = findEnclosingDeclToAnnotate(Ctx)) {
7193 if (auto *TD = dyn_cast<TagDecl>(Enclosing))
7194 if (TD->getDeclName().isEmpty()) {
7195 S.Diag(TD->getLocation(),
7196 diag::note_decl_unguarded_availability_silence)
7197 << /*Anonymous*/ 1 << TD->getKindName();
7198 return;
7199 }
7200 auto FixitNoteDiag =
7201 S.Diag(Enclosing->getLocation(),
7202 diag::note_decl_unguarded_availability_silence)
7203 << /*Named*/ 0 << Enclosing;
7204 // Don't offer a fixit for declarations with availability attributes.
7205 if (Enclosing->hasAttr<AvailabilityAttr>())
7206 return;
7207 if (!S.getPreprocessor().isMacroDefined("API_AVAILABLE"))
7208 return;
7209 Optional<AttributeInsertion> Insertion = createAttributeInsertion(
7210 Enclosing, S.getSourceManager(), S.getLangOpts());
7211 if (!Insertion)
7212 return;
7213 std::string PlatformName =
7214 AvailabilityAttr::getPlatformNameSourceSpelling(
7215 S.getASTContext().getTargetInfo().getPlatformName())
7216 .lower();
7217 std::string Introduced =
7218 OffendingDecl->getVersionIntroduced().getAsString();
7219 FixitNoteDiag << FixItHint::CreateInsertion(
7220 Insertion->Loc,
7221 (llvm::Twine(Insertion->Prefix) + "API_AVAILABLE(" + PlatformName +
7222 "(" + Introduced + "))" + Insertion->Suffix)
7223 .str());
7224 }
7225 return;
7226 }
7227 case AR_Deprecated:
7228 diag = !ObjCPropertyAccess ? diag::warn_deprecated
7229 : diag::warn_property_method_deprecated;
7230 diag_message = diag::warn_deprecated_message;
7231 diag_fwdclass_message = diag::warn_deprecated_fwdclass_message;
7232 property_note_select = /* deprecated */ 0;
7233 available_here_select_kind = /* deprecated */ 2;
7234 if (const auto *Attr = OffendingDecl->getAttr<DeprecatedAttr>())
7235 NoteLocation = Attr->getLocation();
7236 break;
7237
7238 case AR_Unavailable:
7239 diag = !ObjCPropertyAccess ? diag::err_unavailable
7240 : diag::err_property_method_unavailable;
7241 diag_message = diag::err_unavailable_message;
7242 diag_fwdclass_message = diag::warn_unavailable_fwdclass_message;
7243 property_note_select = /* unavailable */ 1;
7244 available_here_select_kind = /* unavailable */ 0;
7245
7246 if (auto Attr = OffendingDecl->getAttr<UnavailableAttr>()) {
7247 if (Attr->isImplicit() && Attr->getImplicitReason()) {
7248 // Most of these failures are due to extra restrictions in ARC;
7249 // reflect that in the primary diagnostic when applicable.
7250 auto flagARCError = [&] {
7251 if (S.getLangOpts().ObjCAutoRefCount &&
7252 S.getSourceManager().isInSystemHeader(
7253 OffendingDecl->getLocation()))
7254 diag = diag::err_unavailable_in_arc;
7255 };
7256
7257 switch (Attr->getImplicitReason()) {
7258 case UnavailableAttr::IR_None: break;
7259
7260 case UnavailableAttr::IR_ARCForbiddenType:
7261 flagARCError();
7262 diag_available_here = diag::note_arc_forbidden_type;
7263 break;
7264
7265 case UnavailableAttr::IR_ForbiddenWeak:
7266 if (S.getLangOpts().ObjCWeakRuntime)
7267 diag_available_here = diag::note_arc_weak_disabled;
7268 else
7269 diag_available_here = diag::note_arc_weak_no_runtime;
7270 break;
7271
7272 case UnavailableAttr::IR_ARCForbiddenConversion:
7273 flagARCError();
7274 diag_available_here = diag::note_performs_forbidden_arc_conversion;
7275 break;
7276
7277 case UnavailableAttr::IR_ARCInitReturnsUnrelated:
7278 flagARCError();
7279 diag_available_here = diag::note_arc_init_returns_unrelated;
7280 break;
7281
7282 case UnavailableAttr::IR_ARCFieldWithOwnership:
7283 flagARCError();
7284 diag_available_here = diag::note_arc_field_with_ownership;
7285 break;
7286 }
7287 }
7288 }
7289 break;
7290
7291 case AR_Available:
7292 llvm_unreachable("Warning for availability of available declaration?")::llvm::llvm_unreachable_internal("Warning for availability of available declaration?"
, "/build/llvm-toolchain-snapshot-6.0~svn318882/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 7292)
;
7293 }
7294
7295 CharSourceRange UseRange;
7296 StringRef Replacement;
7297 if (K == AR_Deprecated) {
7298 if (auto Attr = OffendingDecl->getAttr<DeprecatedAttr>())
7299 Replacement = Attr->getReplacement();
7300 if (auto Attr = getAttrForPlatform(S.Context, OffendingDecl))
7301 Replacement = Attr->getReplacement();
7302
7303 if (!Replacement.empty())
7304 UseRange =
7305 CharSourceRange::getCharRange(Loc, S.getLocForEndOfToken(Loc));
7306 }
7307
7308 if (!Message.empty()) {
7309 S.Diag(Loc, diag_message) << ReferringDecl << Message
7310 << (UseRange.isValid() ?
7311 FixItHint::CreateReplacement(UseRange, Replacement) : FixItHint());
7312 if (ObjCProperty)
7313 S.Diag(ObjCProperty->getLocation(), diag::note_property_attribute)
7314 << ObjCProperty->getDeclName() << property_note_select;
7315 } else if (!UnknownObjCClass) {
7316 S.Diag(Loc, diag) << ReferringDecl
7317 << (UseRange.isValid() ?
7318 FixItHint::CreateReplacement(UseRange, Replacement) : FixItHint());
7319 if (ObjCProperty)
7320 S.Diag(ObjCProperty->getLocation(), diag::note_property_attribute)
7321 << ObjCProperty->getDeclName() << property_note_select;
7322 } else {
7323 S.Diag(Loc, diag_fwdclass_message) << ReferringDecl
7324 << (UseRange.isValid() ?
7325 FixItHint::CreateReplacement(UseRange, Replacement) : FixItHint());
7326 S.Diag(UnknownObjCClass->getLocation(), diag::note_forward_class);
7327 }
7328
7329 S.Diag(NoteLocation, diag_available_here)
7330 << OffendingDecl << available_here_select_kind;
7331}
7332
7333static void handleDelayedAvailabilityCheck(Sema &S, DelayedDiagnostic &DD,
7334 Decl *Ctx) {
7335 assert(DD.Kind == DelayedDiagnostic::Availability &&(static_cast <bool> (DD.Kind == DelayedDiagnostic::Availability
&& "Expected an availability diagnostic here") ? void
(0) : __assert_fail ("DD.Kind == DelayedDiagnostic::Availability && \"Expected an availability diagnostic here\""
, "/build/llvm-toolchain-snapshot-6.0~svn318882/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 7336, __extension__ __PRETTY_FUNCTION__))
7336 "Expected an availability diagnostic here")(static_cast <bool> (DD.Kind == DelayedDiagnostic::Availability
&& "Expected an availability diagnostic here") ? void
(0) : __assert_fail ("DD.Kind == DelayedDiagnostic::Availability && \"Expected an availability diagnostic here\""
, "/build/llvm-toolchain-snapshot-6.0~svn318882/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 7336, __extension__ __PRETTY_FUNCTION__))
;
7337
7338 DD.Triggered = true;
7339 DoEmitAvailabilityWarning(
7340 S, DD.getAvailabilityResult(), Ctx, DD.getAvailabilityReferringDecl(),
7341 DD.getAvailabilityOffendingDecl(), DD.getAvailabilityMessage(), DD.Loc,
7342 DD.getUnknownObjCClass(), DD.getObjCProperty(), false);
7343}
7344
7345void Sema::PopParsingDeclaration(ParsingDeclState state, Decl *decl) {
7346 assert(DelayedDiagnostics.getCurrentPool())(static_cast <bool> (DelayedDiagnostics.getCurrentPool(
)) ? void (0) : __assert_fail ("DelayedDiagnostics.getCurrentPool()"
, "/build/llvm-toolchain-snapshot-6.0~svn318882/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 7346, __extension__ __PRETTY_FUNCTION__))
;
7347 DelayedDiagnosticPool &poppedPool = *DelayedDiagnostics.getCurrentPool();
7348 DelayedDiagnostics.popWithoutEmitting(state);
7349
7350 // When delaying diagnostics to run in the context of a parsed
7351 // declaration, we only want to actually emit anything if parsing
7352 // succeeds.
7353 if (!decl) return;
7354
7355 // We emit all the active diagnostics in this pool or any of its
7356 // parents. In general, we'll get one pool for the decl spec
7357 // and a child pool for each declarator; in a decl group like:
7358 // deprecated_typedef foo, *bar, baz();
7359 // only the declarator pops will be passed decls. This is correct;
7360 // we really do need to consider delayed diagnostics from the decl spec
7361 // for each of the different declarations.
7362 const DelayedDiagnosticPool *pool = &poppedPool;
7363 do {
7364 for (DelayedDiagnosticPool::pool_iterator
7365 i = pool->pool_begin(), e = pool->pool_end(); i != e; ++i) {
7366 // This const_cast is a bit lame. Really, Triggered should be mutable.
7367 DelayedDiagnostic &diag = const_cast<DelayedDiagnostic&>(*i);
7368 if (diag.Triggered)
7369 continue;
7370
7371 switch (diag.Kind) {
7372 case DelayedDiagnostic::Availability:
7373 // Don't bother giving deprecation/unavailable diagnostics if
7374 // the decl is invalid.
7375 if (!decl->isInvalidDecl())
7376 handleDelayedAvailabilityCheck(*this, diag, decl);
7377 break;
7378
7379 case DelayedDiagnostic::Access:
7380 HandleDelayedAccessCheck(diag, decl);
7381 break;
7382
7383 case DelayedDiagnostic::ForbiddenType:
7384 handleDelayedForbiddenType(*this, diag, decl);
7385 break;
7386 }
7387 }
7388 } while ((pool = pool->getParent()));
7389}
7390
7391/// Given a set of delayed diagnostics, re-emit them as if they had
7392/// been delayed in the current context instead of in the given pool.
7393/// Essentially, this just moves them to the current pool.
7394void Sema::redelayDiagnostics(DelayedDiagnosticPool &pool) {
7395 DelayedDiagnosticPool *curPool = DelayedDiagnostics.getCurrentPool();
7396 assert(curPool && "re-emitting in undelayed context not supported")(static_cast <bool> (curPool && "re-emitting in undelayed context not supported"
) ? void (0) : __assert_fail ("curPool && \"re-emitting in undelayed context not supported\""
, "/build/llvm-toolchain-snapshot-6.0~svn318882/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 7396, __extension__ __PRETTY_FUNCTION__))
;
7397 curPool->steal(pool);
7398}
7399
7400static void EmitAvailabilityWarning(Sema &S, AvailabilityResult AR,
7401 const NamedDecl *ReferringDecl,
7402 const NamedDecl *OffendingDecl,
7403 StringRef Message, SourceLocation Loc,
7404 const ObjCInterfaceDecl *UnknownObjCClass,
7405 const ObjCPropertyDecl *ObjCProperty,
7406 bool ObjCPropertyAccess) {
7407 // Delay if we're currently parsing a declaration.
7408 if (S.DelayedDiagnostics.shouldDelayDiagnostics()) {
7409 S.DelayedDiagnostics.add(
7410 DelayedDiagnostic::makeAvailability(
7411 AR, Loc, ReferringDecl, OffendingDecl, UnknownObjCClass,
7412 ObjCProperty, Message, ObjCPropertyAccess));
7413 return;
7414 }
7415
7416 Decl *Ctx = cast<Decl>(S.getCurLexicalContext());
7417 DoEmitAvailabilityWarning(S, AR, Ctx, ReferringDecl, OffendingDecl,
7418 Message, Loc, UnknownObjCClass, ObjCProperty,
7419 ObjCPropertyAccess);
7420}
7421
7422namespace {
7423
7424/// Returns true if the given statement can be a body-like child of \p Parent.
7425bool isBodyLikeChildStmt(const Stmt *S, const Stmt *Parent) {
7426 switch (Parent->getStmtClass()) {
7427 case Stmt::IfStmtClass:
7428 return cast<IfStmt>(Parent)->getThen() == S ||
7429 cast<IfStmt>(Parent)->getElse() == S;
7430 case Stmt::WhileStmtClass:
7431 return cast<WhileStmt>(Parent)->getBody() == S;
7432 case Stmt::DoStmtClass:
7433 return cast<DoStmt>(Parent)->getBody() == S;
7434 case Stmt::ForStmtClass:
7435 return cast<ForStmt>(Parent)->getBody() == S;
7436 case Stmt::CXXForRangeStmtClass:
7437 return cast<CXXForRangeStmt>(Parent)->getBody() == S;
7438 case Stmt::ObjCForCollectionStmtClass:
7439 return cast<ObjCForCollectionStmt>(Parent)->getBody() == S;
7440 case Stmt::CaseStmtClass:
7441 case Stmt::DefaultStmtClass:
7442 return cast<SwitchCase>(Parent)->getSubStmt() == S;
7443 default:
7444 return false;
7445 }
7446}
7447
7448class StmtUSEFinder : public RecursiveASTVisitor<StmtUSEFinder> {
7449 const Stmt *Target;
7450
7451public:
7452 bool VisitStmt(Stmt *S) { return S != Target; }
7453
7454 /// Returns true if the given statement is present in the given declaration.
7455 static bool isContained(const Stmt *Target, const Decl *D) {
7456 StmtUSEFinder Visitor;
7457 Visitor.Target = Target;
7458 return !Visitor.TraverseDecl(const_cast<Decl *>(D));
7459 }
7460};
7461
7462/// Traverses the AST and finds the last statement that used a given
7463/// declaration.
7464class LastDeclUSEFinder : public RecursiveASTVisitor<LastDeclUSEFinder> {
7465 const Decl *D;
7466
7467public:
7468 bool VisitDeclRefExpr(DeclRefExpr *DRE) {
7469 if (DRE->getDecl() == D)
7470 return false;
7471 return true;
7472 }
7473
7474 static const Stmt *findLastStmtThatUsesDecl(const Decl *D,
7475 const CompoundStmt *Scope) {
7476 LastDeclUSEFinder Visitor;
7477 Visitor.D = D;
7478 for (auto I = Scope->body_rbegin(), E = Scope->body_rend(); I != E; ++I) {
7479 const Stmt *S = *I;
7480 if (!Visitor.TraverseStmt(const_cast<Stmt *>(S)))
7481 return S;
7482 }
7483 return nullptr;
7484 }
7485};
7486
7487/// \brief This class implements -Wunguarded-availability.
7488///
7489/// This is done with a traversal of the AST of a function that makes reference
7490/// to a partially available declaration. Whenever we encounter an \c if of the
7491/// form: \c if(@available(...)), we use the version from the condition to visit
7492/// the then statement.
7493class DiagnoseUnguardedAvailability
7494 : public RecursiveASTVisitor<DiagnoseUnguardedAvailability> {
7495 typedef RecursiveASTVisitor<DiagnoseUnguardedAvailability> Base;
7496
7497 Sema &SemaRef;
7498 Decl *Ctx;
7499
7500 /// Stack of potentially nested 'if (@available(...))'s.
7501 SmallVector<VersionTuple, 8> AvailabilityStack;
7502 SmallVector<const Stmt *, 16> StmtStack;
7503
7504 void DiagnoseDeclAvailability(NamedDecl *D, SourceRange Range);
7505
7506public:
7507 DiagnoseUnguardedAvailability(Sema &SemaRef, Decl *Ctx)
7508 : SemaRef(SemaRef), Ctx(Ctx) {
7509 AvailabilityStack.push_back(
7510 SemaRef.Context.getTargetInfo().getPlatformMinVersion());
7511 }
7512
7513 bool TraverseDecl(Decl *D) {
7514 // Avoid visiting nested functions to prevent duplicate warnings.
7515 if (!D || isa<FunctionDecl>(D))
7516 return true;
7517 return Base::TraverseDecl(D);
7518 }
7519
7520 bool TraverseStmt(Stmt *S) {
7521 if (!S)
7522 return true;
7523 StmtStack.push_back(S);
7524 bool Result = Base::TraverseStmt(S);
7525 StmtStack.pop_back();
7526 return Result;
7527 }
7528
7529 void IssueDiagnostics(Stmt *S) { TraverseStmt(S); }
7530
7531 bool TraverseIfStmt(IfStmt *If);
7532
7533 bool TraverseLambdaExpr(LambdaExpr *E) { return true; }
7534
7535 // for 'case X:' statements, don't bother looking at the 'X'; it can't lead
7536 // to any useful diagnostics.
7537 bool TraverseCaseStmt(CaseStmt *CS) { return TraverseStmt(CS->getSubStmt()); }
7538
7539 bool VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *PRE) {
7540 if (PRE->isClassReceiver())
7541 DiagnoseDeclAvailability(PRE->getClassReceiver(), PRE->getReceiverLocation());
7542 return true;
7543 }
7544
7545 bool VisitObjCMessageExpr(ObjCMessageExpr *Msg) {
7546 if (ObjCMethodDecl *D = Msg->getMethodDecl())
7547 DiagnoseDeclAvailability(
7548 D, SourceRange(Msg->getSelectorStartLoc(), Msg->getLocEnd()));
7549 return true;
7550 }
7551
7552 bool VisitDeclRefExpr(DeclRefExpr *DRE) {
7553 DiagnoseDeclAvailability(DRE->getDecl(),
7554 SourceRange(DRE->getLocStart(), DRE->getLocEnd()));
7555 return true;
7556 }
7557
7558 bool VisitMemberExpr(MemberExpr *ME) {
7559 DiagnoseDeclAvailability(ME->getMemberDecl(),
7560 SourceRange(ME->getLocStart(), ME->getLocEnd()));
7561 return true;
7562 }
7563
7564 bool VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *E) {
7565 SemaRef.Diag(E->getLocStart(), diag::warn_at_available_unchecked_use)
7566 << (!SemaRef.getLangOpts().ObjC1);
7567 return true;
7568 }
7569
7570 bool VisitTypeLoc(TypeLoc Ty);
7571};
7572
7573void DiagnoseUnguardedAvailability::DiagnoseDeclAvailability(
7574 NamedDecl *D, SourceRange Range) {
7575 AvailabilityResult Result;
7576 const NamedDecl *OffendingDecl;
7577 std::tie(Result, OffendingDecl) =
7578 ShouldDiagnoseAvailabilityOfDecl(D, nullptr);
7579 if (Result != AR_Available) {
7580 // All other diagnostic kinds have already been handled in
7581 // DiagnoseAvailabilityOfDecl.
7582 if (Result != AR_NotYetIntroduced)
7583 return;
7584
7585 const AvailabilityAttr *AA =
7586 getAttrForPlatform(SemaRef.getASTContext(), OffendingDecl);
7587 VersionTuple Introduced = AA->getIntroduced();
7588
7589 if (AvailabilityStack.back() >= Introduced)
7590 return;
7591
7592 // If the context of this function is less available than D, we should not
7593 // emit a diagnostic.
7594 if (!ShouldDiagnoseAvailabilityInContext(SemaRef, Result, Introduced, Ctx))
7595 return;
7596
7597 // We would like to emit the diagnostic even if -Wunguarded-availability is
7598 // not specified for deployment targets >= to iOS 11 or equivalent or
7599 // for declarations that were introduced in iOS 11 (macOS 10.13, ...) or
7600 // later.
7601 unsigned DiagKind =
7602 shouldDiagnoseAvailabilityByDefault(
7603 SemaRef.Context,
7604 SemaRef.Context.getTargetInfo().getPlatformMinVersion(), Introduced)
7605 ? diag::warn_unguarded_availability_new
7606 : diag::warn_unguarded_availability;
7607
7608 SemaRef.Diag(Range.getBegin(), DiagKind)
7609 << Range << D
7610 << AvailabilityAttr::getPrettyPlatformName(
7611 SemaRef.getASTContext().getTargetInfo().getPlatformName())
7612 << Introduced.getAsString();
7613
7614 SemaRef.Diag(OffendingDecl->getLocation(),
7615 diag::note_availability_specified_here)
7616 << OffendingDecl << /* partial */ 3;
7617
7618 auto FixitDiag =
7619 SemaRef.Diag(Range.getBegin(), diag::note_unguarded_available_silence)
7620 << Range << D
7621 << (SemaRef.getLangOpts().ObjC1 ? /*@available*/ 0
7622 : /*__builtin_available*/ 1);
7623
7624 // Find the statement which should be enclosed in the if @available check.
7625 if (StmtStack.empty())
7626 return;
7627 const Stmt *StmtOfUse = StmtStack.back();
7628 const CompoundStmt *Scope = nullptr;
7629 for (const Stmt *S : llvm::reverse(StmtStack)) {
7630 if (const auto *CS = dyn_cast<CompoundStmt>(S)) {
7631 Scope = CS;
7632 break;
7633 }
7634 if (isBodyLikeChildStmt(StmtOfUse, S)) {
7635 // The declaration won't be seen outside of the statement, so we don't
7636 // have to wrap the uses of any declared variables in if (@available).
7637 // Therefore we can avoid setting Scope here.
7638 break;
7639 }
7640 StmtOfUse = S;
7641 }
7642 const Stmt *LastStmtOfUse = nullptr;
7643 if (isa<DeclStmt>(StmtOfUse) && Scope) {
7644 for (const Decl *D : cast<DeclStmt>(StmtOfUse)->decls()) {
7645 if (StmtUSEFinder::isContained(StmtStack.back(), D)) {
7646 LastStmtOfUse = LastDeclUSEFinder::findLastStmtThatUsesDecl(D, Scope);
7647 break;
7648 }
7649 }
7650 }
7651
7652 const SourceManager &SM = SemaRef.getSourceManager();
7653 SourceLocation IfInsertionLoc =
7654 SM.getExpansionLoc(StmtOfUse->getLocStart());
7655 SourceLocation StmtEndLoc =
7656 SM.getExpansionRange(
7657 (LastStmtOfUse ? LastStmtOfUse : StmtOfUse)->getLocEnd())
7658 .second;
7659 if (SM.getFileID(IfInsertionLoc) != SM.getFileID(StmtEndLoc))
7660 return;
7661
7662 StringRef Indentation = Lexer::getIndentationForLine(IfInsertionLoc, SM);
7663 const char *ExtraIndentation = " ";
7664 std::string FixItString;
7665 llvm::raw_string_ostream FixItOS(FixItString);
7666 FixItOS << "if (" << (SemaRef.getLangOpts().ObjC1 ? "@available"
7667 : "__builtin_available")
7668 << "("
7669 << AvailabilityAttr::getPlatformNameSourceSpelling(
7670 SemaRef.getASTContext().getTargetInfo().getPlatformName())
7671 << " " << Introduced.getAsString() << ", *)) {\n"
7672 << Indentation << ExtraIndentation;
7673 FixitDiag << FixItHint::CreateInsertion(IfInsertionLoc, FixItOS.str());
7674 SourceLocation ElseInsertionLoc = Lexer::findLocationAfterToken(
7675 StmtEndLoc, tok::semi, SM, SemaRef.getLangOpts(),
7676 /*SkipTrailingWhitespaceAndNewLine=*/false);
7677 if (ElseInsertionLoc.isInvalid())
7678 ElseInsertionLoc =
7679 Lexer::getLocForEndOfToken(StmtEndLoc, 0, SM, SemaRef.getLangOpts());
7680 FixItOS.str().clear();
7681 FixItOS << "\n"
7682 << Indentation << "} else {\n"
7683 << Indentation << ExtraIndentation
7684 << "// Fallback on earlier versions\n"
7685 << Indentation << "}";
7686 FixitDiag << FixItHint::CreateInsertion(ElseInsertionLoc, FixItOS.str());
7687 }
7688}
7689
7690bool DiagnoseUnguardedAvailability::VisitTypeLoc(TypeLoc Ty) {
7691 const Type *TyPtr = Ty.getTypePtr();
7692 SourceRange Range{Ty.getBeginLoc(), Ty.getEndLoc()};
7693
7694 if (Range.isInvalid())
7695 return true;
7696
7697 if (const TagType *TT = dyn_cast<TagType>(TyPtr)) {
7698 TagDecl *TD = TT->getDecl();
7699 DiagnoseDeclAvailability(TD, Range);
7700
7701 } else if (const TypedefType *TD = dyn_cast<TypedefType>(TyPtr)) {
7702 TypedefNameDecl *D = TD->getDecl();
7703 DiagnoseDeclAvailability(D, Range);
7704
7705 } else if (const auto *ObjCO = dyn_cast<ObjCObjectType>(TyPtr)) {
7706 if (NamedDecl *D = ObjCO->getInterface())
7707 DiagnoseDeclAvailability(D, Range);
7708 }
7709
7710 return true;
7711}
7712
7713bool DiagnoseUnguardedAvailability::TraverseIfStmt(IfStmt *If) {
7714 VersionTuple CondVersion;
7715 if (auto *E = dyn_cast<ObjCAvailabilityCheckExpr>(If->getCond())) {
7716 CondVersion = E->getVersion();
7717
7718 // If we're using the '*' case here or if this check is redundant, then we
7719 // use the enclosing version to check both branches.
7720 if (CondVersion.empty() || CondVersion <= AvailabilityStack.back())
7721 return TraverseStmt(If->getThen()) && TraverseStmt(If->getElse());
7722 } else {
7723 // This isn't an availability checking 'if', we can just continue.
7724 return Base::TraverseIfStmt(If);
7725 }
7726
7727 AvailabilityStack.push_back(CondVersion);
7728 bool ShouldContinue = TraverseStmt(If->getThen());
7729 AvailabilityStack.pop_back();
7730
7731 return ShouldContinue && TraverseStmt(If->getElse());
7732}
7733
7734} // end anonymous namespace
7735
7736void Sema::DiagnoseUnguardedAvailabilityViolations(Decl *D) {
7737 Stmt *Body = nullptr;
7738
7739 if (auto *FD = D->getAsFunction()) {
7740 // FIXME: We only examine the pattern decl for availability violations now,
7741 // but we should also examine instantiated templates.
7742 if (FD->isTemplateInstantiation())
7743 return;
7744
7745 Body = FD->getBody();
7746 } else if (auto *MD = dyn_cast<ObjCMethodDecl>(D))
7747 Body = MD->getBody();
7748 else if (auto *BD = dyn_cast<BlockDecl>(D))
7749 Body = BD->getBody();
7750
7751 assert(Body && "Need a body here!")(static_cast <bool> (Body && "Need a body here!"
) ? void (0) : __assert_fail ("Body && \"Need a body here!\""
, "/build/llvm-toolchain-snapshot-6.0~svn318882/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 7751, __extension__ __PRETTY_FUNCTION__))
;
7752
7753 DiagnoseUnguardedAvailability(*this, D).IssueDiagnostics(Body);
7754}
7755
7756void Sema::DiagnoseAvailabilityOfDecl(NamedDecl *D, SourceLocation Loc,
7757 const ObjCInterfaceDecl *UnknownObjCClass,
7758 bool ObjCPropertyAccess,
7759 bool AvoidPartialAvailabilityChecks) {
7760 std::string Message;
7761 AvailabilityResult Result;
7762 const NamedDecl* OffendingDecl;
7763 // See if this declaration is unavailable, deprecated, or partial.
7764 std::tie(Result, OffendingDecl) = ShouldDiagnoseAvailabilityOfDecl(D, &Message);
7765 if (Result == AR_Available)
7766 return;
7767
7768 if (Result == AR_NotYetIntroduced) {
7769 if (AvoidPartialAvailabilityChecks)
7770 return;
7771
7772 // We need to know the @available context in the current function to
7773 // diagnose this use, let DiagnoseUnguardedAvailabilityViolations do that
7774 // when we're done parsing the current function.
7775 if (getCurFunctionOrMethodDecl()) {
7776 getEnclosingFunction()->HasPotentialAvailabilityViolations = true;
7777 return;
7778 } else if (getCurBlock() || getCurLambda()) {
7779 getCurFunction()->HasPotentialAvailabilityViolations = true;
7780 return;
7781 }
7782 }
7783
7784 const ObjCPropertyDecl *ObjCPDecl = nullptr;
7785 if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) {
7786 if (const ObjCPropertyDecl *PD = MD->findPropertyDecl()) {
7787 AvailabilityResult PDeclResult = PD->getAvailability(nullptr);
7788 if (PDeclResult == Result)
7789 ObjCPDecl = PD;
7790 }
7791 }
7792
7793 EmitAvailabilityWarning(*this, Result, D, OffendingDecl, Message, Loc,
7794 UnknownObjCClass, ObjCPDecl, ObjCPropertyAccess);
7795}

/build/llvm-toolchain-snapshot-6.0~svn318882/tools/clang/include/clang/Sema/Sema.h

1//===--- Sema.h - Semantic Analysis & AST Building --------------*- C++ -*-===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file defines the Sema class, which performs semantic analysis and
11// builds ASTs.
12//
13//===----------------------------------------------------------------------===//
14
15#ifndef LLVM_CLANG_SEMA_SEMA_H
16#define LLVM_CLANG_SEMA_SEMA_H
17
18#include "clang/AST/Attr.h"
19#include "clang/AST/Availability.h"
20#include "clang/AST/DeclarationName.h"
21#include "clang/AST/DeclTemplate.h"
22#include "clang/AST/Expr.h"
23#include "clang/AST/ExprObjC.h"
24#include "clang/AST/ExternalASTSource.h"
25#include "clang/AST/LocInfoType.h"
26#include "clang/AST/MangleNumberingContext.h"
27#include "clang/AST/NSAPI.h"
28#include "clang/AST/PrettyPrinter.h"
29#include "clang/AST/StmtCXX.h"
30#include "clang/AST/TypeLoc.h"
31#include "clang/AST/TypeOrdering.h"
32#include "clang/Basic/ExpressionTraits.h"
33#include "clang/Basic/LangOptions.h"
34#include "clang/Basic/Module.h"
35#include "clang/Basic/OpenMPKinds.h"
36#include "clang/Basic/PragmaKinds.h"
37#include "clang/Basic/Specifiers.h"
38#include "clang/Basic/TemplateKinds.h"
39#include "clang/Basic/TypeTraits.h"
40#include "clang/Sema/AnalysisBasedWarnings.h"
41#include "clang/Sema/CleanupInfo.h"
42#include "clang/Sema/DeclSpec.h"
43#include "clang/Sema/ExternalSemaSource.h"
44#include "clang/Sema/IdentifierResolver.h"
45#include "clang/Sema/ObjCMethodList.h"
46#include "clang/Sema/Ownership.h"
47#include "clang/Sema/Scope.h"
48#include "clang/Sema/ScopeInfo.h"
49#include "clang/Sema/TypoCorrection.h"
50#include "clang/Sema/Weak.h"
51#include "llvm/ADT/ArrayRef.h"
52#include "llvm/ADT/Optional.h"
53#include "llvm/ADT/SetVector.h"
54#include "llvm/ADT/SmallPtrSet.h"
55#include "llvm/ADT/SmallVector.h"
56#include "llvm/ADT/TinyPtrVector.h"
57#include <deque>
58#include <memory>
59#include <string>
60#include <vector>
61
62namespace llvm {
63 class APSInt;
64 template <typename ValueT> struct DenseMapInfo;
65 template <typename ValueT, typename ValueInfoT> class DenseSet;
66 class SmallBitVector;
67 struct InlineAsmIdentifierInfo;
68}
69
70namespace clang {
71 class ADLResult;
72 class ASTConsumer;
73 class ASTContext;
74 class ASTMutationListener;
75 class ASTReader;
76 class ASTWriter;
77 class ArrayType;
78 class AttributeList;
79 class BindingDecl;
80 class BlockDecl;
81 class CapturedDecl;
82 class CXXBasePath;
83 class CXXBasePaths;
84 class CXXBindTemporaryExpr;
85 typedef SmallVector<CXXBaseSpecifier*, 4> CXXCastPath;
86 class CXXConstructorDecl;
87 class CXXConversionDecl;
88 class CXXDeleteExpr;
89 class CXXDestructorDecl;
90 class CXXFieldCollector;
91 class CXXMemberCallExpr;
92 class CXXMethodDecl;
93 class CXXScopeSpec;
94 class CXXTemporary;
95 class CXXTryStmt;
96 class CallExpr;
97 class ClassTemplateDecl;
98 class ClassTemplatePartialSpecializationDecl;
99 class ClassTemplateSpecializationDecl;
100 class VarTemplatePartialSpecializationDecl;
101 class CodeCompleteConsumer;
102 class CodeCompletionAllocator;
103 class CodeCompletionTUInfo;
104 class CodeCompletionResult;
105 class CoroutineBodyStmt;
106 class Decl;
107 class DeclAccessPair;
108 class DeclContext;
109 class DeclRefExpr;
110 class DeclaratorDecl;
111 class DeducedTemplateArgument;
112 class DependentDiagnostic;
113 class DesignatedInitExpr;
114 class Designation;
115 class EnableIfAttr;
116 class EnumConstantDecl;
117 class Expr;
118 class ExtVectorType;
119 class FormatAttr;
120 class FriendDecl;
121 class FunctionDecl;
122 class FunctionProtoType;
123 class FunctionTemplateDecl;
124 class ImplicitConversionSequence;
125 typedef MutableArrayRef<ImplicitConversionSequence> ConversionSequenceList;
126 class InitListExpr;
127 class InitializationKind;
128 class InitializationSequence;
129 class InitializedEntity;
130 class IntegerLiteral;
131 class LabelStmt;
132 class LambdaExpr;
133 class LangOptions;
134 class LocalInstantiationScope;
135 class LookupResult;
136 class MacroInfo;
137 typedef ArrayRef<std::pair<IdentifierInfo *, SourceLocation>> ModuleIdPath;
138 class ModuleLoader;
139 class MultiLevelTemplateArgumentList;
140 class NamedDecl;
141 class ObjCCategoryDecl;
142 class ObjCCategoryImplDecl;
143 class ObjCCompatibleAliasDecl;
144 class ObjCContainerDecl;
145 class ObjCImplDecl;
146 class ObjCImplementationDecl;
147 class ObjCInterfaceDecl;
148 class ObjCIvarDecl;
149 template <class T> class ObjCList;
150 class ObjCMessageExpr;
151 class ObjCMethodDecl;
152 class ObjCPropertyDecl;
153 class ObjCProtocolDecl;
154 class OMPThreadPrivateDecl;
155 class OMPDeclareReductionDecl;
156 class OMPDeclareSimdDecl;
157 class OMPClause;
158 struct OverloadCandidate;
159 class OverloadCandidateSet;
160 class OverloadExpr;
161 class ParenListExpr;
162 class ParmVarDecl;
163 class Preprocessor;
164 class PseudoDestructorTypeStorage;
165 class PseudoObjectExpr;
166 class QualType;
167 class StandardConversionSequence;
168 class Stmt;
169 class StringLiteral;
170 class SwitchStmt;
171 class TemplateArgument;
172 class TemplateArgumentList;
173 class TemplateArgumentLoc;
174 class TemplateDecl;
175 class TemplateParameterList;
176 class TemplatePartialOrderingContext;
177 class TemplateTemplateParmDecl;
178 class Token;
179 class TypeAliasDecl;
180 class TypedefDecl;
181 class TypedefNameDecl;
182 class TypeLoc;
183 class TypoCorrectionConsumer;
184 class UnqualifiedId;
185 class UnresolvedLookupExpr;
186 class UnresolvedMemberExpr;
187 class UnresolvedSetImpl;
188 class UnresolvedSetIterator;
189 class UsingDecl;
190 class UsingShadowDecl;
191 class ValueDecl;
192 class VarDecl;
193 class VarTemplateSpecializationDecl;
194 class VisibilityAttr;
195 class VisibleDeclConsumer;
196 class IndirectFieldDecl;
197 struct DeductionFailureInfo;
198 class TemplateSpecCandidateSet;
199
200namespace sema {
201 class AccessedEntity;
202 class BlockScopeInfo;
203 class CapturedRegionScopeInfo;
204 class CapturingScopeInfo;
205 class CompoundScopeInfo;
206 class DelayedDiagnostic;
207 class DelayedDiagnosticPool;
208 class FunctionScopeInfo;
209 class LambdaScopeInfo;
210 class PossiblyUnreachableDiag;
211 class SemaPPCallbacks;
212 class TemplateDeductionInfo;
213}
214
215namespace threadSafety {
216 class BeforeSet;
217 void threadSafetyCleanup(BeforeSet* Cache);
218}
219
220// FIXME: No way to easily map from TemplateTypeParmTypes to
221// TemplateTypeParmDecls, so we have this horrible PointerUnion.
222typedef std::pair<llvm::PointerUnion<const TemplateTypeParmType*, NamedDecl*>,
223 SourceLocation> UnexpandedParameterPack;
224
225/// Describes whether we've seen any nullability information for the given
226/// file.
227struct FileNullability {
228 /// The first pointer declarator (of any pointer kind) in the file that does
229 /// not have a corresponding nullability annotation.
230 SourceLocation PointerLoc;
231
232 /// The end location for the first pointer declarator in the file. Used for
233 /// placing fix-its.
234 SourceLocation PointerEndLoc;
235
236 /// Which kind of pointer declarator we saw.
237 uint8_t PointerKind;
238
239 /// Whether we saw any type nullability annotations in the given file.
240 bool SawTypeNullability = false;
241};
242
243/// A mapping from file IDs to a record of whether we've seen nullability
244/// information in that file.
245class FileNullabilityMap {
246 /// A mapping from file IDs to the nullability information for each file ID.
247 llvm::DenseMap<FileID, FileNullability> Map;
248
249 /// A single-element cache based on the file ID.
250 struct {
251 FileID File;
252 FileNullability Nullability;
253 } Cache;
254
255public:
256 FileNullability &operator[](FileID file) {
257 // Check the single-element cache.
258 if (file == Cache.File)
259 return Cache.Nullability;
260
261 // It's not in the single-element cache; flush the cache if we have one.
262 if (!Cache.File.isInvalid()) {
263 Map[Cache.File] = Cache.Nullability;
264 }
265
266 // Pull this entry into the cache.
267 Cache.File = file;
268 Cache.Nullability = Map[file];
269 return Cache.Nullability;
270 }
271};
272
273/// Sema - This implements semantic analysis and AST building for C.
274class Sema {
275 Sema(const Sema &) = delete;
276 void operator=(const Sema &) = delete;
277
278 ///\brief Source of additional semantic information.
279 ExternalSemaSource *ExternalSource;
280
281 ///\brief Whether Sema has generated a multiplexer and has to delete it.
282 bool isMultiplexExternalSource;
283
284 static bool mightHaveNonExternalLinkage(const DeclaratorDecl *FD);
285
286 bool isVisibleSlow(const NamedDecl *D);
287
288 /// Determine whether two declarations should be linked together, given that
289 /// the old declaration might not be visible and the new declaration might
290 /// not have external linkage.
291 bool shouldLinkPossiblyHiddenDecl(const NamedDecl *Old,
292 const NamedDecl *New) {
293 if (isVisible(Old))
294 return true;
295 // See comment in below overload for why it's safe to compute the linkage
296 // of the new declaration here.
297 if (New->isExternallyDeclarable()) {
298 assert(Old->isExternallyDeclarable() &&(static_cast <bool> (Old->isExternallyDeclarable() &&
"should not have found a non-externally-declarable previous decl"
) ? void (0) : __assert_fail ("Old->isExternallyDeclarable() && \"should not have found a non-externally-declarable previous decl\""
, "/build/llvm-toolchain-snapshot-6.0~svn318882/tools/clang/include/clang/Sema/Sema.h"
, 299, __extension__ __PRETTY_FUNCTION__))
299 "should not have found a non-externally-declarable previous decl")(static_cast <bool> (Old->isExternallyDeclarable() &&
"should not have found a non-externally-declarable previous decl"
) ? void (0) : __assert_fail ("Old->isExternallyDeclarable() && \"should not have found a non-externally-declarable previous decl\""
, "/build/llvm-toolchain-snapshot-6.0~svn318882/tools/clang/include/clang/Sema/Sema.h"
, 299, __extension__ __PRETTY_FUNCTION__))
;
300 return true;
301 }
302 return false;
303 }
304 bool shouldLinkPossiblyHiddenDecl(LookupResult &Old, const NamedDecl *New);
305
306public:
307 typedef OpaquePtr<DeclGroupRef> DeclGroupPtrTy;
308 typedef OpaquePtr<TemplateName> TemplateTy;
309 typedef OpaquePtr<QualType> TypeTy;
310
311 OpenCLOptions OpenCLFeatures;
312 FPOptions FPFeatures;
313
314 const LangOptions &LangOpts;
315 Preprocessor &PP;
316 ASTContext &Context;
317 ASTConsumer &Consumer;
318 DiagnosticsEngine &Diags;
319 SourceManager &SourceMgr;
320
321 /// \brief Flag indicating whether or not to collect detailed statistics.
322 bool CollectStats;
323
324 /// \brief Code-completion consumer.
325 CodeCompleteConsumer *CodeCompleter;
326
327 /// CurContext - This is the current declaration context of parsing.
328 DeclContext *CurContext;
329
330 /// \brief Generally null except when we temporarily switch decl contexts,
331 /// like in \see ActOnObjCTemporaryExitContainerContext.
332 DeclContext *OriginalLexicalContext;
333
334 /// VAListTagName - The declaration name corresponding to __va_list_tag.
335 /// This is used as part of a hack to omit that class from ADL results.
336 DeclarationName VAListTagName;
337
338 bool MSStructPragmaOn; // True when \#pragma ms_struct on
339
340 /// \brief Controls member pointer representation format under the MS ABI.
341 LangOptions::PragmaMSPointersToMembersKind
342 MSPointerToMemberRepresentationMethod;
343
344 /// Stack of active SEH __finally scopes. Can be empty.
345 SmallVector<Scope*, 2> CurrentSEHFinally;
346
347 /// \brief Source location for newly created implicit MSInheritanceAttrs
348 SourceLocation ImplicitMSInheritanceAttrLoc;
349
350 /// \brief pragma clang section kind
351 enum PragmaClangSectionKind {
352 PCSK_Invalid = 0,
353 PCSK_BSS = 1,
354 PCSK_Data = 2,
355 PCSK_Rodata = 3,
356 PCSK_Text = 4
357 };
358
359 enum PragmaClangSectionAction {
360 PCSA_Set = 0,
361 PCSA_Clear = 1
362 };
363
364 struct PragmaClangSection {
365 std::string SectionName;
366 bool Valid = false;
367 SourceLocation PragmaLocation;
368
369 void Act(SourceLocation PragmaLocation,
370 PragmaClangSectionAction Action,
371 StringLiteral* Name);
372 };
373
374 PragmaClangSection PragmaClangBSSSection;
375 PragmaClangSection PragmaClangDataSection;
376 PragmaClangSection PragmaClangRodataSection;
377 PragmaClangSection PragmaClangTextSection;
378
379 enum PragmaMsStackAction {
380 PSK_Reset = 0x0, // #pragma ()
381 PSK_Set = 0x1, // #pragma (value)
382 PSK_Push = 0x2, // #pragma (push[, id])
383 PSK_Pop = 0x4, // #pragma (pop[, id])
384 PSK_Show = 0x8, // #pragma (show) -- only for "pack"!
385 PSK_Push_Set = PSK_Push | PSK_Set, // #pragma (push[, id], value)
386 PSK_Pop_Set = PSK_Pop | PSK_Set, // #pragma (pop[, id], value)
387 };
388
389 template<typename ValueType>
390 struct PragmaStack {
391 struct Slot {
392 llvm::StringRef StackSlotLabel;
393 ValueType Value;
394 SourceLocation PragmaLocation;
395 SourceLocation PragmaPushLocation;
396 Slot(llvm::StringRef StackSlotLabel, ValueType Value,
397 SourceLocation PragmaLocation, SourceLocation PragmaPushLocation)
398 : StackSlotLabel(StackSlotLabel), Value(Value),
399 PragmaLocation(PragmaLocation),
400 PragmaPushLocation(PragmaPushLocation) {}
401 };
402 void Act(SourceLocation PragmaLocation,
403 PragmaMsStackAction Action,
404 llvm::StringRef StackSlotLabel,
405 ValueType Value);
406
407 // MSVC seems to add artificial slots to #pragma stacks on entering a C++
408 // method body to restore the stacks on exit, so it works like this:
409 //
410 // struct S {
411 // #pragma <name>(push, InternalPragmaSlot, <current_pragma_value>)
412 // void Method {}
413 // #pragma <name>(pop, InternalPragmaSlot)
414 // };
415 //
416 // It works even with #pragma vtordisp, although MSVC doesn't support
417 // #pragma vtordisp(push [, id], n)
418 // syntax.
419 //
420 // Push / pop a named sentinel slot.
421 void SentinelAction(PragmaMsStackAction Action, StringRef Label) {
422 assert((Action == PSK_Push || Action == PSK_Pop) &&(static_cast <bool> ((Action == PSK_Push || Action == PSK_Pop
) && "Can only push / pop #pragma stack sentinels!") ?
void (0) : __assert_fail ("(Action == PSK_Push || Action == PSK_Pop) && \"Can only push / pop #pragma stack sentinels!\""
, "/build/llvm-toolchain-snapshot-6.0~svn318882/tools/clang/include/clang/Sema/Sema.h"
, 423, __extension__ __PRETTY_FUNCTION__))
423 "Can only push / pop #pragma stack sentinels!")(static_cast <bool> ((Action == PSK_Push || Action == PSK_Pop
) && "Can only push / pop #pragma stack sentinels!") ?
void (0) : __assert_fail ("(Action == PSK_Push || Action == PSK_Pop) && \"Can only push / pop #pragma stack sentinels!\""
, "/build/llvm-toolchain-snapshot-6.0~svn318882/tools/clang/include/clang/Sema/Sema.h"
, 423, __extension__ __PRETTY_FUNCTION__))
;
424 Act(CurrentPragmaLocation, Action, Label, CurrentValue);
425 }
426
427 // Constructors.
428 explicit PragmaStack(const ValueType &Default)
429 : DefaultValue(Default), CurrentValue(Default) {}
430
431 bool hasValue() const { return CurrentValue != DefaultValue; }
432
433 SmallVector<Slot, 2> Stack;
434 ValueType DefaultValue; // Value used for PSK_Reset action.
435 ValueType CurrentValue;
436 SourceLocation CurrentPragmaLocation;
437 };
438 // FIXME: We should serialize / deserialize these if they occur in a PCH (but
439 // we shouldn't do so if they're in a module).
440
441 /// \brief Whether to insert vtordisps prior to virtual bases in the Microsoft
442 /// C++ ABI. Possible values are 0, 1, and 2, which mean:
443 ///
444 /// 0: Suppress all vtordisps
445 /// 1: Insert vtordisps in the presence of vbase overrides and non-trivial
446 /// structors
447 /// 2: Always insert vtordisps to support RTTI on partially constructed
448 /// objects
449 PragmaStack<MSVtorDispAttr::Mode> VtorDispStack;
450 // #pragma pack.
451 // Sentinel to represent when the stack is set to mac68k alignment.
452 static const unsigned kMac68kAlignmentSentinel = ~0U;
453 PragmaStack<unsigned> PackStack;
454 // The current #pragma pack values and locations at each #include.
455 struct PackIncludeState {
456 unsigned CurrentValue;
457 SourceLocation CurrentPragmaLocation;
458 bool HasNonDefaultValue, ShouldWarnOnInclude;
459 };
460 SmallVector<PackIncludeState, 8> PackIncludeStack;
461 // Segment #pragmas.
462 PragmaStack<StringLiteral *> DataSegStack;
463 PragmaStack<StringLiteral *> BSSSegStack;
464 PragmaStack<StringLiteral *> ConstSegStack;
465 PragmaStack<StringLiteral *> CodeSegStack;
466
467 // RAII object to push / pop sentinel slots for all MS #pragma stacks.
468 // Actions should be performed only if we enter / exit a C++ method body.
469 class PragmaStackSentinelRAII {
470 public:
471 PragmaStackSentinelRAII(Sema &S, StringRef SlotLabel, bool ShouldAct);
472 ~PragmaStackSentinelRAII();
473
474