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