Bug Summary

File:build-llvm/tools/clang/include/clang/AST/Attrs.inc
Warning:line 9636, column 9
Null pointer passed as an argument to a 'nonnull' parameter

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name SemaDeclAttr.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mthread-model posix -relaxed-aliasing -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-9/lib/clang/9.0.0 -D CLANG_VENDOR="Debian " -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-9~svn362543/tools/clang/include -I /build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-9~svn362543/build-llvm/include -I /build/llvm-toolchain-snapshot-9~svn362543/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/include/clang/9.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-9/lib/clang/9.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/lib/Sema -fdebug-prefix-map=/build/llvm-toolchain-snapshot-9~svn362543=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2019-06-05-060531-1271-1 -x c++ /build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclAttr.cpp -faddrsig

/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclAttr.cpp

1//===--- SemaDeclAttr.cpp - Declaration Attribute Handling ----------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements decl-related attribute processing.
10//
11//===----------------------------------------------------------------------===//
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/Basic/CharInfo.h"
25#include "clang/Basic/SourceManager.h"
26#include "clang/Basic/TargetInfo.h"
27#include "clang/Lex/Preprocessor.h"
28#include "clang/Sema/DeclSpec.h"
29#include "clang/Sema/DelayedDiagnostic.h"
30#include "clang/Sema/Initialization.h"
31#include "clang/Sema/Lookup.h"
32#include "clang/Sema/Scope.h"
33#include "clang/Sema/ScopeInfo.h"
34#include "clang/Sema/SemaInternal.h"
35#include "llvm/ADT/STLExtras.h"
36#include "llvm/ADT/StringExtras.h"
37#include "llvm/Support/MathExtras.h"
38
39using namespace clang;
40using namespace sema;
41
42namespace AttributeLangSupport {
43 enum LANG {
44 C,
45 Cpp,
46 ObjC
47 };
48} // end namespace AttributeLangSupport
49
50//===----------------------------------------------------------------------===//
51// Helper functions
52//===----------------------------------------------------------------------===//
53
54/// isFunctionOrMethod - Return true if the given decl has function
55/// type (function or function-typed variable) or an Objective-C
56/// method.
57static bool isFunctionOrMethod(const Decl *D) {
58 return (D->getFunctionType() != nullptr) || isa<ObjCMethodDecl>(D);
59}
60
61/// Return true if the given decl has function type (function or
62/// function-typed variable) or an Objective-C method or a block.
63static bool isFunctionOrMethodOrBlock(const Decl *D) {
64 return isFunctionOrMethod(D) || isa<BlockDecl>(D);
65}
66
67/// Return true if the given decl has a declarator that should have
68/// been processed by Sema::GetTypeForDeclarator.
69static bool hasDeclarator(const Decl *D) {
70 // In some sense, TypedefDecl really *ought* to be a DeclaratorDecl.
71 return isa<DeclaratorDecl>(D) || isa<BlockDecl>(D) || isa<TypedefNameDecl>(D) ||
72 isa<ObjCPropertyDecl>(D);
73}
74
75/// hasFunctionProto - Return true if the given decl has a argument
76/// information. This decl should have already passed
77/// isFunctionOrMethod or isFunctionOrMethodOrBlock.
78static bool hasFunctionProto(const Decl *D) {
79 if (const FunctionType *FnTy = D->getFunctionType())
80 return isa<FunctionProtoType>(FnTy);
81 return isa<ObjCMethodDecl>(D) || isa<BlockDecl>(D);
82}
83
84/// getFunctionOrMethodNumParams - Return number of function or method
85/// parameters. It is an error to call this on a K&R function (use
86/// hasFunctionProto first).
87static unsigned getFunctionOrMethodNumParams(const Decl *D) {
88 if (const FunctionType *FnTy = D->getFunctionType())
89 return cast<FunctionProtoType>(FnTy)->getNumParams();
90 if (const auto *BD = dyn_cast<BlockDecl>(D))
91 return BD->getNumParams();
92 return cast<ObjCMethodDecl>(D)->param_size();
93}
94
95static const ParmVarDecl *getFunctionOrMethodParam(const Decl *D,
96 unsigned Idx) {
97 if (const auto *FD = dyn_cast<FunctionDecl>(D))
98 return FD->getParamDecl(Idx);
99 if (const auto *MD = dyn_cast<ObjCMethodDecl>(D))
100 return MD->getParamDecl(Idx);
101 if (const auto *BD = dyn_cast<BlockDecl>(D))
102 return BD->getParamDecl(Idx);
103 return nullptr;
104}
105
106static QualType getFunctionOrMethodParamType(const Decl *D, unsigned Idx) {
107 if (const FunctionType *FnTy = D->getFunctionType())
108 return cast<FunctionProtoType>(FnTy)->getParamType(Idx);
109 if (const auto *BD = dyn_cast<BlockDecl>(D))
110 return BD->getParamDecl(Idx)->getType();
111
112 return cast<ObjCMethodDecl>(D)->parameters()[Idx]->getType();
113}
114
115static SourceRange getFunctionOrMethodParamRange(const Decl *D, unsigned Idx) {
116 if (auto *PVD = getFunctionOrMethodParam(D, Idx))
117 return PVD->getSourceRange();
118 return SourceRange();
119}
120
121static QualType getFunctionOrMethodResultType(const Decl *D) {
122 if (const FunctionType *FnTy = D->getFunctionType())
123 return FnTy->getReturnType();
124 return cast<ObjCMethodDecl>(D)->getReturnType();
125}
126
127static SourceRange getFunctionOrMethodResultSourceRange(const Decl *D) {
128 if (const auto *FD = dyn_cast<FunctionDecl>(D))
129 return FD->getReturnTypeSourceRange();
130 if (const auto *MD = dyn_cast<ObjCMethodDecl>(D))
131 return MD->getReturnTypeSourceRange();
132 return SourceRange();
133}
134
135static bool isFunctionOrMethodVariadic(const Decl *D) {
136 if (const FunctionType *FnTy = D->getFunctionType())
137 return cast<FunctionProtoType>(FnTy)->isVariadic();
138 if (const auto *BD = dyn_cast<BlockDecl>(D))
139 return BD->isVariadic();
140 return cast<ObjCMethodDecl>(D)->isVariadic();
141}
142
143static bool isInstanceMethod(const Decl *D) {
144 if (const auto *MethodDecl = dyn_cast<CXXMethodDecl>(D))
145 return MethodDecl->isInstance();
146 return false;
147}
148
149static inline bool isNSStringType(QualType T, ASTContext &Ctx) {
150 const auto *PT = T->getAs<ObjCObjectPointerType>();
151 if (!PT)
152 return false;
153
154 ObjCInterfaceDecl *Cls = PT->getObjectType()->getInterface();
155 if (!Cls)
156 return false;
157
158 IdentifierInfo* ClsName = Cls->getIdentifier();
159
160 // FIXME: Should we walk the chain of classes?
161 return ClsName == &Ctx.Idents.get("NSString") ||
162 ClsName == &Ctx.Idents.get("NSMutableString");
163}
164
165static inline bool isCFStringType(QualType T, ASTContext &Ctx) {
166 const auto *PT = T->getAs<PointerType>();
167 if (!PT)
168 return false;
169
170 const auto *RT = PT->getPointeeType()->getAs<RecordType>();
171 if (!RT)
172 return false;
173
174 const RecordDecl *RD = RT->getDecl();
175 if (RD->getTagKind() != TTK_Struct)
176 return false;
177
178 return RD->getIdentifier() == &Ctx.Idents.get("__CFString");
179}
180
181static unsigned getNumAttributeArgs(const ParsedAttr &AL) {
182 // FIXME: Include the type in the argument list.
183 return AL.getNumArgs() + AL.hasParsedType();
184}
185
186template <typename Compare>
187static bool checkAttributeNumArgsImpl(Sema &S, const ParsedAttr &AL,
188 unsigned Num, unsigned Diag,
189 Compare Comp) {
190 if (Comp(getNumAttributeArgs(AL), Num)) {
191 S.Diag(AL.getLoc(), Diag) << AL << Num;
192 return false;
193 }
194
195 return true;
196}
197
198/// Check if the attribute has exactly as many args as Num. May
199/// output an error.
200static bool checkAttributeNumArgs(Sema &S, const ParsedAttr &AL, unsigned Num) {
201 return checkAttributeNumArgsImpl(S, AL, Num,
202 diag::err_attribute_wrong_number_arguments,
203 std::not_equal_to<unsigned>());
204}
205
206/// Check if the attribute has at least as many args as Num. May
207/// output an error.
208static bool checkAttributeAtLeastNumArgs(Sema &S, const ParsedAttr &AL,
209 unsigned Num) {
210 return checkAttributeNumArgsImpl(S, AL, Num,
211 diag::err_attribute_too_few_arguments,
212 std::less<unsigned>());
213}
214
215/// Check if the attribute has at most as many args as Num. May
216/// output an error.
217static bool checkAttributeAtMostNumArgs(Sema &S, const ParsedAttr &AL,
218 unsigned Num) {
219 return checkAttributeNumArgsImpl(S, AL, Num,
220 diag::err_attribute_too_many_arguments,
221 std::greater<unsigned>());
222}
223
224/// A helper function to provide Attribute Location for the Attr types
225/// AND the ParsedAttr.
226template <typename AttrInfo>
227static typename std::enable_if<std::is_base_of<Attr, AttrInfo>::value,
228 SourceLocation>::type
229getAttrLoc(const AttrInfo &AL) {
230 return AL.getLocation();
231}
232static SourceLocation getAttrLoc(const ParsedAttr &AL) { return AL.getLoc(); }
233
234/// If Expr is a valid integer constant, get the value of the integer
235/// expression and return success or failure. May output an error.
236///
237/// Negative argument is implicitly converted to unsigned, unless
238/// \p StrictlyUnsigned is true.
239template <typename AttrInfo>
240static bool checkUInt32Argument(Sema &S, const AttrInfo &AI, const Expr *Expr,
241 uint32_t &Val, unsigned Idx = UINT_MAX(2147483647 *2U +1U),
242 bool StrictlyUnsigned = false) {
243 llvm::APSInt I(32);
244 if (Expr->isTypeDependent() || Expr->isValueDependent() ||
245 !Expr->isIntegerConstantExpr(I, S.Context)) {
246 if (Idx != UINT_MAX(2147483647 *2U +1U))
247 S.Diag(getAttrLoc(AI), diag::err_attribute_argument_n_type)
248 << &AI << Idx << AANT_ArgumentIntegerConstant
249 << Expr->getSourceRange();
250 else
251 S.Diag(getAttrLoc(AI), diag::err_attribute_argument_type)
252 << &AI << AANT_ArgumentIntegerConstant << Expr->getSourceRange();
253 return false;
254 }
255
256 if (!I.isIntN(32)) {
257 S.Diag(Expr->getExprLoc(), diag::err_ice_too_large)
258 << I.toString(10, false) << 32 << /* Unsigned */ 1;
259 return false;
260 }
261
262 if (StrictlyUnsigned && I.isSigned() && I.isNegative()) {
263 S.Diag(getAttrLoc(AI), diag::err_attribute_requires_positive_integer)
264 << &AI << /*non-negative*/ 1;
265 return false;
266 }
267
268 Val = (uint32_t)I.getZExtValue();
269 return true;
270}
271
272/// Wrapper around checkUInt32Argument, with an extra check to be sure
273/// that the result will fit into a regular (signed) int. All args have the same
274/// purpose as they do in checkUInt32Argument.
275template <typename AttrInfo>
276static bool checkPositiveIntArgument(Sema &S, const AttrInfo &AI, const Expr *Expr,
277 int &Val, unsigned Idx = UINT_MAX(2147483647 *2U +1U)) {
278 uint32_t UVal;
279 if (!checkUInt32Argument(S, AI, Expr, UVal, Idx))
280 return false;
281
282 if (UVal > (uint32_t)std::numeric_limits<int>::max()) {
283 llvm::APSInt I(32); // for toString
284 I = UVal;
285 S.Diag(Expr->getExprLoc(), diag::err_ice_too_large)
286 << I.toString(10, false) << 32 << /* Unsigned */ 0;
287 return false;
288 }
289
290 Val = UVal;
291 return true;
292}
293
294/// Diagnose mutually exclusive attributes when present on a given
295/// declaration. Returns true if diagnosed.
296template <typename AttrTy>
297static bool checkAttrMutualExclusion(Sema &S, Decl *D, const ParsedAttr &AL) {
298 if (const auto *A = D->getAttr<AttrTy>()) {
299 S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << A;
300 S.Diag(A->getLocation(), diag::note_conflicting_attribute);
301 return true;
302 }
303 return false;
304}
305
306template <typename AttrTy>
307static bool checkAttrMutualExclusion(Sema &S, Decl *D, const Attr &AL) {
308 if (const auto *A = D->getAttr<AttrTy>()) {
309 S.Diag(AL.getLocation(), diag::err_attributes_are_not_compatible) << &AL
310 << A;
311 S.Diag(A->getLocation(), diag::note_conflicting_attribute);
312 return true;
313 }
314 return false;
315}
316
317/// Check if IdxExpr is a valid parameter index for a function or
318/// instance method D. May output an error.
319///
320/// \returns true if IdxExpr is a valid index.
321template <typename AttrInfo>
322static bool checkFunctionOrMethodParameterIndex(
323 Sema &S, const Decl *D, const AttrInfo &AI, unsigned AttrArgNum,
324 const Expr *IdxExpr, ParamIdx &Idx, bool CanIndexImplicitThis = false) {
325 assert(isFunctionOrMethodOrBlock(D))((isFunctionOrMethodOrBlock(D)) ? static_cast<void> (0)
: __assert_fail ("isFunctionOrMethodOrBlock(D)", "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 325, __PRETTY_FUNCTION__))
;
326
327 // In C++ the implicit 'this' function parameter also counts.
328 // Parameters are counted from one.
329 bool HP = hasFunctionProto(D);
330 bool HasImplicitThisParam = isInstanceMethod(D);
331 bool IV = HP && isFunctionOrMethodVariadic(D);
332 unsigned NumParams =
333 (HP ? getFunctionOrMethodNumParams(D) : 0) + HasImplicitThisParam;
334
335 llvm::APSInt IdxInt;
336 if (IdxExpr->isTypeDependent() || IdxExpr->isValueDependent() ||
337 !IdxExpr->isIntegerConstantExpr(IdxInt, S.Context)) {
338 S.Diag(getAttrLoc(AI), diag::err_attribute_argument_n_type)
339 << &AI << AttrArgNum << AANT_ArgumentIntegerConstant
340 << IdxExpr->getSourceRange();
341 return false;
342 }
343
344 unsigned IdxSource = IdxInt.getLimitedValue(UINT_MAX(2147483647 *2U +1U));
345 if (IdxSource < 1 || (!IV && IdxSource > NumParams)) {
346 S.Diag(getAttrLoc(AI), diag::err_attribute_argument_out_of_bounds)
347 << &AI << AttrArgNum << IdxExpr->getSourceRange();
348 return false;
349 }
350 if (HasImplicitThisParam && !CanIndexImplicitThis) {
351 if (IdxSource == 1) {
352 S.Diag(getAttrLoc(AI), diag::err_attribute_invalid_implicit_this_argument)
353 << &AI << IdxExpr->getSourceRange();
354 return false;
355 }
356 }
357
358 Idx = ParamIdx(IdxSource, D);
359 return true;
360}
361
362/// Check if the argument \p ArgNum of \p Attr is a ASCII string literal.
363/// If not emit an error and return false. If the argument is an identifier it
364/// will emit an error with a fixit hint and treat it as if it was a string
365/// literal.
366bool Sema::checkStringLiteralArgumentAttr(const ParsedAttr &AL, unsigned ArgNum,
367 StringRef &Str,
368 SourceLocation *ArgLocation) {
369 // Look for identifiers. If we have one emit a hint to fix it to a literal.
370 if (AL.isArgIdent(ArgNum)) {
371 IdentifierLoc *Loc = AL.getArgAsIdent(ArgNum);
372 Diag(Loc->Loc, diag::err_attribute_argument_type)
373 << AL << AANT_ArgumentString
374 << FixItHint::CreateInsertion(Loc->Loc, "\"")
375 << FixItHint::CreateInsertion(getLocForEndOfToken(Loc->Loc), "\"");
376 Str = Loc->Ident->getName();
377 if (ArgLocation)
378 *ArgLocation = Loc->Loc;
379 return true;
380 }
381
382 // Now check for an actual string literal.
383 Expr *ArgExpr = AL.getArgAsExpr(ArgNum);
384 const auto *Literal = dyn_cast<StringLiteral>(ArgExpr->IgnoreParenCasts());
385 if (ArgLocation)
386 *ArgLocation = ArgExpr->getBeginLoc();
387
388 if (!Literal || !Literal->isAscii()) {
389 Diag(ArgExpr->getBeginLoc(), diag::err_attribute_argument_type)
390 << AL << AANT_ArgumentString;
391 return false;
392 }
393
394 Str = Literal->getString();
395 return true;
396}
397
398/// Applies the given attribute to the Decl without performing any
399/// additional semantic checking.
400template <typename AttrType>
401static void handleSimpleAttribute(Sema &S, Decl *D, SourceRange SR,
402 unsigned SpellingIndex) {
403 D->addAttr(::new (S.Context) AttrType(SR, S.Context, SpellingIndex));
404}
405
406template <typename AttrType>
407static void handleSimpleAttribute(Sema &S, Decl *D, const ParsedAttr &AL) {
408 handleSimpleAttribute<AttrType>(S, D, AL.getRange(),
409 AL.getAttributeSpellingListIndex());
410}
411
412
413template <typename... DiagnosticArgs>
414static const Sema::SemaDiagnosticBuilder&
415appendDiagnostics(const Sema::SemaDiagnosticBuilder &Bldr) {
416 return Bldr;
417}
418
419template <typename T, typename... DiagnosticArgs>
420static const Sema::SemaDiagnosticBuilder&
421appendDiagnostics(const Sema::SemaDiagnosticBuilder &Bldr, T &&ExtraArg,
422 DiagnosticArgs &&... ExtraArgs) {
423 return appendDiagnostics(Bldr << std::forward<T>(ExtraArg),
424 std::forward<DiagnosticArgs>(ExtraArgs)...);
425}
426
427/// Add an attribute {@code AttrType} to declaration {@code D}, provided that
428/// {@code PassesCheck} is true.
429/// Otherwise, emit diagnostic {@code DiagID}, passing in all parameters
430/// specified in {@code ExtraArgs}.
431template <typename AttrType, typename... DiagnosticArgs>
432static void
433handleSimpleAttributeOrDiagnose(Sema &S, Decl *D, SourceRange SR,
434 unsigned SpellingIndex,
435 bool PassesCheck,
436 unsigned DiagID, DiagnosticArgs&&... ExtraArgs) {
437 if (!PassesCheck) {
438 Sema::SemaDiagnosticBuilder DB = S.Diag(D->getBeginLoc(), DiagID);
439 appendDiagnostics(DB, std::forward<DiagnosticArgs>(ExtraArgs)...);
440 return;
441 }
442 handleSimpleAttribute<AttrType>(S, D, SR, SpellingIndex);
443}
444
445template <typename AttrType, typename... DiagnosticArgs>
446static void
447handleSimpleAttributeOrDiagnose(Sema &S, Decl *D, const ParsedAttr &AL,
448 bool PassesCheck,
449 unsigned DiagID,
450 DiagnosticArgs&&... ExtraArgs) {
451 return handleSimpleAttributeOrDiagnose<AttrType>(
452 S, D, AL.getRange(), AL.getAttributeSpellingListIndex(), PassesCheck,
453 DiagID, std::forward<DiagnosticArgs>(ExtraArgs)...);
454}
455
456template <typename AttrType>
457static void handleSimpleAttributeWithExclusions(Sema &S, Decl *D,
458 const ParsedAttr &AL) {
459 handleSimpleAttribute<AttrType>(S, D, AL);
460}
461
462/// Applies the given attribute to the Decl so long as the Decl doesn't
463/// already have one of the given incompatible attributes.
464template <typename AttrType, typename IncompatibleAttrType,
465 typename... IncompatibleAttrTypes>
466static void handleSimpleAttributeWithExclusions(Sema &S, Decl *D,
467 const ParsedAttr &AL) {
468 if (checkAttrMutualExclusion<IncompatibleAttrType>(S, D, AL))
469 return;
470 handleSimpleAttributeWithExclusions<AttrType, IncompatibleAttrTypes...>(S, D,
471 AL);
472}
473
474/// Check if the passed-in expression is of type int or bool.
475static bool isIntOrBool(Expr *Exp) {
476 QualType QT = Exp->getType();
477 return QT->isBooleanType() || QT->isIntegerType();
478}
479
480
481// Check to see if the type is a smart pointer of some kind. We assume
482// it's a smart pointer if it defines both operator-> and operator*.
483static bool threadSafetyCheckIsSmartPointer(Sema &S, const RecordType* RT) {
484 auto IsOverloadedOperatorPresent = [&S](const RecordDecl *Record,
485 OverloadedOperatorKind Op) {
486 DeclContextLookupResult Result =
487 Record->lookup(S.Context.DeclarationNames.getCXXOperatorName(Op));
488 return !Result.empty();
489 };
490
491 const RecordDecl *Record = RT->getDecl();
492 bool foundStarOperator = IsOverloadedOperatorPresent(Record, OO_Star);
493 bool foundArrowOperator = IsOverloadedOperatorPresent(Record, OO_Arrow);
494 if (foundStarOperator && foundArrowOperator)
495 return true;
496
497 const CXXRecordDecl *CXXRecord = dyn_cast<CXXRecordDecl>(Record);
498 if (!CXXRecord)
499 return false;
500
501 for (auto BaseSpecifier : CXXRecord->bases()) {
502 if (!foundStarOperator)
503 foundStarOperator = IsOverloadedOperatorPresent(
504 BaseSpecifier.getType()->getAsRecordDecl(), OO_Star);
505 if (!foundArrowOperator)
506 foundArrowOperator = IsOverloadedOperatorPresent(
507 BaseSpecifier.getType()->getAsRecordDecl(), OO_Arrow);
508 }
509
510 if (foundStarOperator && foundArrowOperator)
511 return true;
512
513 return false;
514}
515
516/// Check if passed in Decl is a pointer type.
517/// Note that this function may produce an error message.
518/// \return true if the Decl is a pointer type; false otherwise
519static bool threadSafetyCheckIsPointer(Sema &S, const Decl *D,
520 const ParsedAttr &AL) {
521 const auto *VD = cast<ValueDecl>(D);
522 QualType QT = VD->getType();
523 if (QT->isAnyPointerType())
524 return true;
525
526 if (const auto *RT = QT->getAs<RecordType>()) {
527 // If it's an incomplete type, it could be a smart pointer; skip it.
528 // (We don't want to force template instantiation if we can avoid it,
529 // since that would alter the order in which templates are instantiated.)
530 if (RT->isIncompleteType())
531 return true;
532
533 if (threadSafetyCheckIsSmartPointer(S, RT))
534 return true;
535 }
536
537 S.Diag(AL.getLoc(), diag::warn_thread_attribute_decl_not_pointer) << AL << QT;
538 return false;
539}
540
541/// Checks that the passed in QualType either is of RecordType or points
542/// to RecordType. Returns the relevant RecordType, null if it does not exit.
543static const RecordType *getRecordType(QualType QT) {
544 if (const auto *RT = QT->getAs<RecordType>())
545 return RT;
546
547 // Now check if we point to record type.
548 if (const auto *PT = QT->getAs<PointerType>())
549 return PT->getPointeeType()->getAs<RecordType>();
550
551 return nullptr;
552}
553
554template <typename AttrType>
555static bool checkRecordDeclForAttr(const RecordDecl *RD) {
556 // Check if the record itself has the attribute.
557 if (RD->hasAttr<AttrType>())
558 return true;
559
560 // Else check if any base classes have the attribute.
561 if (const auto *CRD = dyn_cast<CXXRecordDecl>(RD)) {
562 CXXBasePaths BPaths(false, false);
563 if (CRD->lookupInBases(
564 [](const CXXBaseSpecifier *BS, CXXBasePath &) {
565 const auto &Ty = *BS->getType();
566 // If it's type-dependent, we assume it could have the attribute.
567 if (Ty.isDependentType())
568 return true;
569 return Ty.getAs<RecordType>()->getDecl()->hasAttr<AttrType>();
570 },
571 BPaths, true))
572 return true;
573 }
574 return false;
575}
576
577static bool checkRecordTypeForCapability(Sema &S, QualType Ty) {
578 const RecordType *RT = getRecordType(Ty);
579
580 if (!RT)
581 return false;
582
583 // Don't check for the capability if the class hasn't been defined yet.
584 if (RT->isIncompleteType())
585 return true;
586
587 // Allow smart pointers to be used as capability objects.
588 // FIXME -- Check the type that the smart pointer points to.
589 if (threadSafetyCheckIsSmartPointer(S, RT))
590 return true;
591
592 return checkRecordDeclForAttr<CapabilityAttr>(RT->getDecl());
593}
594
595static bool checkTypedefTypeForCapability(QualType Ty) {
596 const auto *TD = Ty->getAs<TypedefType>();
597 if (!TD)
598 return false;
599
600 TypedefNameDecl *TN = TD->getDecl();
601 if (!TN)
602 return false;
603
604 return TN->hasAttr<CapabilityAttr>();
605}
606
607static bool typeHasCapability(Sema &S, QualType Ty) {
608 if (checkTypedefTypeForCapability(Ty))
609 return true;
610
611 if (checkRecordTypeForCapability(S, Ty))
612 return true;
613
614 return false;
615}
616
617static bool isCapabilityExpr(Sema &S, const Expr *Ex) {
618 // Capability expressions are simple expressions involving the boolean logic
619 // operators &&, || or !, a simple DeclRefExpr, CastExpr or a ParenExpr. Once
620 // a DeclRefExpr is found, its type should be checked to determine whether it
621 // is a capability or not.
622
623 if (const auto *E = dyn_cast<CastExpr>(Ex))
624 return isCapabilityExpr(S, E->getSubExpr());
625 else if (const auto *E = dyn_cast<ParenExpr>(Ex))
626 return isCapabilityExpr(S, E->getSubExpr());
627 else if (const auto *E = dyn_cast<UnaryOperator>(Ex)) {
628 if (E->getOpcode() == UO_LNot || E->getOpcode() == UO_AddrOf ||
629 E->getOpcode() == UO_Deref)
630 return isCapabilityExpr(S, E->getSubExpr());
631 return false;
632 } else if (const auto *E = dyn_cast<BinaryOperator>(Ex)) {
633 if (E->getOpcode() == BO_LAnd || E->getOpcode() == BO_LOr)
634 return isCapabilityExpr(S, E->getLHS()) &&
635 isCapabilityExpr(S, E->getRHS());
636 return false;
637 }
638
639 return typeHasCapability(S, Ex->getType());
640}
641
642/// Checks that all attribute arguments, starting from Sidx, resolve to
643/// a capability object.
644/// \param Sidx The attribute argument index to start checking with.
645/// \param ParamIdxOk Whether an argument can be indexing into a function
646/// parameter list.
647static void checkAttrArgsAreCapabilityObjs(Sema &S, Decl *D,
648 const ParsedAttr &AL,
649 SmallVectorImpl<Expr *> &Args,
650 unsigned Sidx = 0,
651 bool ParamIdxOk = false) {
652 if (Sidx == AL.getNumArgs()) {
653 // If we don't have any capability arguments, the attribute implicitly
654 // refers to 'this'. So we need to make sure that 'this' exists, i.e. we're
655 // a non-static method, and that the class is a (scoped) capability.
656 const auto *MD = dyn_cast<const CXXMethodDecl>(D);
657 if (MD && !MD->isStatic()) {
658 const CXXRecordDecl *RD = MD->getParent();
659 // FIXME -- need to check this again on template instantiation
660 if (!checkRecordDeclForAttr<CapabilityAttr>(RD) &&
661 !checkRecordDeclForAttr<ScopedLockableAttr>(RD))
662 S.Diag(AL.getLoc(),
663 diag::warn_thread_attribute_not_on_capability_member)
664 << AL << MD->getParent();
665 } else {
666 S.Diag(AL.getLoc(), diag::warn_thread_attribute_not_on_non_static_member)
667 << AL;
668 }
669 }
670
671 for (unsigned Idx = Sidx; Idx < AL.getNumArgs(); ++Idx) {
672 Expr *ArgExp = AL.getArgAsExpr(Idx);
673
674 if (ArgExp->isTypeDependent()) {
675 // FIXME -- need to check this again on template instantiation
676 Args.push_back(ArgExp);
677 continue;
678 }
679
680 if (const auto *StrLit = dyn_cast<StringLiteral>(ArgExp)) {
681 if (StrLit->getLength() == 0 ||
682 (StrLit->isAscii() && StrLit->getString() == StringRef("*"))) {
683 // Pass empty strings to the analyzer without warnings.
684 // Treat "*" as the universal lock.
685 Args.push_back(ArgExp);
686 continue;
687 }
688
689 // We allow constant strings to be used as a placeholder for expressions
690 // that are not valid C++ syntax, but warn that they are ignored.
691 S.Diag(AL.getLoc(), diag::warn_thread_attribute_ignored) << AL;
692 Args.push_back(ArgExp);
693 continue;
694 }
695
696 QualType ArgTy = ArgExp->getType();
697
698 // A pointer to member expression of the form &MyClass::mu is treated
699 // specially -- we need to look at the type of the member.
700 if (const auto *UOp = dyn_cast<UnaryOperator>(ArgExp))
701 if (UOp->getOpcode() == UO_AddrOf)
702 if (const auto *DRE = dyn_cast<DeclRefExpr>(UOp->getSubExpr()))
703 if (DRE->getDecl()->isCXXInstanceMember())
704 ArgTy = DRE->getDecl()->getType();
705
706 // First see if we can just cast to record type, or pointer to record type.
707 const RecordType *RT = getRecordType(ArgTy);
708
709 // Now check if we index into a record type function param.
710 if(!RT && ParamIdxOk) {
711 const auto *FD = dyn_cast<FunctionDecl>(D);
712 const auto *IL = dyn_cast<IntegerLiteral>(ArgExp);
713 if(FD && IL) {
714 unsigned int NumParams = FD->getNumParams();
715 llvm::APInt ArgValue = IL->getValue();
716 uint64_t ParamIdxFromOne = ArgValue.getZExtValue();
717 uint64_t ParamIdxFromZero = ParamIdxFromOne - 1;
718 if (!ArgValue.isStrictlyPositive() || ParamIdxFromOne > NumParams) {
719 S.Diag(AL.getLoc(),
720 diag::err_attribute_argument_out_of_bounds_extra_info)
721 << AL << Idx + 1 << NumParams;
722 continue;
723 }
724 ArgTy = FD->getParamDecl(ParamIdxFromZero)->getType();
725 }
726 }
727
728 // If the type does not have a capability, see if the components of the
729 // expression have capabilities. This allows for writing C code where the
730 // capability may be on the type, and the expression is a capability
731 // boolean logic expression. Eg) requires_capability(A || B && !C)
732 if (!typeHasCapability(S, ArgTy) && !isCapabilityExpr(S, ArgExp))
733 S.Diag(AL.getLoc(), diag::warn_thread_attribute_argument_not_lockable)
734 << AL << ArgTy;
735
736 Args.push_back(ArgExp);
737 }
738}
739
740//===----------------------------------------------------------------------===//
741// Attribute Implementations
742//===----------------------------------------------------------------------===//
743
744static void handlePtGuardedVarAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
745 if (!threadSafetyCheckIsPointer(S, D, AL))
746 return;
747
748 D->addAttr(::new (S.Context)
749 PtGuardedVarAttr(AL.getRange(), S.Context,
750 AL.getAttributeSpellingListIndex()));
751}
752
753static bool checkGuardedByAttrCommon(Sema &S, Decl *D, const ParsedAttr &AL,
754 Expr *&Arg) {
755 SmallVector<Expr *, 1> Args;
756 // check that all arguments are lockable objects
757 checkAttrArgsAreCapabilityObjs(S, D, AL, Args);
758 unsigned Size = Args.size();
759 if (Size != 1)
760 return false;
761
762 Arg = Args[0];
763
764 return true;
765}
766
767static void handleGuardedByAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
768 Expr *Arg = nullptr;
769 if (!checkGuardedByAttrCommon(S, D, AL, Arg))
770 return;
771
772 D->addAttr(::new (S.Context) GuardedByAttr(
773 AL.getRange(), S.Context, Arg, AL.getAttributeSpellingListIndex()));
774}
775
776static void handlePtGuardedByAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
777 Expr *Arg = nullptr;
778 if (!checkGuardedByAttrCommon(S, D, AL, Arg))
779 return;
780
781 if (!threadSafetyCheckIsPointer(S, D, AL))
782 return;
783
784 D->addAttr(::new (S.Context) PtGuardedByAttr(
785 AL.getRange(), S.Context, Arg, AL.getAttributeSpellingListIndex()));
786}
787
788static bool checkAcquireOrderAttrCommon(Sema &S, Decl *D, const ParsedAttr &AL,
789 SmallVectorImpl<Expr *> &Args) {
790 if (!checkAttributeAtLeastNumArgs(S, AL, 1))
791 return false;
792
793 // Check that this attribute only applies to lockable types.
794 QualType QT = cast<ValueDecl>(D)->getType();
795 if (!QT->isDependentType() && !typeHasCapability(S, QT)) {
796 S.Diag(AL.getLoc(), diag::warn_thread_attribute_decl_not_lockable) << AL;
797 return false;
798 }
799
800 // Check that all arguments are lockable objects.
801 checkAttrArgsAreCapabilityObjs(S, D, AL, Args);
802 if (Args.empty())
803 return false;
804
805 return true;
806}
807
808static void handleAcquiredAfterAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
809 SmallVector<Expr *, 1> Args;
810 if (!checkAcquireOrderAttrCommon(S, D, AL, Args))
811 return;
812
813 Expr **StartArg = &Args[0];
814 D->addAttr(::new (S.Context) AcquiredAfterAttr(
815 AL.getRange(), S.Context, StartArg, Args.size(),
816 AL.getAttributeSpellingListIndex()));
817}
818
819static void handleAcquiredBeforeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
820 SmallVector<Expr *, 1> Args;
821 if (!checkAcquireOrderAttrCommon(S, D, AL, Args))
822 return;
823
824 Expr **StartArg = &Args[0];
825 D->addAttr(::new (S.Context) AcquiredBeforeAttr(
826 AL.getRange(), S.Context, StartArg, Args.size(),
827 AL.getAttributeSpellingListIndex()));
828}
829
830static bool checkLockFunAttrCommon(Sema &S, Decl *D, const ParsedAttr &AL,
831 SmallVectorImpl<Expr *> &Args) {
832 // zero or more arguments ok
833 // check that all arguments are lockable objects
834 checkAttrArgsAreCapabilityObjs(S, D, AL, Args, 0, /*ParamIdxOk=*/true);
835
836 return true;
837}
838
839static void handleAssertSharedLockAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
840 SmallVector<Expr *, 1> Args;
841 if (!checkLockFunAttrCommon(S, D, AL, Args))
842 return;
843
844 unsigned Size = Args.size();
845 Expr **StartArg = Size == 0 ? nullptr : &Args[0];
846 D->addAttr(::new (S.Context)
847 AssertSharedLockAttr(AL.getRange(), S.Context, StartArg, Size,
848 AL.getAttributeSpellingListIndex()));
849}
850
851static void handleAssertExclusiveLockAttr(Sema &S, Decl *D,
852 const ParsedAttr &AL) {
853 SmallVector<Expr *, 1> Args;
854 if (!checkLockFunAttrCommon(S, D, AL, Args))
855 return;
856
857 unsigned Size = Args.size();
858 Expr **StartArg = Size == 0 ? nullptr : &Args[0];
859 D->addAttr(::new (S.Context) AssertExclusiveLockAttr(
860 AL.getRange(), S.Context, StartArg, Size,
861 AL.getAttributeSpellingListIndex()));
862}
863
864/// Checks to be sure that the given parameter number is in bounds, and
865/// is an integral type. Will emit appropriate diagnostics if this returns
866/// false.
867///
868/// AttrArgNo is used to actually retrieve the argument, so it's base-0.
869template <typename AttrInfo>
870static bool checkParamIsIntegerType(Sema &S, const FunctionDecl *FD,
871 const AttrInfo &AI, unsigned AttrArgNo) {
872 assert(AI.isArgExpr(AttrArgNo) && "Expected expression argument")((AI.isArgExpr(AttrArgNo) && "Expected expression argument"
) ? static_cast<void> (0) : __assert_fail ("AI.isArgExpr(AttrArgNo) && \"Expected expression argument\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 872, __PRETTY_FUNCTION__))
;
873 Expr *AttrArg = AI.getArgAsExpr(AttrArgNo);
874 ParamIdx Idx;
875 if (!checkFunctionOrMethodParameterIndex(S, FD, AI, AttrArgNo + 1, AttrArg,
876 Idx))
877 return false;
878
879 const ParmVarDecl *Param = FD->getParamDecl(Idx.getASTIndex());
880 if (!Param->getType()->isIntegerType() && !Param->getType()->isCharType()) {
881 SourceLocation SrcLoc = AttrArg->getBeginLoc();
882 S.Diag(SrcLoc, diag::err_attribute_integers_only)
883 << AI << Param->getSourceRange();
884 return false;
885 }
886 return true;
887}
888
889static void handleAllocSizeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
890 if (!checkAttributeAtLeastNumArgs(S, AL, 1) ||
891 !checkAttributeAtMostNumArgs(S, AL, 2))
892 return;
893
894 const auto *FD = cast<FunctionDecl>(D);
895 if (!FD->getReturnType()->isPointerType()) {
896 S.Diag(AL.getLoc(), diag::warn_attribute_return_pointers_only) << AL;
897 return;
898 }
899
900 const Expr *SizeExpr = AL.getArgAsExpr(0);
901 int SizeArgNoVal;
902 // Parameter indices are 1-indexed, hence Index=1
903 if (!checkPositiveIntArgument(S, AL, SizeExpr, SizeArgNoVal, /*Index=*/1))
904 return;
905 if (!checkParamIsIntegerType(S, FD, AL, /*AttrArgNo=*/0))
906 return;
907 ParamIdx SizeArgNo(SizeArgNoVal, D);
908
909 ParamIdx NumberArgNo;
910 if (AL.getNumArgs() == 2) {
911 const Expr *NumberExpr = AL.getArgAsExpr(1);
912 int Val;
913 // Parameter indices are 1-based, hence Index=2
914 if (!checkPositiveIntArgument(S, AL, NumberExpr, Val, /*Index=*/2))
915 return;
916 if (!checkParamIsIntegerType(S, FD, AL, /*AttrArgNo=*/1))
917 return;
918 NumberArgNo = ParamIdx(Val, D);
919 }
920
921 D->addAttr(::new (S.Context)
922 AllocSizeAttr(AL.getRange(), S.Context, SizeArgNo, NumberArgNo,
923 AL.getAttributeSpellingListIndex()));
924}
925
926static bool checkTryLockFunAttrCommon(Sema &S, Decl *D, const ParsedAttr &AL,
927 SmallVectorImpl<Expr *> &Args) {
928 if (!checkAttributeAtLeastNumArgs(S, AL, 1))
929 return false;
930
931 if (!isIntOrBool(AL.getArgAsExpr(0))) {
932 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
933 << AL << 1 << AANT_ArgumentIntOrBool;
934 return false;
935 }
936
937 // check that all arguments are lockable objects
938 checkAttrArgsAreCapabilityObjs(S, D, AL, Args, 1);
939
940 return true;
941}
942
943static void handleSharedTrylockFunctionAttr(Sema &S, Decl *D,
944 const ParsedAttr &AL) {
945 SmallVector<Expr*, 2> Args;
946 if (!checkTryLockFunAttrCommon(S, D, AL, Args))
947 return;
948
949 D->addAttr(::new (S.Context) SharedTrylockFunctionAttr(
950 AL.getRange(), S.Context, AL.getArgAsExpr(0), Args.data(), Args.size(),
951 AL.getAttributeSpellingListIndex()));
952}
953
954static void handleExclusiveTrylockFunctionAttr(Sema &S, Decl *D,
955 const ParsedAttr &AL) {
956 SmallVector<Expr*, 2> Args;
957 if (!checkTryLockFunAttrCommon(S, D, AL, Args))
958 return;
959
960 D->addAttr(::new (S.Context) ExclusiveTrylockFunctionAttr(
961 AL.getRange(), S.Context, AL.getArgAsExpr(0), Args.data(),
962 Args.size(), AL.getAttributeSpellingListIndex()));
963}
964
965static void handleLockReturnedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
966 // check that the argument is lockable object
967 SmallVector<Expr*, 1> Args;
968 checkAttrArgsAreCapabilityObjs(S, D, AL, Args);
969 unsigned Size = Args.size();
970 if (Size == 0)
971 return;
972
973 D->addAttr(::new (S.Context)
974 LockReturnedAttr(AL.getRange(), S.Context, Args[0],
975 AL.getAttributeSpellingListIndex()));
976}
977
978static void handleLocksExcludedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
979 if (!checkAttributeAtLeastNumArgs(S, AL, 1))
980 return;
981
982 // check that all arguments are lockable objects
983 SmallVector<Expr*, 1> Args;
984 checkAttrArgsAreCapabilityObjs(S, D, AL, Args);
985 unsigned Size = Args.size();
986 if (Size == 0)
987 return;
988 Expr **StartArg = &Args[0];
989
990 D->addAttr(::new (S.Context)
991 LocksExcludedAttr(AL.getRange(), S.Context, StartArg, Size,
992 AL.getAttributeSpellingListIndex()));
993}
994
995static bool checkFunctionConditionAttr(Sema &S, Decl *D, const ParsedAttr &AL,
996 Expr *&Cond, StringRef &Msg) {
997 Cond = AL.getArgAsExpr(0);
998 if (!Cond->isTypeDependent()) {
999 ExprResult Converted = S.PerformContextuallyConvertToBool(Cond);
1000 if (Converted.isInvalid())
1001 return false;
1002 Cond = Converted.get();
1003 }
1004
1005 if (!S.checkStringLiteralArgumentAttr(AL, 1, Msg))
1006 return false;
1007
1008 if (Msg.empty())
1009 Msg = "<no message provided>";
1010
1011 SmallVector<PartialDiagnosticAt, 8> Diags;
1012 if (isa<FunctionDecl>(D) && !Cond->isValueDependent() &&
1013 !Expr::isPotentialConstantExprUnevaluated(Cond, cast<FunctionDecl>(D),
1014 Diags)) {
1015 S.Diag(AL.getLoc(), diag::err_attr_cond_never_constant_expr) << AL;
1016 for (const PartialDiagnosticAt &PDiag : Diags)
1017 S.Diag(PDiag.first, PDiag.second);
1018 return false;
1019 }
1020 return true;
1021}
1022
1023static void handleEnableIfAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1024 S.Diag(AL.getLoc(), diag::ext_clang_enable_if);
1025
1026 Expr *Cond;
1027 StringRef Msg;
1028 if (checkFunctionConditionAttr(S, D, AL, Cond, Msg))
1029 D->addAttr(::new (S.Context)
1030 EnableIfAttr(AL.getRange(), S.Context, Cond, Msg,
1031 AL.getAttributeSpellingListIndex()));
1032}
1033
1034namespace {
1035/// Determines if a given Expr references any of the given function's
1036/// ParmVarDecls, or the function's implicit `this` parameter (if applicable).
1037class ArgumentDependenceChecker
1038 : public RecursiveASTVisitor<ArgumentDependenceChecker> {
1039#ifndef NDEBUG
1040 const CXXRecordDecl *ClassType;
1041#endif
1042 llvm::SmallPtrSet<const ParmVarDecl *, 16> Parms;
1043 bool Result;
1044
1045public:
1046 ArgumentDependenceChecker(const FunctionDecl *FD) {
1047#ifndef NDEBUG
1048 if (const auto *MD = dyn_cast<CXXMethodDecl>(FD))
1049 ClassType = MD->getParent();
1050 else
1051 ClassType = nullptr;
1052#endif
1053 Parms.insert(FD->param_begin(), FD->param_end());
1054 }
1055
1056 bool referencesArgs(Expr *E) {
1057 Result = false;
1058 TraverseStmt(E);
1059 return Result;
1060 }
1061
1062 bool VisitCXXThisExpr(CXXThisExpr *E) {
1063 assert(E->getType()->getPointeeCXXRecordDecl() == ClassType &&((E->getType()->getPointeeCXXRecordDecl() == ClassType &&
"`this` doesn't refer to the enclosing class?") ? static_cast
<void> (0) : __assert_fail ("E->getType()->getPointeeCXXRecordDecl() == ClassType && \"`this` doesn't refer to the enclosing class?\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 1064, __PRETTY_FUNCTION__))
1064 "`this` doesn't refer to the enclosing class?")((E->getType()->getPointeeCXXRecordDecl() == ClassType &&
"`this` doesn't refer to the enclosing class?") ? static_cast
<void> (0) : __assert_fail ("E->getType()->getPointeeCXXRecordDecl() == ClassType && \"`this` doesn't refer to the enclosing class?\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 1064, __PRETTY_FUNCTION__))
;
1065 Result = true;
1066 return false;
1067 }
1068
1069 bool VisitDeclRefExpr(DeclRefExpr *DRE) {
1070 if (const auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl()))
1071 if (Parms.count(PVD)) {
1072 Result = true;
1073 return false;
1074 }
1075 return true;
1076 }
1077};
1078}
1079
1080static void handleDiagnoseIfAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1081 S.Diag(AL.getLoc(), diag::ext_clang_diagnose_if);
1082
1083 Expr *Cond;
1084 StringRef Msg;
1085 if (!checkFunctionConditionAttr(S, D, AL, Cond, Msg))
1086 return;
1087
1088 StringRef DiagTypeStr;
1089 if (!S.checkStringLiteralArgumentAttr(AL, 2, DiagTypeStr))
1090 return;
1091
1092 DiagnoseIfAttr::DiagnosticType DiagType;
1093 if (!DiagnoseIfAttr::ConvertStrToDiagnosticType(DiagTypeStr, DiagType)) {
1094 S.Diag(AL.getArgAsExpr(2)->getBeginLoc(),
1095 diag::err_diagnose_if_invalid_diagnostic_type);
1096 return;
1097 }
1098
1099 bool ArgDependent = false;
1100 if (const auto *FD = dyn_cast<FunctionDecl>(D))
1101 ArgDependent = ArgumentDependenceChecker(FD).referencesArgs(Cond);
1102 D->addAttr(::new (S.Context) DiagnoseIfAttr(
1103 AL.getRange(), S.Context, Cond, Msg, DiagType, ArgDependent,
1104 cast<NamedDecl>(D), AL.getAttributeSpellingListIndex()));
1105}
1106
1107static void handlePassObjectSizeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1108 if (D->hasAttr<PassObjectSizeAttr>()) {
1109 S.Diag(D->getBeginLoc(), diag::err_attribute_only_once_per_parameter) << AL;
1110 return;
1111 }
1112
1113 Expr *E = AL.getArgAsExpr(0);
1114 uint32_t Type;
1115 if (!checkUInt32Argument(S, AL, E, Type, /*Idx=*/1))
1116 return;
1117
1118 // pass_object_size's argument is passed in as the second argument of
1119 // __builtin_object_size. So, it has the same constraints as that second
1120 // argument; namely, it must be in the range [0, 3].
1121 if (Type > 3) {
1122 S.Diag(E->getBeginLoc(), diag::err_attribute_argument_out_of_range)
1123 << AL << 0 << 3 << E->getSourceRange();
1124 return;
1125 }
1126
1127 // pass_object_size is only supported on constant pointer parameters; as a
1128 // kindness to users, we allow the parameter to be non-const for declarations.
1129 // At this point, we have no clue if `D` belongs to a function declaration or
1130 // definition, so we defer the constness check until later.
1131 if (!cast<ParmVarDecl>(D)->getType()->isPointerType()) {
1132 S.Diag(D->getBeginLoc(), diag::err_attribute_pointers_only) << AL << 1;
1133 return;
1134 }
1135
1136 D->addAttr(::new (S.Context) PassObjectSizeAttr(
1137 AL.getRange(), S.Context, (int)Type, AL.getAttributeSpellingListIndex()));
1138}
1139
1140static void handleConsumableAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1141 ConsumableAttr::ConsumedState DefaultState;
1142
1143 if (AL.isArgIdent(0)) {
1144 IdentifierLoc *IL = AL.getArgAsIdent(0);
1145 if (!ConsumableAttr::ConvertStrToConsumedState(IL->Ident->getName(),
1146 DefaultState)) {
1147 S.Diag(IL->Loc, diag::warn_attribute_type_not_supported) << AL
1148 << IL->Ident;
1149 return;
1150 }
1151 } else {
1152 S.Diag(AL.getLoc(), diag::err_attribute_argument_type)
1153 << AL << AANT_ArgumentIdentifier;
1154 return;
1155 }
1156
1157 D->addAttr(::new (S.Context)
1158 ConsumableAttr(AL.getRange(), S.Context, DefaultState,
1159 AL.getAttributeSpellingListIndex()));
1160}
1161
1162static bool checkForConsumableClass(Sema &S, const CXXMethodDecl *MD,
1163 const ParsedAttr &AL) {
1164 QualType ThisType = MD->getThisType()->getPointeeType();
1165
1166 if (const CXXRecordDecl *RD = ThisType->getAsCXXRecordDecl()) {
1167 if (!RD->hasAttr<ConsumableAttr>()) {
1168 S.Diag(AL.getLoc(), diag::warn_attr_on_unconsumable_class) <<
1169 RD->getNameAsString();
1170
1171 return false;
1172 }
1173 }
1174
1175 return true;
1176}
1177
1178static void handleCallableWhenAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1179 if (!checkAttributeAtLeastNumArgs(S, AL, 1))
1180 return;
1181
1182 if (!checkForConsumableClass(S, cast<CXXMethodDecl>(D), AL))
1183 return;
1184
1185 SmallVector<CallableWhenAttr::ConsumedState, 3> States;
1186 for (unsigned ArgIndex = 0; ArgIndex < AL.getNumArgs(); ++ArgIndex) {
1187 CallableWhenAttr::ConsumedState CallableState;
1188
1189 StringRef StateString;
1190 SourceLocation Loc;
1191 if (AL.isArgIdent(ArgIndex)) {
1192 IdentifierLoc *Ident = AL.getArgAsIdent(ArgIndex);
1193 StateString = Ident->Ident->getName();
1194 Loc = Ident->Loc;
1195 } else {
1196 if (!S.checkStringLiteralArgumentAttr(AL, ArgIndex, StateString, &Loc))
1197 return;
1198 }
1199
1200 if (!CallableWhenAttr::ConvertStrToConsumedState(StateString,
1201 CallableState)) {
1202 S.Diag(Loc, diag::warn_attribute_type_not_supported) << AL << StateString;
1203 return;
1204 }
1205
1206 States.push_back(CallableState);
1207 }
1208
1209 D->addAttr(::new (S.Context)
1210 CallableWhenAttr(AL.getRange(), S.Context, States.data(),
1211 States.size(), AL.getAttributeSpellingListIndex()));
1212}
1213
1214static void handleParamTypestateAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1215 ParamTypestateAttr::ConsumedState ParamState;
1216
1217 if (AL.isArgIdent(0)) {
1218 IdentifierLoc *Ident = AL.getArgAsIdent(0);
1219 StringRef StateString = Ident->Ident->getName();
1220
1221 if (!ParamTypestateAttr::ConvertStrToConsumedState(StateString,
1222 ParamState)) {
1223 S.Diag(Ident->Loc, diag::warn_attribute_type_not_supported)
1224 << AL << StateString;
1225 return;
1226 }
1227 } else {
1228 S.Diag(AL.getLoc(), diag::err_attribute_argument_type)
1229 << AL << AANT_ArgumentIdentifier;
1230 return;
1231 }
1232
1233 // FIXME: This check is currently being done in the analysis. It can be
1234 // enabled here only after the parser propagates attributes at
1235 // template specialization definition, not declaration.
1236 //QualType ReturnType = cast<ParmVarDecl>(D)->getType();
1237 //const CXXRecordDecl *RD = ReturnType->getAsCXXRecordDecl();
1238 //
1239 //if (!RD || !RD->hasAttr<ConsumableAttr>()) {
1240 // S.Diag(AL.getLoc(), diag::warn_return_state_for_unconsumable_type) <<
1241 // ReturnType.getAsString();
1242 // return;
1243 //}
1244
1245 D->addAttr(::new (S.Context)
1246 ParamTypestateAttr(AL.getRange(), S.Context, ParamState,
1247 AL.getAttributeSpellingListIndex()));
1248}
1249
1250static void handleReturnTypestateAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1251 ReturnTypestateAttr::ConsumedState ReturnState;
1252
1253 if (AL.isArgIdent(0)) {
1254 IdentifierLoc *IL = AL.getArgAsIdent(0);
1255 if (!ReturnTypestateAttr::ConvertStrToConsumedState(IL->Ident->getName(),
1256 ReturnState)) {
1257 S.Diag(IL->Loc, diag::warn_attribute_type_not_supported) << AL
1258 << IL->Ident;
1259 return;
1260 }
1261 } else {
1262 S.Diag(AL.getLoc(), diag::err_attribute_argument_type)
1263 << AL << AANT_ArgumentIdentifier;
1264 return;
1265 }
1266
1267 // FIXME: This check is currently being done in the analysis. It can be
1268 // enabled here only after the parser propagates attributes at
1269 // template specialization definition, not declaration.
1270 //QualType ReturnType;
1271 //
1272 //if (const ParmVarDecl *Param = dyn_cast<ParmVarDecl>(D)) {
1273 // ReturnType = Param->getType();
1274 //
1275 //} else if (const CXXConstructorDecl *Constructor =
1276 // dyn_cast<CXXConstructorDecl>(D)) {
1277 // ReturnType = Constructor->getThisType()->getPointeeType();
1278 //
1279 //} else {
1280 //
1281 // ReturnType = cast<FunctionDecl>(D)->getCallResultType();
1282 //}
1283 //
1284 //const CXXRecordDecl *RD = ReturnType->getAsCXXRecordDecl();
1285 //
1286 //if (!RD || !RD->hasAttr<ConsumableAttr>()) {
1287 // S.Diag(Attr.getLoc(), diag::warn_return_state_for_unconsumable_type) <<
1288 // ReturnType.getAsString();
1289 // return;
1290 //}
1291
1292 D->addAttr(::new (S.Context)
1293 ReturnTypestateAttr(AL.getRange(), S.Context, ReturnState,
1294 AL.getAttributeSpellingListIndex()));
1295}
1296
1297static void handleSetTypestateAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1298 if (!checkForConsumableClass(S, cast<CXXMethodDecl>(D), AL))
1299 return;
1300
1301 SetTypestateAttr::ConsumedState NewState;
1302 if (AL.isArgIdent(0)) {
1303 IdentifierLoc *Ident = AL.getArgAsIdent(0);
1304 StringRef Param = Ident->Ident->getName();
1305 if (!SetTypestateAttr::ConvertStrToConsumedState(Param, NewState)) {
1306 S.Diag(Ident->Loc, diag::warn_attribute_type_not_supported) << AL
1307 << Param;
1308 return;
1309 }
1310 } else {
1311 S.Diag(AL.getLoc(), diag::err_attribute_argument_type)
1312 << AL << AANT_ArgumentIdentifier;
1313 return;
1314 }
1315
1316 D->addAttr(::new (S.Context)
1317 SetTypestateAttr(AL.getRange(), S.Context, NewState,
1318 AL.getAttributeSpellingListIndex()));
1319}
1320
1321static void handleTestTypestateAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1322 if (!checkForConsumableClass(S, cast<CXXMethodDecl>(D), AL))
1323 return;
1324
1325 TestTypestateAttr::ConsumedState TestState;
1326 if (AL.isArgIdent(0)) {
1327 IdentifierLoc *Ident = AL.getArgAsIdent(0);
1328 StringRef Param = Ident->Ident->getName();
1329 if (!TestTypestateAttr::ConvertStrToConsumedState(Param, TestState)) {
1330 S.Diag(Ident->Loc, diag::warn_attribute_type_not_supported) << AL
1331 << Param;
1332 return;
1333 }
1334 } else {
1335 S.Diag(AL.getLoc(), diag::err_attribute_argument_type)
1336 << AL << AANT_ArgumentIdentifier;
1337 return;
1338 }
1339
1340 D->addAttr(::new (S.Context)
1341 TestTypestateAttr(AL.getRange(), S.Context, TestState,
1342 AL.getAttributeSpellingListIndex()));
1343}
1344
1345static void handleExtVectorTypeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1346 // Remember this typedef decl, we will need it later for diagnostics.
1347 S.ExtVectorDecls.push_back(cast<TypedefNameDecl>(D));
1348}
1349
1350static void handlePackedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1351 if (auto *TD = dyn_cast<TagDecl>(D))
1352 TD->addAttr(::new (S.Context) PackedAttr(AL.getRange(), S.Context,
1353 AL.getAttributeSpellingListIndex()));
1354 else if (auto *FD = dyn_cast<FieldDecl>(D)) {
1355 bool BitfieldByteAligned = (!FD->getType()->isDependentType() &&
1356 !FD->getType()->isIncompleteType() &&
1357 FD->isBitField() &&
1358 S.Context.getTypeAlign(FD->getType()) <= 8);
1359
1360 if (S.getASTContext().getTargetInfo().getTriple().isPS4()) {
1361 if (BitfieldByteAligned)
1362 // The PS4 target needs to maintain ABI backwards compatibility.
1363 S.Diag(AL.getLoc(), diag::warn_attribute_ignored_for_field_of_type)
1364 << AL << FD->getType();
1365 else
1366 FD->addAttr(::new (S.Context) PackedAttr(
1367 AL.getRange(), S.Context, AL.getAttributeSpellingListIndex()));
1368 } else {
1369 // Report warning about changed offset in the newer compiler versions.
1370 if (BitfieldByteAligned)
1371 S.Diag(AL.getLoc(), diag::warn_attribute_packed_for_bitfield);
1372
1373 FD->addAttr(::new (S.Context) PackedAttr(
1374 AL.getRange(), S.Context, AL.getAttributeSpellingListIndex()));
1375 }
1376
1377 } else
1378 S.Diag(AL.getLoc(), diag::warn_attribute_ignored) << AL;
1379}
1380
1381static bool checkIBOutletCommon(Sema &S, Decl *D, const ParsedAttr &AL) {
1382 // The IBOutlet/IBOutletCollection attributes only apply to instance
1383 // variables or properties of Objective-C classes. The outlet must also
1384 // have an object reference type.
1385 if (const auto *VD = dyn_cast<ObjCIvarDecl>(D)) {
1386 if (!VD->getType()->getAs<ObjCObjectPointerType>()) {
1387 S.Diag(AL.getLoc(), diag::warn_iboutlet_object_type)
1388 << AL << VD->getType() << 0;
1389 return false;
1390 }
1391 }
1392 else if (const auto *PD = dyn_cast<ObjCPropertyDecl>(D)) {
1393 if (!PD->getType()->getAs<ObjCObjectPointerType>()) {
1394 S.Diag(AL.getLoc(), diag::warn_iboutlet_object_type)
1395 << AL << PD->getType() << 1;
1396 return false;
1397 }
1398 }
1399 else {
1400 S.Diag(AL.getLoc(), diag::warn_attribute_iboutlet) << AL;
1401 return false;
1402 }
1403
1404 return true;
1405}
1406
1407static void handleIBOutlet(Sema &S, Decl *D, const ParsedAttr &AL) {
1408 if (!checkIBOutletCommon(S, D, AL))
1409 return;
1410
1411 D->addAttr(::new (S.Context)
1412 IBOutletAttr(AL.getRange(), S.Context,
1413 AL.getAttributeSpellingListIndex()));
1414}
1415
1416static void handleIBOutletCollection(Sema &S, Decl *D, const ParsedAttr &AL) {
1417
1418 // The iboutletcollection attribute can have zero or one arguments.
1419 if (AL.getNumArgs() > 1) {
1420 S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) << AL << 1;
1421 return;
1422 }
1423
1424 if (!checkIBOutletCommon(S, D, AL))
1425 return;
1426
1427 ParsedType PT;
1428
1429 if (AL.hasParsedType())
1430 PT = AL.getTypeArg();
1431 else {
1432 PT = S.getTypeName(S.Context.Idents.get("NSObject"), AL.getLoc(),
1433 S.getScopeForContext(D->getDeclContext()->getParent()));
1434 if (!PT) {
1435 S.Diag(AL.getLoc(), diag::err_iboutletcollection_type) << "NSObject";
1436 return;
1437 }
1438 }
1439
1440 TypeSourceInfo *QTLoc = nullptr;
1441 QualType QT = S.GetTypeFromParser(PT, &QTLoc);
1442 if (!QTLoc)
1443 QTLoc = S.Context.getTrivialTypeSourceInfo(QT, AL.getLoc());
1444
1445 // Diagnose use of non-object type in iboutletcollection attribute.
1446 // FIXME. Gnu attribute extension ignores use of builtin types in
1447 // attributes. So, __attribute__((iboutletcollection(char))) will be
1448 // treated as __attribute__((iboutletcollection())).
1449 if (!QT->isObjCIdType() && !QT->isObjCObjectType()) {
1450 S.Diag(AL.getLoc(),
1451 QT->isBuiltinType() ? diag::err_iboutletcollection_builtintype
1452 : diag::err_iboutletcollection_type) << QT;
1453 return;
1454 }
1455
1456 D->addAttr(::new (S.Context)
1457 IBOutletCollectionAttr(AL.getRange(), S.Context, QTLoc,
1458 AL.getAttributeSpellingListIndex()));
1459}
1460
1461bool Sema::isValidPointerAttrType(QualType T, bool RefOkay) {
1462 if (RefOkay) {
1463 if (T->isReferenceType())
1464 return true;
1465 } else {
1466 T = T.getNonReferenceType();
1467 }
1468
1469 // The nonnull attribute, and other similar attributes, can be applied to a
1470 // transparent union that contains a pointer type.
1471 if (const RecordType *UT = T->getAsUnionType()) {
1472 if (UT && UT->getDecl()->hasAttr<TransparentUnionAttr>()) {
1473 RecordDecl *UD = UT->getDecl();
1474 for (const auto *I : UD->fields()) {
1475 QualType QT = I->getType();
1476 if (QT->isAnyPointerType() || QT->isBlockPointerType())
1477 return true;
1478 }
1479 }
1480 }
1481
1482 return T->isAnyPointerType() || T->isBlockPointerType();
1483}
1484
1485static bool attrNonNullArgCheck(Sema &S, QualType T, const ParsedAttr &AL,
1486 SourceRange AttrParmRange,
1487 SourceRange TypeRange,
1488 bool isReturnValue = false) {
1489 if (!S.isValidPointerAttrType(T)) {
1490 if (isReturnValue)
1491 S.Diag(AL.getLoc(), diag::warn_attribute_return_pointers_only)
1492 << AL << AttrParmRange << TypeRange;
1493 else
1494 S.Diag(AL.getLoc(), diag::warn_attribute_pointers_only)
1495 << AL << AttrParmRange << TypeRange << 0;
1496 return false;
1497 }
1498 return true;
1499}
1500
1501static void handleNonNullAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1502 SmallVector<ParamIdx, 8> NonNullArgs;
1503 for (unsigned I = 0; I < AL.getNumArgs(); ++I) {
1504 Expr *Ex = AL.getArgAsExpr(I);
1505 ParamIdx Idx;
1506 if (!checkFunctionOrMethodParameterIndex(S, D, AL, I + 1, Ex, Idx))
1507 return;
1508
1509 // Is the function argument a pointer type?
1510 if (Idx.getASTIndex() < getFunctionOrMethodNumParams(D) &&
1511 !attrNonNullArgCheck(
1512 S, getFunctionOrMethodParamType(D, Idx.getASTIndex()), AL,
1513 Ex->getSourceRange(),
1514 getFunctionOrMethodParamRange(D, Idx.getASTIndex())))
1515 continue;
1516
1517 NonNullArgs.push_back(Idx);
1518 }
1519
1520 // If no arguments were specified to __attribute__((nonnull)) then all pointer
1521 // arguments have a nonnull attribute; warn if there aren't any. Skip this
1522 // check if the attribute came from a macro expansion or a template
1523 // instantiation.
1524 if (NonNullArgs.empty() && AL.getLoc().isFileID() &&
1525 !S.inTemplateInstantiation()) {
1526 bool AnyPointers = isFunctionOrMethodVariadic(D);
1527 for (unsigned I = 0, E = getFunctionOrMethodNumParams(D);
1528 I != E && !AnyPointers; ++I) {
1529 QualType T = getFunctionOrMethodParamType(D, I);
1530 if (T->isDependentType() || S.isValidPointerAttrType(T))
1531 AnyPointers = true;
1532 }
1533
1534 if (!AnyPointers)
1535 S.Diag(AL.getLoc(), diag::warn_attribute_nonnull_no_pointers);
1536 }
1537
1538 ParamIdx *Start = NonNullArgs.data();
1539 unsigned Size = NonNullArgs.size();
1540 llvm::array_pod_sort(Start, Start + Size);
1541 D->addAttr(::new (S.Context)
1542 NonNullAttr(AL.getRange(), S.Context, Start, Size,
1543 AL.getAttributeSpellingListIndex()));
1544}
1545
1546static void handleNonNullAttrParameter(Sema &S, ParmVarDecl *D,
1547 const ParsedAttr &AL) {
1548 if (AL.getNumArgs() > 0) {
1549 if (D->getFunctionType()) {
1550 handleNonNullAttr(S, D, AL);
1551 } else {
1552 S.Diag(AL.getLoc(), diag::warn_attribute_nonnull_parm_no_args)
1553 << D->getSourceRange();
1554 }
1555 return;
1556 }
1557
1558 // Is the argument a pointer type?
1559 if (!attrNonNullArgCheck(S, D->getType(), AL, SourceRange(),
1560 D->getSourceRange()))
1561 return;
1562
1563 D->addAttr(::new (S.Context)
1564 NonNullAttr(AL.getRange(), S.Context, nullptr, 0,
1565 AL.getAttributeSpellingListIndex()));
1566}
1567
1568static void handleReturnsNonNullAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1569 QualType ResultType = getFunctionOrMethodResultType(D);
1570 SourceRange SR = getFunctionOrMethodResultSourceRange(D);
1571 if (!attrNonNullArgCheck(S, ResultType, AL, SourceRange(), SR,
1572 /* isReturnValue */ true))
1573 return;
1574
1575 D->addAttr(::new (S.Context)
1576 ReturnsNonNullAttr(AL.getRange(), S.Context,
1577 AL.getAttributeSpellingListIndex()));
1578}
1579
1580static void handleNoEscapeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1581 if (D->isInvalidDecl())
1582 return;
1583
1584 // noescape only applies to pointer types.
1585 QualType T = cast<ParmVarDecl>(D)->getType();
1586 if (!S.isValidPointerAttrType(T, /* RefOkay */ true)) {
1587 S.Diag(AL.getLoc(), diag::warn_attribute_pointers_only)
1588 << AL << AL.getRange() << 0;
1589 return;
1590 }
1591
1592 D->addAttr(::new (S.Context) NoEscapeAttr(
1593 AL.getRange(), S.Context, AL.getAttributeSpellingListIndex()));
1594}
1595
1596static void handleAssumeAlignedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1597 Expr *E = AL.getArgAsExpr(0),
1598 *OE = AL.getNumArgs() > 1 ? AL.getArgAsExpr(1) : nullptr;
1599 S.AddAssumeAlignedAttr(AL.getRange(), D, E, OE,
1600 AL.getAttributeSpellingListIndex());
1601}
1602
1603static void handleAllocAlignAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1604 S.AddAllocAlignAttr(AL.getRange(), D, AL.getArgAsExpr(0),
1605 AL.getAttributeSpellingListIndex());
1606}
1607
1608void Sema::AddAssumeAlignedAttr(SourceRange AttrRange, Decl *D, Expr *E,
1609 Expr *OE, unsigned SpellingListIndex) {
1610 QualType ResultType = getFunctionOrMethodResultType(D);
1611 SourceRange SR = getFunctionOrMethodResultSourceRange(D);
1612
1613 AssumeAlignedAttr TmpAttr(AttrRange, Context, E, OE, SpellingListIndex);
1614 SourceLocation AttrLoc = AttrRange.getBegin();
1615
1616 if (!isValidPointerAttrType(ResultType, /* RefOkay */ true)) {
1617 Diag(AttrLoc, diag::warn_attribute_return_pointers_refs_only)
1618 << &TmpAttr << AttrRange << SR;
1619 return;
1620 }
1621
1622 if (!E->isValueDependent()) {
1623 llvm::APSInt I(64);
1624 if (!E->isIntegerConstantExpr(I, Context)) {
1625 if (OE)
1626 Diag(AttrLoc, diag::err_attribute_argument_n_type)
1627 << &TmpAttr << 1 << AANT_ArgumentIntegerConstant
1628 << E->getSourceRange();
1629 else
1630 Diag(AttrLoc, diag::err_attribute_argument_type)
1631 << &TmpAttr << AANT_ArgumentIntegerConstant
1632 << E->getSourceRange();
1633 return;
1634 }
1635
1636 if (!I.isPowerOf2()) {
1637 Diag(AttrLoc, diag::err_alignment_not_power_of_two)
1638 << E->getSourceRange();
1639 return;
1640 }
1641 }
1642
1643 if (OE) {
1644 if (!OE->isValueDependent()) {
1645 llvm::APSInt I(64);
1646 if (!OE->isIntegerConstantExpr(I, Context)) {
1647 Diag(AttrLoc, diag::err_attribute_argument_n_type)
1648 << &TmpAttr << 2 << AANT_ArgumentIntegerConstant
1649 << OE->getSourceRange();
1650 return;
1651 }
1652 }
1653 }
1654
1655 D->addAttr(::new (Context)
1656 AssumeAlignedAttr(AttrRange, Context, E, OE, SpellingListIndex));
1657}
1658
1659void Sema::AddAllocAlignAttr(SourceRange AttrRange, Decl *D, Expr *ParamExpr,
1660 unsigned SpellingListIndex) {
1661 QualType ResultType = getFunctionOrMethodResultType(D);
1662
1663 AllocAlignAttr TmpAttr(AttrRange, Context, ParamIdx(), SpellingListIndex);
1664 SourceLocation AttrLoc = AttrRange.getBegin();
1665
1666 if (!ResultType->isDependentType() &&
1667 !isValidPointerAttrType(ResultType, /* RefOkay */ true)) {
1668 Diag(AttrLoc, diag::warn_attribute_return_pointers_refs_only)
1669 << &TmpAttr << AttrRange << getFunctionOrMethodResultSourceRange(D);
1670 return;
1671 }
1672
1673 ParamIdx Idx;
1674 const auto *FuncDecl = cast<FunctionDecl>(D);
1675 if (!checkFunctionOrMethodParameterIndex(*this, FuncDecl, TmpAttr,
1676 /*AttrArgNo=*/1, ParamExpr, Idx))
1677 return;
1678
1679 QualType Ty = getFunctionOrMethodParamType(D, Idx.getASTIndex());
1680 if (!Ty->isDependentType() && !Ty->isIntegralType(Context)) {
1681 Diag(ParamExpr->getBeginLoc(), diag::err_attribute_integers_only)
1682 << &TmpAttr
1683 << FuncDecl->getParamDecl(Idx.getASTIndex())->getSourceRange();
1684 return;
1685 }
1686
1687 D->addAttr(::new (Context)
1688 AllocAlignAttr(AttrRange, Context, Idx, SpellingListIndex));
1689}
1690
1691/// Normalize the attribute, __foo__ becomes foo.
1692/// Returns true if normalization was applied.
1693static bool normalizeName(StringRef &AttrName) {
1694 if (AttrName.size() > 4 && AttrName.startswith("__") &&
1695 AttrName.endswith("__")) {
1696 AttrName = AttrName.drop_front(2).drop_back(2);
1697 return true;
1698 }
1699 return false;
1700}
1701
1702static void handleOwnershipAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1703 // This attribute must be applied to a function declaration. The first
1704 // argument to the attribute must be an identifier, the name of the resource,
1705 // for example: malloc. The following arguments must be argument indexes, the
1706 // arguments must be of integer type for Returns, otherwise of pointer type.
1707 // The difference between Holds and Takes is that a pointer may still be used
1708 // after being held. free() should be __attribute((ownership_takes)), whereas
1709 // a list append function may well be __attribute((ownership_holds)).
1710
1711 if (!AL.isArgIdent(0)) {
1712 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
1713 << AL << 1 << AANT_ArgumentIdentifier;
1714 return;
1715 }
1716
1717 // Figure out our Kind.
1718 OwnershipAttr::OwnershipKind K =
1719 OwnershipAttr(AL.getLoc(), S.Context, nullptr, nullptr, 0,
1720 AL.getAttributeSpellingListIndex()).getOwnKind();
1721
1722 // Check arguments.
1723 switch (K) {
1724 case OwnershipAttr::Takes:
1725 case OwnershipAttr::Holds:
1726 if (AL.getNumArgs() < 2) {
1727 S.Diag(AL.getLoc(), diag::err_attribute_too_few_arguments) << AL << 2;
1728 return;
1729 }
1730 break;
1731 case OwnershipAttr::Returns:
1732 if (AL.getNumArgs() > 2) {
1733 S.Diag(AL.getLoc(), diag::err_attribute_too_many_arguments) << AL << 1;
1734 return;
1735 }
1736 break;
1737 }
1738
1739 IdentifierInfo *Module = AL.getArgAsIdent(0)->Ident;
1740
1741 StringRef ModuleName = Module->getName();
1742 if (normalizeName(ModuleName)) {
1743 Module = &S.PP.getIdentifierTable().get(ModuleName);
1744 }
1745
1746 SmallVector<ParamIdx, 8> OwnershipArgs;
1747 for (unsigned i = 1; i < AL.getNumArgs(); ++i) {
1748 Expr *Ex = AL.getArgAsExpr(i);
1749 ParamIdx Idx;
1750 if (!checkFunctionOrMethodParameterIndex(S, D, AL, i, Ex, Idx))
1751 return;
1752
1753 // Is the function argument a pointer type?
1754 QualType T = getFunctionOrMethodParamType(D, Idx.getASTIndex());
1755 int Err = -1; // No error
1756 switch (K) {
1757 case OwnershipAttr::Takes:
1758 case OwnershipAttr::Holds:
1759 if (!T->isAnyPointerType() && !T->isBlockPointerType())
1760 Err = 0;
1761 break;
1762 case OwnershipAttr::Returns:
1763 if (!T->isIntegerType())
1764 Err = 1;
1765 break;
1766 }
1767 if (-1 != Err) {
1768 S.Diag(AL.getLoc(), diag::err_ownership_type) << AL << Err
1769 << Ex->getSourceRange();
1770 return;
1771 }
1772
1773 // Check we don't have a conflict with another ownership attribute.
1774 for (const auto *I : D->specific_attrs<OwnershipAttr>()) {
1775 // Cannot have two ownership attributes of different kinds for the same
1776 // index.
1777 if (I->getOwnKind() != K && I->args_end() !=
1778 std::find(I->args_begin(), I->args_end(), Idx)) {
1779 S.Diag(AL.getLoc(), diag::err_attributes_are_not_compatible) << AL << I;
1780 return;
1781 } else if (K == OwnershipAttr::Returns &&
1782 I->getOwnKind() == OwnershipAttr::Returns) {
1783 // A returns attribute conflicts with any other returns attribute using
1784 // a different index.
1785 if (std::find(I->args_begin(), I->args_end(), Idx) == I->args_end()) {
1786 S.Diag(I->getLocation(), diag::err_ownership_returns_index_mismatch)
1787 << I->args_begin()->getSourceIndex();
1788 if (I->args_size())
1789 S.Diag(AL.getLoc(), diag::note_ownership_returns_index_mismatch)
1790 << Idx.getSourceIndex() << Ex->getSourceRange();
1791 return;
1792 }
1793 }
1794 }
1795 OwnershipArgs.push_back(Idx);
1796 }
1797
1798 ParamIdx *Start = OwnershipArgs.data();
1799 unsigned Size = OwnershipArgs.size();
1800 llvm::array_pod_sort(Start, Start + Size);
1801 D->addAttr(::new (S.Context)
1802 OwnershipAttr(AL.getLoc(), S.Context, Module, Start, Size,
1803 AL.getAttributeSpellingListIndex()));
1804}
1805
1806static void handleWeakRefAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1807 // Check the attribute arguments.
1808 if (AL.getNumArgs() > 1) {
1809 S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) << AL << 1;
1810 return;
1811 }
1812
1813 // gcc rejects
1814 // class c {
1815 // static int a __attribute__((weakref ("v2")));
1816 // static int b() __attribute__((weakref ("f3")));
1817 // };
1818 // and ignores the attributes of
1819 // void f(void) {
1820 // static int a __attribute__((weakref ("v2")));
1821 // }
1822 // we reject them
1823 const DeclContext *Ctx = D->getDeclContext()->getRedeclContext();
1824 if (!Ctx->isFileContext()) {
1825 S.Diag(AL.getLoc(), diag::err_attribute_weakref_not_global_context)
1826 << cast<NamedDecl>(D);
1827 return;
1828 }
1829
1830 // The GCC manual says
1831 //
1832 // At present, a declaration to which `weakref' is attached can only
1833 // be `static'.
1834 //
1835 // It also says
1836 //
1837 // Without a TARGET,
1838 // given as an argument to `weakref' or to `alias', `weakref' is
1839 // equivalent to `weak'.
1840 //
1841 // gcc 4.4.1 will accept
1842 // int a7 __attribute__((weakref));
1843 // as
1844 // int a7 __attribute__((weak));
1845 // This looks like a bug in gcc. We reject that for now. We should revisit
1846 // it if this behaviour is actually used.
1847
1848 // GCC rejects
1849 // static ((alias ("y"), weakref)).
1850 // Should we? How to check that weakref is before or after alias?
1851
1852 // FIXME: it would be good for us to keep the WeakRefAttr as-written instead
1853 // of transforming it into an AliasAttr. The WeakRefAttr never uses the
1854 // StringRef parameter it was given anyway.
1855 StringRef Str;
1856 if (AL.getNumArgs() && S.checkStringLiteralArgumentAttr(AL, 0, Str))
1857 // GCC will accept anything as the argument of weakref. Should we
1858 // check for an existing decl?
1859 D->addAttr(::new (S.Context) AliasAttr(AL.getRange(), S.Context, Str,
1860 AL.getAttributeSpellingListIndex()));
1861
1862 D->addAttr(::new (S.Context)
1863 WeakRefAttr(AL.getRange(), S.Context,
1864 AL.getAttributeSpellingListIndex()));
1865}
1866
1867static void handleIFuncAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1868 StringRef Str;
1869 if (!S.checkStringLiteralArgumentAttr(AL, 0, Str))
1870 return;
1871
1872 // Aliases should be on declarations, not definitions.
1873 const auto *FD = cast<FunctionDecl>(D);
1874 if (FD->isThisDeclarationADefinition()) {
1875 S.Diag(AL.getLoc(), diag::err_alias_is_definition) << FD << 1;
1876 return;
1877 }
1878
1879 D->addAttr(::new (S.Context) IFuncAttr(AL.getRange(), S.Context, Str,
1880 AL.getAttributeSpellingListIndex()));
1881}
1882
1883static 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(AL.getRange(), S.Context, Str,
1922 AL.getAttributeSpellingListIndex()));
1923}
1924
1925static void handleTLSModelAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1926 StringRef Model;
1927 SourceLocation LiteralLoc;
1928 // Check that it is a string.
1929 if (!S.checkStringLiteralArgumentAttr(AL, 0, Model, &LiteralLoc))
1930 return;
1931
1932 // Check that the value.
1933 if (Model != "global-dynamic" && Model != "local-dynamic"
1934 && Model != "initial-exec" && Model != "local-exec") {
1935 S.Diag(LiteralLoc, diag::err_attr_tlsmodel_arg);
1936 return;
1937 }
1938
1939 D->addAttr(::new (S.Context)
1940 TLSModelAttr(AL.getRange(), S.Context, Model,
1941 AL.getAttributeSpellingListIndex()));
1942}
1943
1944static void handleRestrictAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1945 QualType ResultType = getFunctionOrMethodResultType(D);
1946 if (ResultType->isAnyPointerType() || ResultType->isBlockPointerType()) {
1947 D->addAttr(::new (S.Context) RestrictAttr(
1948 AL.getRange(), S.Context, AL.getAttributeSpellingListIndex()));
1949 return;
1950 }
1951
1952 S.Diag(AL.getLoc(), diag::warn_attribute_return_pointers_only)
1953 << AL << getFunctionOrMethodResultSourceRange(D);
1954}
1955
1956static void handleCPUSpecificAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
1957 FunctionDecl *FD = cast<FunctionDecl>(D);
1958
1959 if (const auto *MD = dyn_cast<CXXMethodDecl>(D)) {
1960 if (MD->getParent()->isLambda()) {
1961 S.Diag(AL.getLoc(), diag::err_attribute_dll_lambda) << AL;
1962 return;
1963 }
1964 }
1965
1966 if (!checkAttributeAtLeastNumArgs(S, AL, 1))
1967 return;
1968
1969 SmallVector<IdentifierInfo *, 8> CPUs;
1970 for (unsigned ArgNo = 0; ArgNo < getNumAttributeArgs(AL); ++ArgNo) {
1971 if (!AL.isArgIdent(ArgNo)) {
1972 S.Diag(AL.getLoc(), diag::err_attribute_argument_type)
1973 << AL << AANT_ArgumentIdentifier;
1974 return;
1975 }
1976
1977 IdentifierLoc *CPUArg = AL.getArgAsIdent(ArgNo);
1978 StringRef CPUName = CPUArg->Ident->getName().trim();
1979
1980 if (!S.Context.getTargetInfo().validateCPUSpecificCPUDispatch(CPUName)) {
1981 S.Diag(CPUArg->Loc, diag::err_invalid_cpu_specific_dispatch_value)
1982 << CPUName << (AL.getKind() == ParsedAttr::AT_CPUDispatch);
1983 return;
1984 }
1985
1986 const TargetInfo &Target = S.Context.getTargetInfo();
1987 if (llvm::any_of(CPUs, [CPUName, &Target](const IdentifierInfo *Cur) {
1988 return Target.CPUSpecificManglingCharacter(CPUName) ==
1989 Target.CPUSpecificManglingCharacter(Cur->getName());
1990 })) {
1991 S.Diag(AL.getLoc(), diag::warn_multiversion_duplicate_entries);
1992 return;
1993 }
1994 CPUs.push_back(CPUArg->Ident);
1995 }
1996
1997 FD->setIsMultiVersion(true);
1998 if (AL.getKind() == ParsedAttr::AT_CPUSpecific)
1999 D->addAttr(::new (S.Context) CPUSpecificAttr(
2000 AL.getRange(), S.Context, CPUs.data(), CPUs.size(),
2001 AL.getAttributeSpellingListIndex()));
2002 else
2003 D->addAttr(::new (S.Context) CPUDispatchAttr(
2004 AL.getRange(), S.Context, CPUs.data(), CPUs.size(),
2005 AL.getAttributeSpellingListIndex()));
2006}
2007
2008static 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 if (CommonAttr *CA = S.mergeCommonAttr(D, AL))
2016 D->addAttr(CA);
2017}
2018
2019static void handleNakedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2020 if (checkAttrMutualExclusion<DisableTailCallsAttr>(S, D, AL))
2021 return;
2022
2023 if (AL.isDeclspecAttribute()) {
2024 const auto &Triple = S.getASTContext().getTargetInfo().getTriple();
2025 const auto &Arch = Triple.getArch();
2026 if (Arch != llvm::Triple::x86 &&
2027 (Arch != llvm::Triple::arm && Arch != llvm::Triple::thumb)) {
2028 S.Diag(AL.getLoc(), diag::err_attribute_not_supported_on_arch)
2029 << AL << Triple.getArchName();
2030 return;
2031 }
2032 }
2033
2034 D->addAttr(::new (S.Context) NakedAttr(AL.getRange(), S.Context,
2035 AL.getAttributeSpellingListIndex()));
2036}
2037
2038static void handleNoReturnAttr(Sema &S, Decl *D, const ParsedAttr &Attrs) {
2039 if (hasDeclarator(D)) return;
2040
2041 if (!isa<ObjCMethodDecl>(D)) {
2042 S.Diag(Attrs.getLoc(), diag::warn_attribute_wrong_decl_type)
2043 << Attrs << ExpectedFunctionOrMethod;
2044 return;
2045 }
2046
2047 D->addAttr(::new (S.Context) NoReturnAttr(
2048 Attrs.getRange(), S.Context, Attrs.getAttributeSpellingListIndex()));
2049}
2050
2051static void handleNoCfCheckAttr(Sema &S, Decl *D, const ParsedAttr &Attrs) {
2052 if (!S.getLangOpts().CFProtectionBranch)
2053 S.Diag(Attrs.getLoc(), diag::warn_nocf_check_attribute_ignored);
2054 else
2055 handleSimpleAttribute<AnyX86NoCfCheckAttr>(S, D, Attrs);
2056}
2057
2058bool Sema::CheckAttrNoArgs(const ParsedAttr &Attrs) {
2059 if (!checkAttributeNumArgs(*this, Attrs, 0)) {
2060 Attrs.setInvalid();
2061 return true;
2062 }
2063
2064 return false;
2065}
2066
2067bool Sema::CheckAttrTarget(const ParsedAttr &AL) {
2068 // Check whether the attribute is valid on the current target.
2069 if (!AL.existsInTarget(Context.getTargetInfo())) {
2070 Diag(AL.getLoc(), diag::warn_unknown_attribute_ignored) << AL;
2071 AL.setInvalid();
2072 return true;
2073 }
2074
2075 return false;
2076}
2077
2078static void handleAnalyzerNoReturnAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2079
2080 // The checking path for 'noreturn' and 'analyzer_noreturn' are different
2081 // because 'analyzer_noreturn' does not impact the type.
2082 if (!isFunctionOrMethodOrBlock(D)) {
2083 ValueDecl *VD = dyn_cast<ValueDecl>(D);
2084 if (!VD || (!VD->getType()->isBlockPointerType() &&
2085 !VD->getType()->isFunctionPointerType())) {
2086 S.Diag(AL.getLoc(), AL.isCXX11Attribute()
2087 ? diag::err_attribute_wrong_decl_type
2088 : diag::warn_attribute_wrong_decl_type)
2089 << AL << ExpectedFunctionMethodOrBlock;
2090 return;
2091 }
2092 }
2093
2094 D->addAttr(::new (S.Context)
2095 AnalyzerNoReturnAttr(AL.getRange(), S.Context,
2096 AL.getAttributeSpellingListIndex()));
2097}
2098
2099// PS3 PPU-specific.
2100static void handleVecReturnAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2101 /*
2102 Returning a Vector Class in Registers
2103
2104 According to the PPU ABI specifications, a class with a single member of
2105 vector type is returned in memory when used as the return value of a
2106 function.
2107 This results in inefficient code when implementing vector classes. To return
2108 the value in a single vector register, add the vecreturn attribute to the
2109 class definition. This attribute is also applicable to struct types.
2110
2111 Example:
2112
2113 struct Vector
2114 {
2115 __vector float xyzw;
2116 } __attribute__((vecreturn));
2117
2118 Vector Add(Vector lhs, Vector rhs)
2119 {
2120 Vector result;
2121 result.xyzw = vec_add(lhs.xyzw, rhs.xyzw);
2122 return result; // This will be returned in a register
2123 }
2124 */
2125 if (VecReturnAttr *A = D->getAttr<VecReturnAttr>()) {
2126 S.Diag(AL.getLoc(), diag::err_repeat_attribute) << A;
2127 return;
2128 }
2129
2130 const auto *R = cast<RecordDecl>(D);
2131 int count = 0;
2132
2133 if (!isa<CXXRecordDecl>(R)) {
2134 S.Diag(AL.getLoc(), diag::err_attribute_vecreturn_only_vector_member);
2135 return;
2136 }
2137
2138 if (!cast<CXXRecordDecl>(R)->isPOD()) {
2139 S.Diag(AL.getLoc(), diag::err_attribute_vecreturn_only_pod_record);
2140 return;
2141 }
2142
2143 for (const auto *I : R->fields()) {
2144 if ((count == 1) || !I->getType()->isVectorType()) {
2145 S.Diag(AL.getLoc(), diag::err_attribute_vecreturn_only_vector_member);
2146 return;
2147 }
2148 count++;
2149 }
2150
2151 D->addAttr(::new (S.Context) VecReturnAttr(
2152 AL.getRange(), S.Context, AL.getAttributeSpellingListIndex()));
2153}
2154
2155static void handleDependencyAttr(Sema &S, Scope *Scope, Decl *D,
2156 const ParsedAttr &AL) {
2157 if (isa<ParmVarDecl>(D)) {
2158 // [[carries_dependency]] can only be applied to a parameter if it is a
2159 // parameter of a function declaration or lambda.
2160 if (!(Scope->getFlags() & clang::Scope::FunctionDeclarationScope)) {
2161 S.Diag(AL.getLoc(),
2162 diag::err_carries_dependency_param_not_function_decl);
2163 return;
2164 }
2165 }
2166
2167 D->addAttr(::new (S.Context) CarriesDependencyAttr(
2168 AL.getRange(), S.Context,
2169 AL.getAttributeSpellingListIndex()));
2170}
2171
2172static void handleUnusedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2173 bool IsCXX17Attr = AL.isCXX11Attribute() && !AL.getScopeName();
2174
2175 // If this is spelled as the standard C++17 attribute, but not in C++17, warn
2176 // about using it as an extension.
2177 if (!S.getLangOpts().CPlusPlus17 && IsCXX17Attr)
2178 S.Diag(AL.getLoc(), diag::ext_cxx17_attr) << AL;
2179
2180 D->addAttr(::new (S.Context) UnusedAttr(
2181 AL.getRange(), S.Context, AL.getAttributeSpellingListIndex()));
2182}
2183
2184static void handleConstructorAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2185 uint32_t priority = ConstructorAttr::DefaultPriority;
2186 if (AL.getNumArgs() &&
2187 !checkUInt32Argument(S, AL, AL.getArgAsExpr(0), priority))
2188 return;
2189
2190 D->addAttr(::new (S.Context)
2191 ConstructorAttr(AL.getRange(), S.Context, priority,
2192 AL.getAttributeSpellingListIndex()));
2193}
2194
2195static void handleDestructorAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2196 uint32_t priority = DestructorAttr::DefaultPriority;
2197 if (AL.getNumArgs() &&
2198 !checkUInt32Argument(S, AL, AL.getArgAsExpr(0), priority))
2199 return;
2200
2201 D->addAttr(::new (S.Context)
2202 DestructorAttr(AL.getRange(), S.Context, priority,
2203 AL.getAttributeSpellingListIndex()));
2204}
2205
2206template <typename AttrTy>
2207static 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(AL.getRange(), S.Context, Str,
2214 AL.getAttributeSpellingListIndex()));
2215}
2216
2217static void handleObjCSuppresProtocolAttr(Sema &S, Decl *D,
2218 const ParsedAttr &AL) {
2219 if (!cast<ObjCProtocolDecl>(D)->isThisDeclarationADefinition()) {
2220 S.Diag(AL.getLoc(), diag::err_objc_attr_protocol_requires_definition)
2221 << AL << AL.getRange();
2222 return;
2223 }
2224
2225 D->addAttr(::new (S.Context)
2226 ObjCExplicitProtocolImplAttr(AL.getRange(), S.Context,
2227 AL.getAttributeSpellingListIndex()));
2228}
2229
2230static bool checkAvailabilityAttr(Sema &S, SourceRange Range,
2231 IdentifierInfo *Platform,
2232 VersionTuple Introduced,
2233 VersionTuple Deprecated,
2234 VersionTuple Obsoleted) {
2235 StringRef PlatformName
2236 = AvailabilityAttr::getPrettyPlatformName(Platform->getName());
2237 if (PlatformName.empty())
2238 PlatformName = Platform->getName();
2239
2240 // Ensure that Introduced <= Deprecated <= Obsoleted (although not all
2241 // of these steps are needed).
2242 if (!Introduced.empty() && !Deprecated.empty() &&
2243 !(Introduced <= Deprecated)) {
2244 S.Diag(Range.getBegin(), diag::warn_availability_version_ordering)
2245 << 1 << PlatformName << Deprecated.getAsString()
2246 << 0 << Introduced.getAsString();
2247 return true;
2248 }
2249
2250 if (!Introduced.empty() && !Obsoleted.empty() &&
2251 !(Introduced <= Obsoleted)) {
2252 S.Diag(Range.getBegin(), diag::warn_availability_version_ordering)
2253 << 2 << PlatformName << Obsoleted.getAsString()
2254 << 0 << Introduced.getAsString();
2255 return true;
2256 }
2257
2258 if (!Deprecated.empty() && !Obsoleted.empty() &&
2259 !(Deprecated <= Obsoleted)) {
2260 S.Diag(Range.getBegin(), diag::warn_availability_version_ordering)
2261 << 2 << PlatformName << Obsoleted.getAsString()
2262 << 1 << Deprecated.getAsString();
2263 return true;
2264 }
2265
2266 return false;
2267}
2268
2269/// Check whether the two versions match.
2270///
2271/// If either version tuple is empty, then they are assumed to match. If
2272/// \p BeforeIsOkay is true, then \p X can be less than or equal to \p Y.
2273static bool versionsMatch(const VersionTuple &X, const VersionTuple &Y,
2274 bool BeforeIsOkay) {
2275 if (X.empty() || Y.empty())
2276 return true;
2277
2278 if (X == Y)
2279 return true;
2280
2281 if (BeforeIsOkay && X < Y)
2282 return true;
2283
2284 return false;
2285}
2286
2287AvailabilityAttr *Sema::mergeAvailabilityAttr(
2288 NamedDecl *D, SourceRange Range, IdentifierInfo *Platform, bool Implicit,
2289 VersionTuple Introduced, VersionTuple Deprecated, VersionTuple Obsoleted,
2290 bool IsUnavailable, StringRef Message, bool IsStrict, StringRef Replacement,
2291 AvailabilityMergeKind AMK, int Priority, unsigned AttrSpellingListIndex) {
2292 VersionTuple MergedIntroduced = Introduced;
2293 VersionTuple MergedDeprecated = Deprecated;
2294 VersionTuple MergedObsoleted = Obsoleted;
2295 bool FoundAny = false;
2296 bool OverrideOrImpl = false;
2297 switch (AMK) {
2298 case AMK_None:
2299 case AMK_Redeclaration:
2300 OverrideOrImpl = false;
2301 break;
2302
2303 case AMK_Override:
2304 case AMK_ProtocolImplementation:
2305 OverrideOrImpl = true;
2306 break;
2307 }
2308
2309 if (D->hasAttrs()) {
2310 AttrVec &Attrs = D->getAttrs();
2311 for (unsigned i = 0, e = Attrs.size(); i != e;) {
2312 const auto *OldAA = dyn_cast<AvailabilityAttr>(Attrs[i]);
2313 if (!OldAA) {
2314 ++i;
2315 continue;
2316 }
2317
2318 IdentifierInfo *OldPlatform = OldAA->getPlatform();
2319 if (OldPlatform != Platform) {
2320 ++i;
2321 continue;
2322 }
2323
2324 // If there is an existing availability attribute for this platform that
2325 // has a lower priority use the existing one and discard the new
2326 // attribute.
2327 if (OldAA->getPriority() < Priority)
2328 return nullptr;
2329
2330 // If there is an existing attribute for this platform that has a higher
2331 // priority than the new attribute then erase the old one and continue
2332 // processing the attributes.
2333 if (OldAA->getPriority() > Priority) {
2334 Attrs.erase(Attrs.begin() + i);
2335 --e;
2336 continue;
2337 }
2338
2339 FoundAny = true;
2340 VersionTuple OldIntroduced = OldAA->getIntroduced();
2341 VersionTuple OldDeprecated = OldAA->getDeprecated();
2342 VersionTuple OldObsoleted = OldAA->getObsoleted();
2343 bool OldIsUnavailable = OldAA->getUnavailable();
2344
2345 if (!versionsMatch(OldIntroduced, Introduced, OverrideOrImpl) ||
2346 !versionsMatch(Deprecated, OldDeprecated, OverrideOrImpl) ||
2347 !versionsMatch(Obsoleted, OldObsoleted, OverrideOrImpl) ||
2348 !(OldIsUnavailable == IsUnavailable ||
2349 (OverrideOrImpl && !OldIsUnavailable && IsUnavailable))) {
2350 if (OverrideOrImpl) {
2351 int Which = -1;
2352 VersionTuple FirstVersion;
2353 VersionTuple SecondVersion;
2354 if (!versionsMatch(OldIntroduced, Introduced, OverrideOrImpl)) {
2355 Which = 0;
2356 FirstVersion = OldIntroduced;
2357 SecondVersion = Introduced;
2358 } else if (!versionsMatch(Deprecated, OldDeprecated, OverrideOrImpl)) {
2359 Which = 1;
2360 FirstVersion = Deprecated;
2361 SecondVersion = OldDeprecated;
2362 } else if (!versionsMatch(Obsoleted, OldObsoleted, OverrideOrImpl)) {
2363 Which = 2;
2364 FirstVersion = Obsoleted;
2365 SecondVersion = OldObsoleted;
2366 }
2367
2368 if (Which == -1) {
2369 Diag(OldAA->getLocation(),
2370 diag::warn_mismatched_availability_override_unavail)
2371 << AvailabilityAttr::getPrettyPlatformName(Platform->getName())
2372 << (AMK == AMK_Override);
2373 } else {
2374 Diag(OldAA->getLocation(),
2375 diag::warn_mismatched_availability_override)
2376 << Which
2377 << AvailabilityAttr::getPrettyPlatformName(Platform->getName())
2378 << FirstVersion.getAsString() << SecondVersion.getAsString()
2379 << (AMK == AMK_Override);
2380 }
2381 if (AMK == AMK_Override)
2382 Diag(Range.getBegin(), diag::note_overridden_method);
2383 else
2384 Diag(Range.getBegin(), diag::note_protocol_method);
2385 } else {
2386 Diag(OldAA->getLocation(), diag::warn_mismatched_availability);
2387 Diag(Range.getBegin(), diag::note_previous_attribute);
2388 }
2389
2390 Attrs.erase(Attrs.begin() + i);
2391 --e;
2392 continue;
2393 }
2394
2395 VersionTuple MergedIntroduced2 = MergedIntroduced;
2396 VersionTuple MergedDeprecated2 = MergedDeprecated;
2397 VersionTuple MergedObsoleted2 = MergedObsoleted;
2398
2399 if (MergedIntroduced2.empty())
2400 MergedIntroduced2 = OldIntroduced;
2401 if (MergedDeprecated2.empty())
2402 MergedDeprecated2 = OldDeprecated;
2403 if (MergedObsoleted2.empty())
2404 MergedObsoleted2 = OldObsoleted;
2405
2406 if (checkAvailabilityAttr(*this, OldAA->getRange(), Platform,
2407 MergedIntroduced2, MergedDeprecated2,
2408 MergedObsoleted2)) {
2409 Attrs.erase(Attrs.begin() + i);
2410 --e;
2411 continue;
2412 }
2413
2414 MergedIntroduced = MergedIntroduced2;
2415 MergedDeprecated = MergedDeprecated2;
2416 MergedObsoleted = MergedObsoleted2;
2417 ++i;
2418 }
2419 }
2420
2421 if (FoundAny &&
2422 MergedIntroduced == Introduced &&
2423 MergedDeprecated == Deprecated &&
2424 MergedObsoleted == Obsoleted)
2425 return nullptr;
2426
2427 // Only create a new attribute if !OverrideOrImpl, but we want to do
2428 // the checking.
2429 if (!checkAvailabilityAttr(*this, Range, Platform, MergedIntroduced,
2430 MergedDeprecated, MergedObsoleted) &&
2431 !OverrideOrImpl) {
2432 auto *Avail = ::new (Context)
2433 AvailabilityAttr(Range, Context, Platform, Introduced, Deprecated,
2434 Obsoleted, IsUnavailable, Message, IsStrict,
2435 Replacement, Priority, AttrSpellingListIndex);
2436 Avail->setImplicit(Implicit);
2437 return Avail;
2438 }
2439 return nullptr;
2440}
2441
2442static void handleAvailabilityAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2443 if (!checkAttributeNumArgs(S, AL, 1))
2444 return;
2445 IdentifierLoc *Platform = AL.getArgAsIdent(0);
2446 unsigned Index = AL.getAttributeSpellingListIndex();
2447
2448 IdentifierInfo *II = Platform->Ident;
2449 if (AvailabilityAttr::getPrettyPlatformName(II->getName()).empty())
2450 S.Diag(Platform->Loc, diag::warn_availability_unknown_platform)
2451 << Platform->Ident;
2452
2453 auto *ND = dyn_cast<NamedDecl>(D);
2454 if (!ND) // We warned about this already, so just return.
2455 return;
2456
2457 AvailabilityChange Introduced = AL.getAvailabilityIntroduced();
2458 AvailabilityChange Deprecated = AL.getAvailabilityDeprecated();
2459 AvailabilityChange Obsoleted = AL.getAvailabilityObsoleted();
2460 bool IsUnavailable = AL.getUnavailableLoc().isValid();
2461 bool IsStrict = AL.getStrictLoc().isValid();
2462 StringRef Str;
2463 if (const auto *SE = dyn_cast_or_null<StringLiteral>(AL.getMessageExpr()))
2464 Str = SE->getString();
2465 StringRef Replacement;
2466 if (const auto *SE = dyn_cast_or_null<StringLiteral>(AL.getReplacementExpr()))
2467 Replacement = SE->getString();
2468
2469 if (II->isStr("swift")) {
2470 if (Introduced.isValid() || Obsoleted.isValid() ||
2471 (!IsUnavailable && !Deprecated.isValid())) {
2472 S.Diag(AL.getLoc(),
2473 diag::warn_availability_swift_unavailable_deprecated_only);
2474 return;
2475 }
2476 }
2477
2478 int PriorityModifier = AL.isPragmaClangAttribute()
2479 ? Sema::AP_PragmaClangAttribute
2480 : Sema::AP_Explicit;
2481 AvailabilityAttr *NewAttr = S.mergeAvailabilityAttr(
2482 ND, AL.getRange(), II, false /*Implicit*/, Introduced.Version,
2483 Deprecated.Version, Obsoleted.Version, IsUnavailable, Str, IsStrict,
2484 Replacement, Sema::AMK_None, PriorityModifier, Index);
2485 if (NewAttr)
2486 D->addAttr(NewAttr);
2487
2488 // Transcribe "ios" to "watchos" (and add a new attribute) if the versioning
2489 // matches before the start of the watchOS platform.
2490 if (S.Context.getTargetInfo().getTriple().isWatchOS()) {
2491 IdentifierInfo *NewII = nullptr;
2492 if (II->getName() == "ios")
2493 NewII = &S.Context.Idents.get("watchos");
2494 else if (II->getName() == "ios_app_extension")
2495 NewII = &S.Context.Idents.get("watchos_app_extension");
2496
2497 if (NewII) {
2498 auto adjustWatchOSVersion = [](VersionTuple Version) -> VersionTuple {
2499 if (Version.empty())
2500 return Version;
2501 auto Major = Version.getMajor();
2502 auto NewMajor = Major >= 9 ? Major - 7 : 0;
2503 if (NewMajor >= 2) {
2504 if (Version.getMinor().hasValue()) {
2505 if (Version.getSubminor().hasValue())
2506 return VersionTuple(NewMajor, Version.getMinor().getValue(),
2507 Version.getSubminor().getValue());
2508 else
2509 return VersionTuple(NewMajor, Version.getMinor().getValue());
2510 }
2511 return VersionTuple(NewMajor);
2512 }
2513
2514 return VersionTuple(2, 0);
2515 };
2516
2517 auto NewIntroduced = adjustWatchOSVersion(Introduced.Version);
2518 auto NewDeprecated = adjustWatchOSVersion(Deprecated.Version);
2519 auto NewObsoleted = adjustWatchOSVersion(Obsoleted.Version);
2520
2521 AvailabilityAttr *NewAttr = S.mergeAvailabilityAttr(
2522 ND, AL.getRange(), NewII, true /*Implicit*/, NewIntroduced,
2523 NewDeprecated, NewObsoleted, IsUnavailable, Str, IsStrict,
2524 Replacement, Sema::AMK_None,
2525 PriorityModifier + Sema::AP_InferredFromOtherPlatform, Index);
2526 if (NewAttr)
2527 D->addAttr(NewAttr);
2528 }
2529 } else if (S.Context.getTargetInfo().getTriple().isTvOS()) {
2530 // Transcribe "ios" to "tvos" (and add a new attribute) if the versioning
2531 // matches before the start of the tvOS platform.
2532 IdentifierInfo *NewII = nullptr;
2533 if (II->getName() == "ios")
2534 NewII = &S.Context.Idents.get("tvos");
2535 else if (II->getName() == "ios_app_extension")
2536 NewII = &S.Context.Idents.get("tvos_app_extension");
2537
2538 if (NewII) {
2539 AvailabilityAttr *NewAttr = S.mergeAvailabilityAttr(
2540 ND, AL.getRange(), NewII, true /*Implicit*/, Introduced.Version,
2541 Deprecated.Version, Obsoleted.Version, IsUnavailable, Str, IsStrict,
2542 Replacement, Sema::AMK_None,
2543 PriorityModifier + Sema::AP_InferredFromOtherPlatform, Index);
2544 if (NewAttr)
2545 D->addAttr(NewAttr);
2546 }
2547 }
2548}
2549
2550static void handleExternalSourceSymbolAttr(Sema &S, Decl *D,
2551 const ParsedAttr &AL) {
2552 if (!checkAttributeAtLeastNumArgs(S, AL, 1))
2553 return;
2554 assert(checkAttributeAtMostNumArgs(S, AL, 3) &&((checkAttributeAtMostNumArgs(S, AL, 3) && "Invalid number of arguments in an external_source_symbol attribute"
) ? static_cast<void> (0) : __assert_fail ("checkAttributeAtMostNumArgs(S, AL, 3) && \"Invalid number of arguments in an external_source_symbol attribute\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 2555, __PRETTY_FUNCTION__))
2555 "Invalid number of arguments in an external_source_symbol attribute")((checkAttributeAtMostNumArgs(S, AL, 3) && "Invalid number of arguments in an external_source_symbol attribute"
) ? static_cast<void> (0) : __assert_fail ("checkAttributeAtMostNumArgs(S, AL, 3) && \"Invalid number of arguments in an external_source_symbol attribute\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 2555, __PRETTY_FUNCTION__))
;
2556
2557 StringRef Language;
2558 if (const auto *SE = dyn_cast_or_null<StringLiteral>(AL.getArgAsExpr(0)))
2559 Language = SE->getString();
2560 StringRef DefinedIn;
2561 if (const auto *SE = dyn_cast_or_null<StringLiteral>(AL.getArgAsExpr(1)))
2562 DefinedIn = SE->getString();
2563 bool IsGeneratedDeclaration = AL.getArgAsIdent(2) != nullptr;
2564
2565 D->addAttr(::new (S.Context) ExternalSourceSymbolAttr(
2566 AL.getRange(), S.Context, Language, DefinedIn, IsGeneratedDeclaration,
2567 AL.getAttributeSpellingListIndex()));
2568}
2569
2570template <class T>
2571static T *mergeVisibilityAttr(Sema &S, Decl *D, SourceRange range,
2572 typename T::VisibilityType value,
2573 unsigned attrSpellingListIndex) {
2574 T *existingAttr = D->getAttr<T>();
2575 if (existingAttr) {
2576 typename T::VisibilityType existingValue = existingAttr->getVisibility();
2577 if (existingValue == value)
2578 return nullptr;
2579 S.Diag(existingAttr->getLocation(), diag::err_mismatched_visibility);
2580 S.Diag(range.getBegin(), diag::note_previous_attribute);
2581 D->dropAttr<T>();
2582 }
2583 return ::new (S.Context) T(range, S.Context, value, attrSpellingListIndex);
2584}
2585
2586VisibilityAttr *Sema::mergeVisibilityAttr(Decl *D, SourceRange Range,
2587 VisibilityAttr::VisibilityType Vis,
2588 unsigned AttrSpellingListIndex) {
2589 return ::mergeVisibilityAttr<VisibilityAttr>(*this, D, Range, Vis,
2590 AttrSpellingListIndex);
2591}
2592
2593TypeVisibilityAttr *Sema::mergeTypeVisibilityAttr(Decl *D, SourceRange Range,
2594 TypeVisibilityAttr::VisibilityType Vis,
2595 unsigned AttrSpellingListIndex) {
2596 return ::mergeVisibilityAttr<TypeVisibilityAttr>(*this, D, Range, Vis,
2597 AttrSpellingListIndex);
2598}
2599
2600static void handleVisibilityAttr(Sema &S, Decl *D, const ParsedAttr &AL,
2601 bool isTypeVisibility) {
2602 // Visibility attributes don't mean anything on a typedef.
2603 if (isa<TypedefNameDecl>(D)) {
2604 S.Diag(AL.getRange().getBegin(), diag::warn_attribute_ignored) << AL;
2605 return;
2606 }
2607
2608 // 'type_visibility' can only go on a type or namespace.
2609 if (isTypeVisibility &&
2610 !(isa<TagDecl>(D) ||
2611 isa<ObjCInterfaceDecl>(D) ||
2612 isa<NamespaceDecl>(D))) {
2613 S.Diag(AL.getRange().getBegin(), diag::err_attribute_wrong_decl_type)
2614 << AL << ExpectedTypeOrNamespace;
2615 return;
2616 }
2617
2618 // Check that the argument is a string literal.
2619 StringRef TypeStr;
2620 SourceLocation LiteralLoc;
2621 if (!S.checkStringLiteralArgumentAttr(AL, 0, TypeStr, &LiteralLoc))
2622 return;
2623
2624 VisibilityAttr::VisibilityType type;
2625 if (!VisibilityAttr::ConvertStrToVisibilityType(TypeStr, type)) {
2626 S.Diag(LiteralLoc, diag::warn_attribute_type_not_supported) << AL
2627 << TypeStr;
2628 return;
2629 }
2630
2631 // Complain about attempts to use protected visibility on targets
2632 // (like Darwin) that don't support it.
2633 if (type == VisibilityAttr::Protected &&
2634 !S.Context.getTargetInfo().hasProtectedVisibility()) {
2635 S.Diag(AL.getLoc(), diag::warn_attribute_protected_visibility);
2636 type = VisibilityAttr::Default;
2637 }
2638
2639 unsigned Index = AL.getAttributeSpellingListIndex();
2640 Attr *newAttr;
2641 if (isTypeVisibility) {
2642 newAttr = S.mergeTypeVisibilityAttr(D, AL.getRange(),
2643 (TypeVisibilityAttr::VisibilityType) type,
2644 Index);
2645 } else {
2646 newAttr = S.mergeVisibilityAttr(D, AL.getRange(), type, Index);
2647 }
2648 if (newAttr)
2649 D->addAttr(newAttr);
2650}
2651
2652static void handleObjCMethodFamilyAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2653 const auto *M = cast<ObjCMethodDecl>(D);
2654 if (!AL.isArgIdent(0)) {
2655 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
2656 << AL << 1 << AANT_ArgumentIdentifier;
2657 return;
2658 }
2659
2660 IdentifierLoc *IL = AL.getArgAsIdent(0);
2661 ObjCMethodFamilyAttr::FamilyKind F;
2662 if (!ObjCMethodFamilyAttr::ConvertStrToFamilyKind(IL->Ident->getName(), F)) {
2663 S.Diag(IL->Loc, diag::warn_attribute_type_not_supported) << AL << IL->Ident;
2664 return;
2665 }
2666
2667 if (F == ObjCMethodFamilyAttr::OMF_init &&
2668 !M->getReturnType()->isObjCObjectPointerType()) {
2669 S.Diag(M->getLocation(), diag::err_init_method_bad_return_type)
2670 << M->getReturnType();
2671 // Ignore the attribute.
2672 return;
2673 }
2674
2675 D->addAttr(new (S.Context) ObjCMethodFamilyAttr(
2676 AL.getRange(), S.Context, F, AL.getAttributeSpellingListIndex()));
2677}
2678
2679static void handleObjCNSObject(Sema &S, Decl *D, const ParsedAttr &AL) {
2680 if (const auto *TD = dyn_cast<TypedefNameDecl>(D)) {
2681 QualType T = TD->getUnderlyingType();
2682 if (!T->isCARCBridgableType()) {
2683 S.Diag(TD->getLocation(), diag::err_nsobject_attribute);
2684 return;
2685 }
2686 }
2687 else if (const auto *PD = dyn_cast<ObjCPropertyDecl>(D)) {
2688 QualType T = PD->getType();
2689 if (!T->isCARCBridgableType()) {
2690 S.Diag(PD->getLocation(), diag::err_nsobject_attribute);
2691 return;
2692 }
2693 }
2694 else {
2695 // It is okay to include this attribute on properties, e.g.:
2696 //
2697 // @property (retain, nonatomic) struct Bork *Q __attribute__((NSObject));
2698 //
2699 // In this case it follows tradition and suppresses an error in the above
2700 // case.
2701 S.Diag(D->getLocation(), diag::warn_nsobject_attribute);
2702 }
2703 D->addAttr(::new (S.Context)
2704 ObjCNSObjectAttr(AL.getRange(), S.Context,
2705 AL.getAttributeSpellingListIndex()));
2706}
2707
2708static void handleObjCIndependentClass(Sema &S, Decl *D, const ParsedAttr &AL) {
2709 if (const auto *TD = dyn_cast<TypedefNameDecl>(D)) {
2710 QualType T = TD->getUnderlyingType();
2711 if (!T->isObjCObjectPointerType()) {
2712 S.Diag(TD->getLocation(), diag::warn_ptr_independentclass_attribute);
2713 return;
2714 }
2715 } else {
2716 S.Diag(D->getLocation(), diag::warn_independentclass_attribute);
2717 return;
2718 }
2719 D->addAttr(::new (S.Context)
2720 ObjCIndependentClassAttr(AL.getRange(), S.Context,
2721 AL.getAttributeSpellingListIndex()));
2722}
2723
2724static void handleBlocksAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2725 if (!AL.isArgIdent(0)) {
2726 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
2727 << AL << 1 << AANT_ArgumentIdentifier;
2728 return;
2729 }
2730
2731 IdentifierInfo *II = AL.getArgAsIdent(0)->Ident;
2732 BlocksAttr::BlockType type;
2733 if (!BlocksAttr::ConvertStrToBlockType(II->getName(), type)) {
2734 S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported) << AL << II;
2735 return;
2736 }
2737
2738 D->addAttr(::new (S.Context)
2739 BlocksAttr(AL.getRange(), S.Context, type,
2740 AL.getAttributeSpellingListIndex()));
2741}
2742
2743static void handleSentinelAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2744 unsigned sentinel = (unsigned)SentinelAttr::DefaultSentinel;
2745 if (AL.getNumArgs() > 0) {
2746 Expr *E = AL.getArgAsExpr(0);
2747 llvm::APSInt Idx(32);
2748 if (E->isTypeDependent() || E->isValueDependent() ||
2749 !E->isIntegerConstantExpr(Idx, S.Context)) {
2750 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
2751 << AL << 1 << AANT_ArgumentIntegerConstant << E->getSourceRange();
2752 return;
2753 }
2754
2755 if (Idx.isSigned() && Idx.isNegative()) {
2756 S.Diag(AL.getLoc(), diag::err_attribute_sentinel_less_than_zero)
2757 << E->getSourceRange();
2758 return;
2759 }
2760
2761 sentinel = Idx.getZExtValue();
2762 }
2763
2764 unsigned nullPos = (unsigned)SentinelAttr::DefaultNullPos;
2765 if (AL.getNumArgs() > 1) {
2766 Expr *E = AL.getArgAsExpr(1);
2767 llvm::APSInt Idx(32);
2768 if (E->isTypeDependent() || E->isValueDependent() ||
2769 !E->isIntegerConstantExpr(Idx, S.Context)) {
2770 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
2771 << AL << 2 << AANT_ArgumentIntegerConstant << E->getSourceRange();
2772 return;
2773 }
2774 nullPos = Idx.getZExtValue();
2775
2776 if ((Idx.isSigned() && Idx.isNegative()) || nullPos > 1) {
2777 // FIXME: This error message could be improved, it would be nice
2778 // to say what the bounds actually are.
2779 S.Diag(AL.getLoc(), diag::err_attribute_sentinel_not_zero_or_one)
2780 << E->getSourceRange();
2781 return;
2782 }
2783 }
2784
2785 if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
2786 const FunctionType *FT = FD->getType()->castAs<FunctionType>();
2787 if (isa<FunctionNoProtoType>(FT)) {
2788 S.Diag(AL.getLoc(), diag::warn_attribute_sentinel_named_arguments);
2789 return;
2790 }
2791
2792 if (!cast<FunctionProtoType>(FT)->isVariadic()) {
2793 S.Diag(AL.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0;
2794 return;
2795 }
2796 } else if (const auto *MD = dyn_cast<ObjCMethodDecl>(D)) {
2797 if (!MD->isVariadic()) {
2798 S.Diag(AL.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0;
2799 return;
2800 }
2801 } else if (const auto *BD = dyn_cast<BlockDecl>(D)) {
2802 if (!BD->isVariadic()) {
2803 S.Diag(AL.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 1;
2804 return;
2805 }
2806 } else if (const auto *V = dyn_cast<VarDecl>(D)) {
2807 QualType Ty = V->getType();
2808 if (Ty->isBlockPointerType() || Ty->isFunctionPointerType()) {
2809 const FunctionType *FT = Ty->isFunctionPointerType()
2810 ? D->getFunctionType()
2811 : Ty->getAs<BlockPointerType>()->getPointeeType()->getAs<FunctionType>();
2812 if (!cast<FunctionProtoType>(FT)->isVariadic()) {
2813 int m = Ty->isFunctionPointerType() ? 0 : 1;
2814 S.Diag(AL.getLoc(), diag::warn_attribute_sentinel_not_variadic) << m;
2815 return;
2816 }
2817 } else {
2818 S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type)
2819 << AL << ExpectedFunctionMethodOrBlock;
2820 return;
2821 }
2822 } else {
2823 S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type)
2824 << AL << ExpectedFunctionMethodOrBlock;
2825 return;
2826 }
2827 D->addAttr(::new (S.Context)
2828 SentinelAttr(AL.getRange(), S.Context, sentinel, nullPos,
2829 AL.getAttributeSpellingListIndex()));
2830}
2831
2832static void handleWarnUnusedResult(Sema &S, Decl *D, const ParsedAttr &AL) {
2833 if (D->getFunctionType() &&
2834 D->getFunctionType()->getReturnType()->isVoidType()) {
2835 S.Diag(AL.getLoc(), diag::warn_attribute_void_function_method) << AL << 0;
2836 return;
2837 }
2838 if (const auto *MD = dyn_cast<ObjCMethodDecl>(D))
2839 if (MD->getReturnType()->isVoidType()) {
2840 S.Diag(AL.getLoc(), diag::warn_attribute_void_function_method) << AL << 1;
2841 return;
2842 }
2843
2844 // If this is spelled as the standard C++17 attribute, but not in C++17, warn
2845 // about using it as an extension.
2846 if (!S.getLangOpts().CPlusPlus17 && AL.isCXX11Attribute() &&
2847 !AL.getScopeName())
2848 S.Diag(AL.getLoc(), diag::ext_cxx17_attr) << AL;
2849
2850 D->addAttr(::new (S.Context)
2851 WarnUnusedResultAttr(AL.getRange(), S.Context,
2852 AL.getAttributeSpellingListIndex()));
2853}
2854
2855static void handleWeakImportAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2856 // weak_import only applies to variable & function declarations.
2857 bool isDef = false;
2858 if (!D->canBeWeakImported(isDef)) {
2859 if (isDef)
2860 S.Diag(AL.getLoc(), diag::warn_attribute_invalid_on_definition)
2861 << "weak_import";
2862 else if (isa<ObjCPropertyDecl>(D) || isa<ObjCMethodDecl>(D) ||
2863 (S.Context.getTargetInfo().getTriple().isOSDarwin() &&
2864 (isa<ObjCInterfaceDecl>(D) || isa<EnumDecl>(D)))) {
2865 // Nothing to warn about here.
2866 } else
2867 S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type)
2868 << AL << ExpectedVariableOrFunction;
2869
2870 return;
2871 }
2872
2873 D->addAttr(::new (S.Context)
2874 WeakImportAttr(AL.getRange(), S.Context,
2875 AL.getAttributeSpellingListIndex()));
2876}
2877
2878// Handles reqd_work_group_size and work_group_size_hint.
2879template <typename WorkGroupAttr>
2880static void handleWorkGroupSize(Sema &S, Decl *D, const ParsedAttr &AL) {
2881 uint32_t WGSize[3];
2882 for (unsigned i = 0; i < 3; ++i) {
2883 const Expr *E = AL.getArgAsExpr(i);
2884 if (!checkUInt32Argument(S, AL, E, WGSize[i], i,
2885 /*StrictlyUnsigned=*/true))
2886 return;
2887 if (WGSize[i] == 0) {
2888 S.Diag(AL.getLoc(), diag::err_attribute_argument_is_zero)
2889 << AL << E->getSourceRange();
2890 return;
2891 }
2892 }
2893
2894 WorkGroupAttr *Existing = D->getAttr<WorkGroupAttr>();
2895 if (Existing && !(Existing->getXDim() == WGSize[0] &&
2896 Existing->getYDim() == WGSize[1] &&
2897 Existing->getZDim() == WGSize[2]))
2898 S.Diag(AL.getLoc(), diag::warn_duplicate_attribute) << AL;
2899
2900 D->addAttr(::new (S.Context) WorkGroupAttr(AL.getRange(), S.Context,
2901 WGSize[0], WGSize[1], WGSize[2],
2902 AL.getAttributeSpellingListIndex()));
2903}
2904
2905// Handles intel_reqd_sub_group_size.
2906static void handleSubGroupSize(Sema &S, Decl *D, const ParsedAttr &AL) {
2907 uint32_t SGSize;
2908 const Expr *E = AL.getArgAsExpr(0);
2909 if (!checkUInt32Argument(S, AL, E, SGSize))
2910 return;
2911 if (SGSize == 0) {
2912 S.Diag(AL.getLoc(), diag::err_attribute_argument_is_zero)
2913 << AL << E->getSourceRange();
2914 return;
2915 }
2916
2917 OpenCLIntelReqdSubGroupSizeAttr *Existing =
2918 D->getAttr<OpenCLIntelReqdSubGroupSizeAttr>();
2919 if (Existing && Existing->getSubGroupSize() != SGSize)
2920 S.Diag(AL.getLoc(), diag::warn_duplicate_attribute) << AL;
2921
2922 D->addAttr(::new (S.Context) OpenCLIntelReqdSubGroupSizeAttr(
2923 AL.getRange(), S.Context, SGSize,
2924 AL.getAttributeSpellingListIndex()));
2925}
2926
2927static void handleVecTypeHint(Sema &S, Decl *D, const ParsedAttr &AL) {
2928 if (!AL.hasParsedType()) {
2929 S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) << AL << 1;
2930 return;
2931 }
2932
2933 TypeSourceInfo *ParmTSI = nullptr;
2934 QualType ParmType = S.GetTypeFromParser(AL.getTypeArg(), &ParmTSI);
2935 assert(ParmTSI && "no type source info for attribute argument")((ParmTSI && "no type source info for attribute argument"
) ? static_cast<void> (0) : __assert_fail ("ParmTSI && \"no type source info for attribute argument\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 2935, __PRETTY_FUNCTION__))
;
2936
2937 if (!ParmType->isExtVectorType() && !ParmType->isFloatingType() &&
2938 (ParmType->isBooleanType() ||
2939 !ParmType->isIntegralType(S.getASTContext()))) {
2940 S.Diag(AL.getLoc(), diag::err_attribute_argument_vec_type_hint)
2941 << ParmType;
2942 return;
2943 }
2944
2945 if (VecTypeHintAttr *A = D->getAttr<VecTypeHintAttr>()) {
2946 if (!S.Context.hasSameType(A->getTypeHint(), ParmType)) {
2947 S.Diag(AL.getLoc(), diag::warn_duplicate_attribute) << AL;
2948 return;
2949 }
2950 }
2951
2952 D->addAttr(::new (S.Context) VecTypeHintAttr(AL.getLoc(), S.Context,
2953 ParmTSI,
2954 AL.getAttributeSpellingListIndex()));
2955}
2956
2957SectionAttr *Sema::mergeSectionAttr(Decl *D, SourceRange Range,
2958 StringRef Name,
2959 unsigned AttrSpellingListIndex) {
2960 // Explicit or partial specializations do not inherit
2961 // the section attribute from the primary template.
2962 if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
2963 if (AttrSpellingListIndex == SectionAttr::Declspec_allocate &&
2964 FD->isFunctionTemplateSpecialization())
2965 return nullptr;
2966 }
2967 if (SectionAttr *ExistingAttr = D->getAttr<SectionAttr>()) {
2968 if (ExistingAttr->getName() == Name)
2969 return nullptr;
2970 Diag(ExistingAttr->getLocation(), diag::warn_mismatched_section)
2971 << 1 /*section*/;
2972 Diag(Range.getBegin(), diag::note_previous_attribute);
2973 return nullptr;
2974 }
2975 return ::new (Context) SectionAttr(Range, Context, Name,
2976 AttrSpellingListIndex);
2977}
2978
2979bool Sema::checkSectionName(SourceLocation LiteralLoc, StringRef SecName) {
2980 std::string Error = Context.getTargetInfo().isValidSectionSpecifier(SecName);
2981 if (!Error.empty()) {
2982 Diag(LiteralLoc, diag::err_attribute_section_invalid_for_target) << Error
2983 << 1 /*'section'*/;
2984 return false;
2985 }
2986 return true;
2987}
2988
2989static void handleSectionAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
2990 // Make sure that there is a string literal as the sections's single
2991 // argument.
2992 StringRef Str;
2993 SourceLocation LiteralLoc;
2994 if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &LiteralLoc))
2995 return;
2996
2997 if (!S.checkSectionName(LiteralLoc, Str))
2998 return;
2999
3000 // If the target wants to validate the section specifier, make it happen.
3001 std::string Error = S.Context.getTargetInfo().isValidSectionSpecifier(Str);
3002 if (!Error.empty()) {
3003 S.Diag(LiteralLoc, diag::err_attribute_section_invalid_for_target)
3004 << Error;
3005 return;
3006 }
3007
3008 unsigned Index = AL.getAttributeSpellingListIndex();
3009 SectionAttr *NewAttr = S.mergeSectionAttr(D, AL.getRange(), Str, Index);
3010 if (NewAttr)
3011 D->addAttr(NewAttr);
3012}
3013
3014static bool checkCodeSegName(Sema&S, SourceLocation LiteralLoc, StringRef CodeSegName) {
3015 std::string Error = S.Context.getTargetInfo().isValidSectionSpecifier(CodeSegName);
3016 if (!Error.empty()) {
3017 S.Diag(LiteralLoc, diag::err_attribute_section_invalid_for_target) << Error
3018 << 0 /*'code-seg'*/;
3019 return false;
3020 }
3021 return true;
3022}
3023
3024CodeSegAttr *Sema::mergeCodeSegAttr(Decl *D, SourceRange Range,
3025 StringRef Name,
3026 unsigned AttrSpellingListIndex) {
3027 // Explicit or partial specializations do not inherit
3028 // the code_seg attribute from the primary template.
3029 if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
3030 if (FD->isFunctionTemplateSpecialization())
3031 return nullptr;
3032 }
3033 if (const auto *ExistingAttr = D->getAttr<CodeSegAttr>()) {
3034 if (ExistingAttr->getName() == Name)
3035 return nullptr;
3036 Diag(ExistingAttr->getLocation(), diag::warn_mismatched_section)
3037 << 0 /*codeseg*/;
3038 Diag(Range.getBegin(), diag::note_previous_attribute);
3039 return nullptr;
3040 }
3041 return ::new (Context) CodeSegAttr(Range, Context, Name,
3042 AttrSpellingListIndex);
3043}
3044
3045static void handleCodeSegAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3046 StringRef Str;
3047 SourceLocation LiteralLoc;
3048 if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &LiteralLoc))
3049 return;
3050 if (!checkCodeSegName(S, LiteralLoc, Str))
3051 return;
3052 if (const auto *ExistingAttr = D->getAttr<CodeSegAttr>()) {
3053 if (!ExistingAttr->isImplicit()) {
3054 S.Diag(AL.getLoc(),
3055 ExistingAttr->getName() == Str
3056 ? diag::warn_duplicate_codeseg_attribute
3057 : diag::err_conflicting_codeseg_attribute);
3058 return;
3059 }
3060 D->dropAttr<CodeSegAttr>();
3061 }
3062 if (CodeSegAttr *CSA = S.mergeCodeSegAttr(D, AL.getRange(), Str,
3063 AL.getAttributeSpellingListIndex()))
3064 D->addAttr(CSA);
3065}
3066
3067// Check for things we'd like to warn about. Multiversioning issues are
3068// handled later in the process, once we know how many exist.
3069bool Sema::checkTargetAttr(SourceLocation LiteralLoc, StringRef AttrStr) {
3070 enum FirstParam { Unsupported, Duplicate };
3071 enum SecondParam { None, Architecture };
3072 for (auto Str : {"tune=", "fpmath="})
3073 if (AttrStr.find(Str) != StringRef::npos)
3074 return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
3075 << Unsupported << None << Str;
3076
3077 TargetAttr::ParsedTargetAttr ParsedAttrs = TargetAttr::parse(AttrStr);
3078
3079 if (!ParsedAttrs.Architecture.empty() &&
3080 !Context.getTargetInfo().isValidCPUName(ParsedAttrs.Architecture))
3081 return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
3082 << Unsupported << Architecture << ParsedAttrs.Architecture;
3083
3084 if (ParsedAttrs.DuplicateArchitecture)
3085 return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
3086 << Duplicate << None << "arch=";
3087
3088 for (const auto &Feature : ParsedAttrs.Features) {
3089 auto CurFeature = StringRef(Feature).drop_front(); // remove + or -.
3090 if (!Context.getTargetInfo().isValidFeatureName(CurFeature))
3091 return Diag(LiteralLoc, diag::warn_unsupported_target_attribute)
3092 << Unsupported << None << CurFeature;
3093 }
3094
3095 return false;
3096}
3097
3098static void handleTargetAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3099 StringRef Str;
3100 SourceLocation LiteralLoc;
3101 if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &LiteralLoc) ||
3102 S.checkTargetAttr(LiteralLoc, Str))
3103 return;
3104
3105 unsigned Index = AL.getAttributeSpellingListIndex();
3106 TargetAttr *NewAttr =
3107 ::new (S.Context) TargetAttr(AL.getRange(), S.Context, Str, Index);
3108 D->addAttr(NewAttr);
3109}
3110
3111static void handleMinVectorWidthAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3112 Expr *E = AL.getArgAsExpr(0);
3113 uint32_t VecWidth;
3114 if (!checkUInt32Argument(S, AL, E, VecWidth)) {
3115 AL.setInvalid();
3116 return;
3117 }
3118
3119 MinVectorWidthAttr *Existing = D->getAttr<MinVectorWidthAttr>();
3120 if (Existing && Existing->getVectorWidth() != VecWidth) {
3121 S.Diag(AL.getLoc(), diag::warn_duplicate_attribute) << AL;
3122 return;
3123 }
3124
3125 D->addAttr(::new (S.Context)
3126 MinVectorWidthAttr(AL.getRange(), S.Context, VecWidth,
3127 AL.getAttributeSpellingListIndex()));
3128}
3129
3130static void handleCleanupAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3131 Expr *E = AL.getArgAsExpr(0);
3132 SourceLocation Loc = E->getExprLoc();
3133 FunctionDecl *FD = nullptr;
3134 DeclarationNameInfo NI;
3135
3136 // gcc only allows for simple identifiers. Since we support more than gcc, we
3137 // will warn the user.
3138 if (auto *DRE = dyn_cast<DeclRefExpr>(E)) {
3139 if (DRE->hasQualifier())
3140 S.Diag(Loc, diag::warn_cleanup_ext);
3141 FD = dyn_cast<FunctionDecl>(DRE->getDecl());
3142 NI = DRE->getNameInfo();
3143 if (!FD) {
3144 S.Diag(Loc, diag::err_attribute_cleanup_arg_not_function) << 1
3145 << NI.getName();
3146 return;
3147 }
3148 } else if (auto *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
3149 if (ULE->hasExplicitTemplateArgs())
3150 S.Diag(Loc, diag::warn_cleanup_ext);
3151 FD = S.ResolveSingleFunctionTemplateSpecialization(ULE, true);
3152 NI = ULE->getNameInfo();
3153 if (!FD) {
3154 S.Diag(Loc, diag::err_attribute_cleanup_arg_not_function) << 2
3155 << NI.getName();
3156 if (ULE->getType() == S.Context.OverloadTy)
3157 S.NoteAllOverloadCandidates(ULE);
3158 return;
3159 }
3160 } else {
3161 S.Diag(Loc, diag::err_attribute_cleanup_arg_not_function) << 0;
3162 return;
3163 }
3164
3165 if (FD->getNumParams() != 1) {
3166 S.Diag(Loc, diag::err_attribute_cleanup_func_must_take_one_arg)
3167 << NI.getName();
3168 return;
3169 }
3170
3171 // We're currently more strict than GCC about what function types we accept.
3172 // If this ever proves to be a problem it should be easy to fix.
3173 QualType Ty = S.Context.getPointerType(cast<VarDecl>(D)->getType());
3174 QualType ParamTy = FD->getParamDecl(0)->getType();
3175 if (S.CheckAssignmentConstraints(FD->getParamDecl(0)->getLocation(),
3176 ParamTy, Ty) != Sema::Compatible) {
3177 S.Diag(Loc, diag::err_attribute_cleanup_func_arg_incompatible_type)
3178 << NI.getName() << ParamTy << Ty;
3179 return;
3180 }
3181
3182 D->addAttr(::new (S.Context)
3183 CleanupAttr(AL.getRange(), S.Context, FD,
3184 AL.getAttributeSpellingListIndex()));
3185}
3186
3187static void handleEnumExtensibilityAttr(Sema &S, Decl *D,
3188 const ParsedAttr &AL) {
3189 if (!AL.isArgIdent(0)) {
3190 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
3191 << AL << 0 << AANT_ArgumentIdentifier;
3192 return;
3193 }
3194
3195 EnumExtensibilityAttr::Kind ExtensibilityKind;
3196 IdentifierInfo *II = AL.getArgAsIdent(0)->Ident;
3197 if (!EnumExtensibilityAttr::ConvertStrToKind(II->getName(),
3198 ExtensibilityKind)) {
3199 S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported) << AL << II;
3200 return;
3201 }
3202
3203 D->addAttr(::new (S.Context) EnumExtensibilityAttr(
3204 AL.getRange(), S.Context, ExtensibilityKind,
3205 AL.getAttributeSpellingListIndex()));
3206}
3207
3208/// Handle __attribute__((format_arg((idx)))) attribute based on
3209/// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
3210static void handleFormatArgAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3211 Expr *IdxExpr = AL.getArgAsExpr(0);
3212 ParamIdx Idx;
3213 if (!checkFunctionOrMethodParameterIndex(S, D, AL, 1, IdxExpr, Idx))
3214 return;
3215
3216 // Make sure the format string is really a string.
3217 QualType Ty = getFunctionOrMethodParamType(D, Idx.getASTIndex());
3218
3219 bool NotNSStringTy = !isNSStringType(Ty, S.Context);
3220 if (NotNSStringTy &&
3221 !isCFStringType(Ty, S.Context) &&
3222 (!Ty->isPointerType() ||
3223 !Ty->getAs<PointerType>()->getPointeeType()->isCharType())) {
3224 S.Diag(AL.getLoc(), diag::err_format_attribute_not)
3225 << "a string type" << IdxExpr->getSourceRange()
3226 << getFunctionOrMethodParamRange(D, 0);
3227 return;
3228 }
3229 Ty = getFunctionOrMethodResultType(D);
3230 if (!isNSStringType(Ty, S.Context) &&
3231 !isCFStringType(Ty, S.Context) &&
3232 (!Ty->isPointerType() ||
3233 !Ty->getAs<PointerType>()->getPointeeType()->isCharType())) {
3234 S.Diag(AL.getLoc(), diag::err_format_attribute_result_not)
3235 << (NotNSStringTy ? "string type" : "NSString")
3236 << IdxExpr->getSourceRange() << getFunctionOrMethodParamRange(D, 0);
3237 return;
3238 }
3239
3240 D->addAttr(::new (S.Context) FormatArgAttr(
3241 AL.getRange(), S.Context, Idx, AL.getAttributeSpellingListIndex()));
3242}
3243
3244enum FormatAttrKind {
3245 CFStringFormat,
3246 NSStringFormat,
3247 StrftimeFormat,
3248 SupportedFormat,
3249 IgnoredFormat,
3250 InvalidFormat
3251};
3252
3253/// getFormatAttrKind - Map from format attribute names to supported format
3254/// types.
3255static FormatAttrKind getFormatAttrKind(StringRef Format) {
3256 return llvm::StringSwitch<FormatAttrKind>(Format)
3257 // Check for formats that get handled specially.
3258 .Case("NSString", NSStringFormat)
3259 .Case("CFString", CFStringFormat)
3260 .Case("strftime", StrftimeFormat)
3261
3262 // Otherwise, check for supported formats.
3263 .Cases("scanf", "printf", "printf0", "strfmon", SupportedFormat)
3264 .Cases("cmn_err", "vcmn_err", "zcmn_err", SupportedFormat)
3265 .Case("kprintf", SupportedFormat) // OpenBSD.
3266 .Case("freebsd_kprintf", SupportedFormat) // FreeBSD.
3267 .Case("os_trace", SupportedFormat)
3268 .Case("os_log", SupportedFormat)
3269
3270 .Cases("gcc_diag", "gcc_cdiag", "gcc_cxxdiag", "gcc_tdiag", IgnoredFormat)
3271 .Default(InvalidFormat);
3272}
3273
3274/// Handle __attribute__((init_priority(priority))) attributes based on
3275/// http://gcc.gnu.org/onlinedocs/gcc/C_002b_002b-Attributes.html
3276static void handleInitPriorityAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3277 if (!S.getLangOpts().CPlusPlus) {
3278 S.Diag(AL.getLoc(), diag::warn_attribute_ignored) << AL;
3279 return;
3280 }
3281
3282 if (S.getCurFunctionOrMethodDecl()) {
3283 S.Diag(AL.getLoc(), diag::err_init_priority_object_attr);
3284 AL.setInvalid();
3285 return;
3286 }
3287 QualType T = cast<VarDecl>(D)->getType();
3288 if (S.Context.getAsArrayType(T))
3289 T = S.Context.getBaseElementType(T);
3290 if (!T->getAs<RecordType>()) {
3291 S.Diag(AL.getLoc(), diag::err_init_priority_object_attr);
3292 AL.setInvalid();
3293 return;
3294 }
3295
3296 Expr *E = AL.getArgAsExpr(0);
3297 uint32_t prioritynum;
3298 if (!checkUInt32Argument(S, AL, E, prioritynum)) {
3299 AL.setInvalid();
3300 return;
3301 }
3302
3303 if (prioritynum < 101 || prioritynum > 65535) {
3304 S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_range)
3305 << E->getSourceRange() << AL << 101 << 65535;
3306 AL.setInvalid();
3307 return;
3308 }
3309 D->addAttr(::new (S.Context)
3310 InitPriorityAttr(AL.getRange(), S.Context, prioritynum,
3311 AL.getAttributeSpellingListIndex()));
3312}
3313
3314FormatAttr *Sema::mergeFormatAttr(Decl *D, SourceRange Range,
3315 IdentifierInfo *Format, int FormatIdx,
3316 int FirstArg,
3317 unsigned AttrSpellingListIndex) {
3318 // Check whether we already have an equivalent format attribute.
3319 for (auto *F : D->specific_attrs<FormatAttr>()) {
3320 if (F->getType() == Format &&
3321 F->getFormatIdx() == FormatIdx &&
3322 F->getFirstArg() == FirstArg) {
3323 // If we don't have a valid location for this attribute, adopt the
3324 // location.
3325 if (F->getLocation().isInvalid())
3326 F->setRange(Range);
3327 return nullptr;
3328 }
3329 }
3330
3331 return ::new (Context) FormatAttr(Range, Context, Format, FormatIdx,
3332 FirstArg, AttrSpellingListIndex);
3333}
3334
3335/// Handle __attribute__((format(type,idx,firstarg))) attributes based on
3336/// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
3337static void handleFormatAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3338 if (!AL.isArgIdent(0)) {
3339 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
3340 << AL << 1 << AANT_ArgumentIdentifier;
3341 return;
3342 }
3343
3344 // In C++ the implicit 'this' function parameter also counts, and they are
3345 // counted from one.
3346 bool HasImplicitThisParam = isInstanceMethod(D);
3347 unsigned NumArgs = getFunctionOrMethodNumParams(D) + HasImplicitThisParam;
3348
3349 IdentifierInfo *II = AL.getArgAsIdent(0)->Ident;
3350 StringRef Format = II->getName();
3351
3352 if (normalizeName(Format)) {
3353 // If we've modified the string name, we need a new identifier for it.
3354 II = &S.Context.Idents.get(Format);
3355 }
3356
3357 // Check for supported formats.
3358 FormatAttrKind Kind = getFormatAttrKind(Format);
3359
3360 if (Kind == IgnoredFormat)
3361 return;
3362
3363 if (Kind == InvalidFormat) {
3364 S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported)
3365 << AL << II->getName();
3366 return;
3367 }
3368
3369 // checks for the 2nd argument
3370 Expr *IdxExpr = AL.getArgAsExpr(1);
3371 uint32_t Idx;
3372 if (!checkUInt32Argument(S, AL, IdxExpr, Idx, 2))
3373 return;
3374
3375 if (Idx < 1 || Idx > NumArgs) {
3376 S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_bounds)
3377 << AL << 2 << IdxExpr->getSourceRange();
3378 return;
3379 }
3380
3381 // FIXME: Do we need to bounds check?
3382 unsigned ArgIdx = Idx - 1;
3383
3384 if (HasImplicitThisParam) {
3385 if (ArgIdx == 0) {
3386 S.Diag(AL.getLoc(),
3387 diag::err_format_attribute_implicit_this_format_string)
3388 << IdxExpr->getSourceRange();
3389 return;
3390 }
3391 ArgIdx--;
3392 }
3393
3394 // make sure the format string is really a string
3395 QualType Ty = getFunctionOrMethodParamType(D, ArgIdx);
3396
3397 if (Kind == CFStringFormat) {
3398 if (!isCFStringType(Ty, S.Context)) {
3399 S.Diag(AL.getLoc(), diag::err_format_attribute_not)
3400 << "a CFString" << IdxExpr->getSourceRange()
3401 << getFunctionOrMethodParamRange(D, ArgIdx);
3402 return;
3403 }
3404 } else if (Kind == NSStringFormat) {
3405 // FIXME: do we need to check if the type is NSString*? What are the
3406 // semantics?
3407 if (!isNSStringType(Ty, S.Context)) {
3408 S.Diag(AL.getLoc(), diag::err_format_attribute_not)
3409 << "an NSString" << IdxExpr->getSourceRange()
3410 << getFunctionOrMethodParamRange(D, ArgIdx);
3411 return;
3412 }
3413 } else if (!Ty->isPointerType() ||
3414 !Ty->getAs<PointerType>()->getPointeeType()->isCharType()) {
3415 S.Diag(AL.getLoc(), diag::err_format_attribute_not)
3416 << "a string type" << IdxExpr->getSourceRange()
3417 << getFunctionOrMethodParamRange(D, ArgIdx);
3418 return;
3419 }
3420
3421 // check the 3rd argument
3422 Expr *FirstArgExpr = AL.getArgAsExpr(2);
3423 uint32_t FirstArg;
3424 if (!checkUInt32Argument(S, AL, FirstArgExpr, FirstArg, 3))
3425 return;
3426
3427 // check if the function is variadic if the 3rd argument non-zero
3428 if (FirstArg != 0) {
3429 if (isFunctionOrMethodVariadic(D)) {
3430 ++NumArgs; // +1 for ...
3431 } else {
3432 S.Diag(D->getLocation(), diag::err_format_attribute_requires_variadic);
3433 return;
3434 }
3435 }
3436
3437 // strftime requires FirstArg to be 0 because it doesn't read from any
3438 // variable the input is just the current time + the format string.
3439 if (Kind == StrftimeFormat) {
3440 if (FirstArg != 0) {
3441 S.Diag(AL.getLoc(), diag::err_format_strftime_third_parameter)
3442 << FirstArgExpr->getSourceRange();
3443 return;
3444 }
3445 // if 0 it disables parameter checking (to use with e.g. va_list)
3446 } else if (FirstArg != 0 && FirstArg != NumArgs) {
3447 S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_bounds)
3448 << AL << 3 << FirstArgExpr->getSourceRange();
3449 return;
3450 }
3451
3452 FormatAttr *NewAttr = S.mergeFormatAttr(D, AL.getRange(), II,
3453 Idx, FirstArg,
3454 AL.getAttributeSpellingListIndex());
3455 if (NewAttr)
3456 D->addAttr(NewAttr);
3457}
3458
3459/// Handle __attribute__((callback(CalleeIdx, PayloadIdx0, ...))) attributes.
3460static void handleCallbackAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3461 // The index that identifies the callback callee is mandatory.
3462 if (AL.getNumArgs() == 0) {
3463 S.Diag(AL.getLoc(), diag::err_callback_attribute_no_callee)
3464 << AL.getRange();
3465 return;
3466 }
3467
3468 bool HasImplicitThisParam = isInstanceMethod(D);
3469 int32_t NumArgs = getFunctionOrMethodNumParams(D);
3470
3471 FunctionDecl *FD = D->getAsFunction();
3472 assert(FD && "Expected a function declaration!")((FD && "Expected a function declaration!") ? static_cast
<void> (0) : __assert_fail ("FD && \"Expected a function declaration!\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 3472, __PRETTY_FUNCTION__))
;
3473
3474 llvm::StringMap<int> NameIdxMapping;
3475 NameIdxMapping["__"] = -1;
3476
3477 NameIdxMapping["this"] = 0;
3478
3479 int Idx = 1;
3480 for (const ParmVarDecl *PVD : FD->parameters())
3481 NameIdxMapping[PVD->getName()] = Idx++;
3482
3483 auto UnknownName = NameIdxMapping.end();
3484
3485 SmallVector<int, 8> EncodingIndices;
3486 for (unsigned I = 0, E = AL.getNumArgs(); I < E; ++I) {
3487 SourceRange SR;
3488 int32_t ArgIdx;
3489
3490 if (AL.isArgIdent(I)) {
3491 IdentifierLoc *IdLoc = AL.getArgAsIdent(I);
3492 auto It = NameIdxMapping.find(IdLoc->Ident->getName());
3493 if (It == UnknownName) {
3494 S.Diag(AL.getLoc(), diag::err_callback_attribute_argument_unknown)
3495 << IdLoc->Ident << IdLoc->Loc;
3496 return;
3497 }
3498
3499 SR = SourceRange(IdLoc->Loc);
3500 ArgIdx = It->second;
3501 } else if (AL.isArgExpr(I)) {
3502 Expr *IdxExpr = AL.getArgAsExpr(I);
3503
3504 // If the expression is not parseable as an int32_t we have a problem.
3505 if (!checkUInt32Argument(S, AL, IdxExpr, (uint32_t &)ArgIdx, I + 1,
3506 false)) {
3507 S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_bounds)
3508 << AL << (I + 1) << IdxExpr->getSourceRange();
3509 return;
3510 }
3511
3512 // Check oob, excluding the special values, 0 and -1.
3513 if (ArgIdx < -1 || ArgIdx > NumArgs) {
3514 S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_bounds)
3515 << AL << (I + 1) << IdxExpr->getSourceRange();
3516 return;
3517 }
3518
3519 SR = IdxExpr->getSourceRange();
3520 } else {
3521 llvm_unreachable("Unexpected ParsedAttr argument type!")::llvm::llvm_unreachable_internal("Unexpected ParsedAttr argument type!"
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 3521)
;
3522 }
3523
3524 if (ArgIdx == 0 && !HasImplicitThisParam) {
3525 S.Diag(AL.getLoc(), diag::err_callback_implicit_this_not_available)
3526 << (I + 1) << SR;
3527 return;
3528 }
3529
3530 // Adjust for the case we do not have an implicit "this" parameter. In this
3531 // case we decrease all positive values by 1 to get LLVM argument indices.
3532 if (!HasImplicitThisParam && ArgIdx > 0)
3533 ArgIdx -= 1;
3534
3535 EncodingIndices.push_back(ArgIdx);
3536 }
3537
3538 int CalleeIdx = EncodingIndices.front();
3539 // Check if the callee index is proper, thus not "this" and not "unknown".
3540 // This means the "CalleeIdx" has to be non-negative if "HasImplicitThisParam"
3541 // is false and positive if "HasImplicitThisParam" is true.
3542 if (CalleeIdx < (int)HasImplicitThisParam) {
3543 S.Diag(AL.getLoc(), diag::err_callback_attribute_invalid_callee)
3544 << AL.getRange();
3545 return;
3546 }
3547
3548 // Get the callee type, note the index adjustment as the AST doesn't contain
3549 // the this type (which the callee cannot reference anyway!).
3550 const Type *CalleeType =
3551 getFunctionOrMethodParamType(D, CalleeIdx - HasImplicitThisParam)
3552 .getTypePtr();
3553 if (!CalleeType || !CalleeType->isFunctionPointerType()) {
3554 S.Diag(AL.getLoc(), diag::err_callback_callee_no_function_type)
3555 << AL.getRange();
3556 return;
3557 }
3558
3559 const Type *CalleeFnType =
3560 CalleeType->getPointeeType()->getUnqualifiedDesugaredType();
3561
3562 // TODO: Check the type of the callee arguments.
3563
3564 const auto *CalleeFnProtoType = dyn_cast<FunctionProtoType>(CalleeFnType);
3565 if (!CalleeFnProtoType) {
3566 S.Diag(AL.getLoc(), diag::err_callback_callee_no_function_type)
3567 << AL.getRange();
3568 return;
3569 }
3570
3571 if (CalleeFnProtoType->getNumParams() > EncodingIndices.size() - 1) {
3572 S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments)
3573 << AL << (unsigned)(EncodingIndices.size() - 1);
3574 return;
3575 }
3576
3577 if (CalleeFnProtoType->getNumParams() < EncodingIndices.size() - 1) {
3578 S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments)
3579 << AL << (unsigned)(EncodingIndices.size() - 1);
3580 return;
3581 }
3582
3583 if (CalleeFnProtoType->isVariadic()) {
3584 S.Diag(AL.getLoc(), diag::err_callback_callee_is_variadic) << AL.getRange();
3585 return;
3586 }
3587
3588 // Do not allow multiple callback attributes.
3589 if (D->hasAttr<CallbackAttr>()) {
3590 S.Diag(AL.getLoc(), diag::err_callback_attribute_multiple) << AL.getRange();
3591 return;
3592 }
3593
3594 D->addAttr(::new (S.Context) CallbackAttr(
3595 AL.getRange(), S.Context, EncodingIndices.data(), EncodingIndices.size(),
3596 AL.getAttributeSpellingListIndex()));
3597}
3598
3599static void handleTransparentUnionAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3600 // Try to find the underlying union declaration.
3601 RecordDecl *RD = nullptr;
3602 const auto *TD = dyn_cast<TypedefNameDecl>(D);
3603 if (TD && TD->getUnderlyingType()->isUnionType())
3604 RD = TD->getUnderlyingType()->getAsUnionType()->getDecl();
3605 else
3606 RD = dyn_cast<RecordDecl>(D);
3607
3608 if (!RD || !RD->isUnion()) {
3609 S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type) << AL
3610 << ExpectedUnion;
3611 return;
3612 }
3613
3614 if (!RD->isCompleteDefinition()) {
3615 if (!RD->isBeingDefined())
3616 S.Diag(AL.getLoc(),
3617 diag::warn_transparent_union_attribute_not_definition);
3618 return;
3619 }
3620
3621 RecordDecl::field_iterator Field = RD->field_begin(),
3622 FieldEnd = RD->field_end();
3623 if (Field == FieldEnd) {
3624 S.Diag(AL.getLoc(), diag::warn_transparent_union_attribute_zero_fields);
3625 return;
3626 }
3627
3628 FieldDecl *FirstField = *Field;
3629 QualType FirstType = FirstField->getType();
3630 if (FirstType->hasFloatingRepresentation() || FirstType->isVectorType()) {
3631 S.Diag(FirstField->getLocation(),
3632 diag::warn_transparent_union_attribute_floating)
3633 << FirstType->isVectorType() << FirstType;
3634 return;
3635 }
3636
3637 if (FirstType->isIncompleteType())
3638 return;
3639 uint64_t FirstSize = S.Context.getTypeSize(FirstType);
3640 uint64_t FirstAlign = S.Context.getTypeAlign(FirstType);
3641 for (; Field != FieldEnd; ++Field) {
3642 QualType FieldType = Field->getType();
3643 if (FieldType->isIncompleteType())
3644 return;
3645 // FIXME: this isn't fully correct; we also need to test whether the
3646 // members of the union would all have the same calling convention as the
3647 // first member of the union. Checking just the size and alignment isn't
3648 // sufficient (consider structs passed on the stack instead of in registers
3649 // as an example).
3650 if (S.Context.getTypeSize(FieldType) != FirstSize ||
3651 S.Context.getTypeAlign(FieldType) > FirstAlign) {
3652 // Warn if we drop the attribute.
3653 bool isSize = S.Context.getTypeSize(FieldType) != FirstSize;
3654 unsigned FieldBits = isSize? S.Context.getTypeSize(FieldType)
3655 : S.Context.getTypeAlign(FieldType);
3656 S.Diag(Field->getLocation(),
3657 diag::warn_transparent_union_attribute_field_size_align)
3658 << isSize << Field->getDeclName() << FieldBits;
3659 unsigned FirstBits = isSize? FirstSize : FirstAlign;
3660 S.Diag(FirstField->getLocation(),
3661 diag::note_transparent_union_first_field_size_align)
3662 << isSize << FirstBits;
3663 return;
3664 }
3665 }
3666
3667 RD->addAttr(::new (S.Context)
3668 TransparentUnionAttr(AL.getRange(), S.Context,
3669 AL.getAttributeSpellingListIndex()));
3670}
3671
3672static void handleAnnotateAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3673 // Make sure that there is a string literal as the annotation's single
3674 // argument.
3675 StringRef Str;
3676 if (!S.checkStringLiteralArgumentAttr(AL, 0, Str))
3677 return;
3678
3679 // Don't duplicate annotations that are already set.
3680 for (const auto *I : D->specific_attrs<AnnotateAttr>()) {
3681 if (I->getAnnotation() == Str)
3682 return;
3683 }
3684
3685 D->addAttr(::new (S.Context)
3686 AnnotateAttr(AL.getRange(), S.Context, Str,
3687 AL.getAttributeSpellingListIndex()));
3688}
3689
3690static void handleAlignValueAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3691 S.AddAlignValueAttr(AL.getRange(), D, AL.getArgAsExpr(0),
3692 AL.getAttributeSpellingListIndex());
3693}
3694
3695void Sema::AddAlignValueAttr(SourceRange AttrRange, Decl *D, Expr *E,
3696 unsigned SpellingListIndex) {
3697 AlignValueAttr TmpAttr(AttrRange, Context, E, SpellingListIndex);
3698 SourceLocation AttrLoc = AttrRange.getBegin();
3699
3700 QualType T;
3701 if (const auto *TD = dyn_cast<TypedefNameDecl>(D))
3702 T = TD->getUnderlyingType();
3703 else if (const auto *VD = dyn_cast<ValueDecl>(D))
3704 T = VD->getType();
3705 else
3706 llvm_unreachable("Unknown decl type for align_value")::llvm::llvm_unreachable_internal("Unknown decl type for align_value"
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 3706)
;
3707
3708 if (!T->isDependentType() && !T->isAnyPointerType() &&
3709 !T->isReferenceType() && !T->isMemberPointerType()) {
3710 Diag(AttrLoc, diag::warn_attribute_pointer_or_reference_only)
3711 << &TmpAttr /*TmpAttr.getName()*/ << T << D->getSourceRange();
3712 return;
3713 }
3714
3715 if (!E->isValueDependent()) {
3716 llvm::APSInt Alignment;
3717 ExprResult ICE
3718 = VerifyIntegerConstantExpression(E, &Alignment,
3719 diag::err_align_value_attribute_argument_not_int,
3720 /*AllowFold*/ false);
3721 if (ICE.isInvalid())
3722 return;
3723
3724 if (!Alignment.isPowerOf2()) {
3725 Diag(AttrLoc, diag::err_alignment_not_power_of_two)
3726 << E->getSourceRange();
3727 return;
3728 }
3729
3730 D->addAttr(::new (Context)
3731 AlignValueAttr(AttrRange, Context, ICE.get(),
3732 SpellingListIndex));
3733 return;
3734 }
3735
3736 // Save dependent expressions in the AST to be instantiated.
3737 D->addAttr(::new (Context) AlignValueAttr(TmpAttr));
3738}
3739
3740static void handleAlignedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
3741 // check the attribute arguments.
3742 if (AL.getNumArgs() > 1) {
3743 S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments) << AL << 1;
3744 return;
3745 }
3746
3747 if (AL.getNumArgs() == 0) {
3748 D->addAttr(::new (S.Context) AlignedAttr(AL.getRange(), S.Context,
3749 true, nullptr, AL.getAttributeSpellingListIndex()));
3750 return;
3751 }
3752
3753 Expr *E = AL.getArgAsExpr(0);
3754 if (AL.isPackExpansion() && !E->containsUnexpandedParameterPack()) {
3755 S.Diag(AL.getEllipsisLoc(),
3756 diag::err_pack_expansion_without_parameter_packs);
3757 return;
3758 }
3759
3760 if (!AL.isPackExpansion() && S.DiagnoseUnexpandedParameterPack(E))
3761 return;
3762
3763 S.AddAlignedAttr(AL.getRange(), D, E, AL.getAttributeSpellingListIndex(),
3764 AL.isPackExpansion());
3765}
3766
3767void Sema::AddAlignedAttr(SourceRange AttrRange, Decl *D, Expr *E,
3768 unsigned SpellingListIndex, bool IsPackExpansion) {
3769 AlignedAttr TmpAttr(AttrRange, Context, true, E, SpellingListIndex);
3770 SourceLocation AttrLoc = AttrRange.getBegin();
3771
3772 // C++11 alignas(...) and C11 _Alignas(...) have additional requirements.
3773 if (TmpAttr.isAlignas()) {
3774 // C++11 [dcl.align]p1:
3775 // An alignment-specifier may be applied to a variable or to a class
3776 // data member, but it shall not be applied to a bit-field, a function
3777 // parameter, the formal parameter of a catch clause, or a variable
3778 // declared with the register storage class specifier. An
3779 // alignment-specifier may also be applied to the declaration of a class
3780 // or enumeration type.
3781 // C11 6.7.5/2:
3782 // An alignment attribute shall not be specified in a declaration of
3783 // a typedef, or a bit-field, or a function, or a parameter, or an
3784 // object declared with the register storage-class specifier.
3785 int DiagKind = -1;
3786 if (isa<ParmVarDecl>(D)) {
3787 DiagKind = 0;
3788 } else if (const auto *VD = dyn_cast<VarDecl>(D)) {
3789 if (VD->getStorageClass() == SC_Register)
3790 DiagKind = 1;
3791 if (VD->isExceptionVariable())
3792 DiagKind = 2;
3793 } else if (const auto *FD = dyn_cast<FieldDecl>(D)) {
3794 if (FD->isBitField())
3795 DiagKind = 3;
3796 } else if (!isa<TagDecl>(D)) {
3797 Diag(AttrLoc, diag::err_attribute_wrong_decl_type) << &TmpAttr
3798 << (TmpAttr.isC11() ? ExpectedVariableOrField
3799 : ExpectedVariableFieldOrTag);
3800 return;
3801 }
3802 if (DiagKind != -1) {
3803 Diag(AttrLoc, diag::err_alignas_attribute_wrong_decl_type)
3804 << &TmpAttr << DiagKind;
3805 return;
3806 }
3807 }
3808
3809 if (E->isValueDependent()) {
3810 // We can't support a dependent alignment on a non-dependent type,
3811 // because we have no way to model that a type is "alignment-dependent"
3812 // but not dependent in any other way.
3813 if (const auto *TND = dyn_cast<TypedefNameDecl>(D)) {
3814 if (!TND->getUnderlyingType()->isDependentType()) {
3815 Diag(AttrLoc, diag::err_alignment_dependent_typedef_name)
3816 << E->getSourceRange();
3817 return;
3818 }
3819 }
3820
3821 // Save dependent expressions in the AST to be instantiated.
3822 AlignedAttr *AA = ::new (Context) AlignedAttr(TmpAttr);
3823 AA->setPackExpansion(IsPackExpansion);
3824 D->addAttr(AA);
3825 return;
3826 }
3827
3828 // FIXME: Cache the number on the AL object?
3829 llvm::APSInt Alignment;
3830 ExprResult ICE
3831 = VerifyIntegerConstantExpression(E, &Alignment,
3832 diag::err_aligned_attribute_argument_not_int,
3833 /*AllowFold*/ false);
3834 if (ICE.isInvalid())
3835 return;
3836
3837 uint64_t AlignVal = Alignment.getZExtValue();
3838
3839 // C++11 [dcl.align]p2:
3840 // -- if the constant expression evaluates to zero, the alignment
3841 // specifier shall have no effect
3842 // C11 6.7.5p6:
3843 // An alignment specification of zero has no effect.
3844 if (!(TmpAttr.isAlignas() && !Alignment)) {
3845 if (!llvm::isPowerOf2_64(AlignVal)) {
3846 Diag(AttrLoc, diag::err_alignment_not_power_of_two)
3847 << E->getSourceRange();
3848 return;
3849 }
3850 }
3851
3852 // Alignment calculations can wrap around if it's greater than 2**28.
3853 unsigned MaxValidAlignment =
3854 Context.getTargetInfo().getTriple().isOSBinFormatCOFF() ? 8192
3855 : 268435456;
3856 if (AlignVal > MaxValidAlignment) {
3857 Diag(AttrLoc, diag::err_attribute_aligned_too_great) << MaxValidAlignment
3858 << E->getSourceRange();
3859 return;
3860 }
3861
3862 if (Context.getTargetInfo().isTLSSupported()) {
3863 unsigned MaxTLSAlign =
3864 Context.toCharUnitsFromBits(Context.getTargetInfo().getMaxTLSAlign())
3865 .getQuantity();
3866 const auto *VD = dyn_cast<VarDecl>(D);
3867 if (MaxTLSAlign && AlignVal > MaxTLSAlign && VD &&
3868 VD->getTLSKind() != VarDecl::TLS_None) {
3869 Diag(VD->getLocation(), diag::err_tls_var_aligned_over_maximum)
3870 << (unsigned)AlignVal << VD << MaxTLSAlign;
3871 return;
3872 }
3873 }
3874
3875 AlignedAttr *AA = ::new (Context) AlignedAttr(AttrRange, Context, true,
3876 ICE.get(), SpellingListIndex);
3877 AA->setPackExpansion(IsPackExpansion);
3878 D->addAttr(AA);
3879}
3880
3881void Sema::AddAlignedAttr(SourceRange AttrRange, Decl *D, TypeSourceInfo *TS,
3882 unsigned SpellingListIndex, bool IsPackExpansion) {
3883 // FIXME: Cache the number on the AL object if non-dependent?
3884 // FIXME: Perform checking of type validity
3885 AlignedAttr *AA = ::new (Context) AlignedAttr(AttrRange, Context, false, TS,
3886 SpellingListIndex);
3887 AA->setPackExpansion(IsPackExpansion);
3888 D->addAttr(AA);
3889}
3890
3891void Sema::CheckAlignasUnderalignment(Decl *D) {
3892 assert(D->hasAttrs() && "no attributes on decl")((D->hasAttrs() && "no attributes on decl") ? static_cast
<void> (0) : __assert_fail ("D->hasAttrs() && \"no attributes on decl\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 3892, __PRETTY_FUNCTION__))
;
3893
3894 QualType UnderlyingTy, DiagTy;
3895 if (const auto *VD = dyn_cast<ValueDecl>(D)) {
3896 UnderlyingTy = DiagTy = VD->getType();
3897 } else {
3898 UnderlyingTy = DiagTy = Context.getTagDeclType(cast<TagDecl>(D));
3899 if (const auto *ED = dyn_cast<EnumDecl>(D))
3900 UnderlyingTy = ED->getIntegerType();
3901 }
3902 if (DiagTy->isDependentType() || DiagTy->isIncompleteType())
3903 return;
3904
3905 // C++11 [dcl.align]p5, C11 6.7.5/4:
3906 // The combined effect of all alignment attributes in a declaration shall
3907 // not specify an alignment that is less strict than the alignment that
3908 // would otherwise be required for the entity being declared.
3909 AlignedAttr *AlignasAttr = nullptr;
3910 unsigned Align = 0;
3911 for (auto *I : D->specific_attrs<AlignedAttr>()) {
3912 if (I->isAlignmentDependent())
3913 return;
3914 if (I->isAlignas())
3915 AlignasAttr = I;
3916 Align = std::max(Align, I->getAlignment(Context));
3917 }
3918
3919 if (AlignasAttr && Align) {
3920 CharUnits RequestedAlign = Context.toCharUnitsFromBits(Align);
3921 CharUnits NaturalAlign = Context.getTypeAlignInChars(UnderlyingTy);
3922 if (NaturalAlign > RequestedAlign)
3923 Diag(AlignasAttr->getLocation(), diag::err_alignas_underaligned)
3924 << DiagTy << (unsigned)NaturalAlign.getQuantity();
3925 }
3926}
3927
3928bool Sema::checkMSInheritanceAttrOnDefinition(
3929 CXXRecordDecl *RD, SourceRange Range, bool BestCase,
3930 MSInheritanceAttr::Spelling SemanticSpelling) {
3931 assert(RD->hasDefinition() && "RD has no definition!")((RD->hasDefinition() && "RD has no definition!") ?
static_cast<void> (0) : __assert_fail ("RD->hasDefinition() && \"RD has no definition!\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 3931, __PRETTY_FUNCTION__))
;
3932
3933 // We may not have seen base specifiers or any virtual methods yet. We will
3934 // have to wait until the record is defined to catch any mismatches.
3935 if (!RD->getDefinition()->isCompleteDefinition())
3936 return false;
3937
3938 // The unspecified model never matches what a definition could need.
3939 if (SemanticSpelling == MSInheritanceAttr::Keyword_unspecified_inheritance)
3940 return false;
3941
3942 if (BestCase) {
3943 if (RD->calculateInheritanceModel() == SemanticSpelling)
3944 return false;
3945 } else {
3946 if (RD->calculateInheritanceModel() <= SemanticSpelling)
3947 return false;
3948 }
3949
3950 Diag(Range.getBegin(), diag::err_mismatched_ms_inheritance)
3951 << 0 /*definition*/;
3952 Diag(RD->getDefinition()->getLocation(), diag::note_defined_here)
3953 << RD->getNameAsString();
3954 return true;
3955}
3956
3957/// parseModeAttrArg - Parses attribute mode string and returns parsed type
3958/// attribute.
3959static void parseModeAttrArg(Sema &S, StringRef Str, unsigned &DestWidth,
3960 bool &IntegerMode, bool &ComplexMode) {
3961 IntegerMode = true;
3962 ComplexMode = false;
3963 switch (Str.size()) {
3964 case 2:
3965 switch (Str[0]) {
3966 case 'Q':
3967 DestWidth = 8;
3968 break;
3969 case 'H':
3970 DestWidth = 16;
3971 break;
3972 case 'S':
3973 DestWidth = 32;
3974 break;
3975 case 'D':
3976 DestWidth = 64;
3977 break;
3978 case 'X':
3979 DestWidth = 96;
3980 break;
3981 case 'T':
3982 DestWidth = 128;
3983 break;
3984 }
3985 if (Str[1] == 'F') {
3986 IntegerMode = false;
3987 } else if (Str[1] == 'C') {
3988 IntegerMode = false;
3989 ComplexMode = true;
3990 } else if (Str[1] != 'I') {
3991 DestWidth = 0;
3992 }
3993 break;
3994 case 4:
3995 // FIXME: glibc uses 'word' to define register_t; this is narrower than a
3996 // pointer on PIC16 and other embedded platforms.
3997 if (Str == "word")
3998 DestWidth = S.Context.getTargetInfo().getRegisterWidth();
3999 else if (Str == "byte")
4000 DestWidth = S.Context.getTargetInfo().getCharWidth();
4001 break;
4002 case 7:
4003 if (Str == "pointer")
4004 DestWidth = S.Context.getTargetInfo().getPointerWidth(0);
4005 break;
4006 case 11:
4007 if (Str == "unwind_word")
4008 DestWidth = S.Context.getTargetInfo().getUnwindWordWidth();
4009 break;
4010 }
4011}
4012
4013/// handleModeAttr - This attribute modifies the width of a decl with primitive
4014/// type.
4015///
4016/// Despite what would be logical, the mode attribute is a decl attribute, not a
4017/// type attribute: 'int ** __attribute((mode(HI))) *G;' tries to make 'G' be
4018/// HImode, not an intermediate pointer.
4019static void handleModeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4020 // This attribute isn't documented, but glibc uses it. It changes
4021 // the width of an int or unsigned int to the specified size.
4022 if (!AL.isArgIdent(0)) {
4023 S.Diag(AL.getLoc(), diag::err_attribute_argument_type)
4024 << AL << AANT_ArgumentIdentifier;
4025 return;
4026 }
4027
4028 IdentifierInfo *Name = AL.getArgAsIdent(0)->Ident;
4029
4030 S.AddModeAttr(AL.getRange(), D, Name, AL.getAttributeSpellingListIndex());
4031}
4032
4033void Sema::AddModeAttr(SourceRange AttrRange, Decl *D, IdentifierInfo *Name,
4034 unsigned SpellingListIndex, bool InInstantiation) {
4035 StringRef Str = Name->getName();
4036 normalizeName(Str);
4037 SourceLocation AttrLoc = AttrRange.getBegin();
4038
4039 unsigned DestWidth = 0;
4040 bool IntegerMode = true;
4041 bool ComplexMode = false;
4042 llvm::APInt VectorSize(64, 0);
4043 if (Str.size() >= 4 && Str[0] == 'V') {
4044 // Minimal length of vector mode is 4: 'V' + NUMBER(>=1) + TYPE(>=2).
4045 size_t StrSize = Str.size();
4046 size_t VectorStringLength = 0;
4047 while ((VectorStringLength + 1) < StrSize &&
4048 isdigit(Str[VectorStringLength + 1]))
4049 ++VectorStringLength;
4050 if (VectorStringLength &&
4051 !Str.substr(1, VectorStringLength).getAsInteger(10, VectorSize) &&
4052 VectorSize.isPowerOf2()) {
4053 parseModeAttrArg(*this, Str.substr(VectorStringLength + 1), DestWidth,
4054 IntegerMode, ComplexMode);
4055 // Avoid duplicate warning from template instantiation.
4056 if (!InInstantiation)
4057 Diag(AttrLoc, diag::warn_vector_mode_deprecated);
4058 } else {
4059 VectorSize = 0;
4060 }
4061 }
4062
4063 if (!VectorSize)
4064 parseModeAttrArg(*this, Str, DestWidth, IntegerMode, ComplexMode);
4065
4066 // FIXME: Sync this with InitializePredefinedMacros; we need to match int8_t
4067 // and friends, at least with glibc.
4068 // FIXME: Make sure floating-point mappings are accurate
4069 // FIXME: Support XF and TF types
4070 if (!DestWidth) {
4071 Diag(AttrLoc, diag::err_machine_mode) << 0 /*Unknown*/ << Name;
4072 return;
4073 }
4074
4075 QualType OldTy;
4076 if (const auto *TD = dyn_cast<TypedefNameDecl>(D))
4077 OldTy = TD->getUnderlyingType();
4078 else if (const auto *ED = dyn_cast<EnumDecl>(D)) {
4079 // Something like 'typedef enum { X } __attribute__((mode(XX))) T;'.
4080 // Try to get type from enum declaration, default to int.
4081 OldTy = ED->getIntegerType();
4082 if (OldTy.isNull())
4083 OldTy = Context.IntTy;
4084 } else
4085 OldTy = cast<ValueDecl>(D)->getType();
4086
4087 if (OldTy->isDependentType()) {
4088 D->addAttr(::new (Context)
4089 ModeAttr(AttrRange, Context, Name, SpellingListIndex));
4090 return;
4091 }
4092
4093 // Base type can also be a vector type (see PR17453).
4094 // Distinguish between base type and base element type.
4095 QualType OldElemTy = OldTy;
4096 if (const auto *VT = OldTy->getAs<VectorType>())
4097 OldElemTy = VT->getElementType();
4098
4099 // GCC allows 'mode' attribute on enumeration types (even incomplete), except
4100 // for vector modes. So, 'enum X __attribute__((mode(QI)));' forms a complete
4101 // type, 'enum { A } __attribute__((mode(V4SI)))' is rejected.
4102 if ((isa<EnumDecl>(D) || OldElemTy->getAs<EnumType>()) &&
4103 VectorSize.getBoolValue()) {
4104 Diag(AttrLoc, diag::err_enum_mode_vector_type) << Name << AttrRange;
4105 return;
4106 }
4107 bool IntegralOrAnyEnumType =
4108 OldElemTy->isIntegralOrEnumerationType() || OldElemTy->getAs<EnumType>();
4109
4110 if (!OldElemTy->getAs<BuiltinType>() && !OldElemTy->isComplexType() &&
4111 !IntegralOrAnyEnumType)
4112 Diag(AttrLoc, diag::err_mode_not_primitive);
4113 else if (IntegerMode) {
4114 if (!IntegralOrAnyEnumType)
4115 Diag(AttrLoc, diag::err_mode_wrong_type);
4116 } else if (ComplexMode) {
4117 if (!OldElemTy->isComplexType())
4118 Diag(AttrLoc, diag::err_mode_wrong_type);
4119 } else {
4120 if (!OldElemTy->isFloatingType())
4121 Diag(AttrLoc, diag::err_mode_wrong_type);
4122 }
4123
4124 QualType NewElemTy;
4125
4126 if (IntegerMode)
4127 NewElemTy = Context.getIntTypeForBitwidth(DestWidth,
4128 OldElemTy->isSignedIntegerType());
4129 else
4130 NewElemTy = Context.getRealTypeForBitwidth(DestWidth);
4131
4132 if (NewElemTy.isNull()) {
4133 Diag(AttrLoc, diag::err_machine_mode) << 1 /*Unsupported*/ << Name;
4134 return;
4135 }
4136
4137 if (ComplexMode) {
4138 NewElemTy = Context.getComplexType(NewElemTy);
4139 }
4140
4141 QualType NewTy = NewElemTy;
4142 if (VectorSize.getBoolValue()) {
4143 NewTy = Context.getVectorType(NewTy, VectorSize.getZExtValue(),
4144 VectorType::GenericVector);
4145 } else if (const auto *OldVT = OldTy->getAs<VectorType>()) {
4146 // Complex machine mode does not support base vector types.
4147 if (ComplexMode) {
4148 Diag(AttrLoc, diag::err_complex_mode_vector_type);
4149 return;
4150 }
4151 unsigned NumElements = Context.getTypeSize(OldElemTy) *
4152 OldVT->getNumElements() /
4153 Context.getTypeSize(NewElemTy);
4154 NewTy =
4155 Context.getVectorType(NewElemTy, NumElements, OldVT->getVectorKind());
4156 }
4157
4158 if (NewTy.isNull()) {
4159 Diag(AttrLoc, diag::err_mode_wrong_type);
4160 return;
4161 }
4162
4163 // Install the new type.
4164 if (auto *TD = dyn_cast<TypedefNameDecl>(D))
4165 TD->setModedTypeSourceInfo(TD->getTypeSourceInfo(), NewTy);
4166 else if (auto *ED = dyn_cast<EnumDecl>(D))
4167 ED->setIntegerType(NewTy);
4168 else
4169 cast<ValueDecl>(D)->setType(NewTy);
4170
4171 D->addAttr(::new (Context)
4172 ModeAttr(AttrRange, Context, Name, SpellingListIndex));
4173}
4174
4175static void handleNoDebugAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4176 D->addAttr(::new (S.Context)
4177 NoDebugAttr(AL.getRange(), S.Context,
4178 AL.getAttributeSpellingListIndex()));
4179}
4180
4181AlwaysInlineAttr *Sema::mergeAlwaysInlineAttr(Decl *D, SourceRange Range,
4182 IdentifierInfo *Ident,
4183 unsigned AttrSpellingListIndex) {
4184 if (OptimizeNoneAttr *Optnone = D->getAttr<OptimizeNoneAttr>()) {
4185 Diag(Range.getBegin(), diag::warn_attribute_ignored) << Ident;
4186 Diag(Optnone->getLocation(), diag::note_conflicting_attribute);
4187 return nullptr;
4188 }
4189
4190 if (D->hasAttr<AlwaysInlineAttr>())
4191 return nullptr;
4192
4193 return ::new (Context) AlwaysInlineAttr(Range, Context,
4194 AttrSpellingListIndex);
4195}
4196
4197CommonAttr *Sema::mergeCommonAttr(Decl *D, const ParsedAttr &AL) {
4198 if (checkAttrMutualExclusion<InternalLinkageAttr>(*this, D, AL))
4199 return nullptr;
4200
4201 return ::new (Context)
4202 CommonAttr(AL.getRange(), Context, AL.getAttributeSpellingListIndex());
4203}
4204
4205CommonAttr *Sema::mergeCommonAttr(Decl *D, const CommonAttr &AL) {
4206 if (checkAttrMutualExclusion<InternalLinkageAttr>(*this, D, AL))
4207 return nullptr;
4208
4209 return ::new (Context)
4210 CommonAttr(AL.getRange(), Context, AL.getSpellingListIndex());
4211}
4212
4213InternalLinkageAttr *Sema::mergeInternalLinkageAttr(Decl *D,
4214 const ParsedAttr &AL) {
4215 if (const auto *VD = dyn_cast<VarDecl>(D)) {
4216 // Attribute applies to Var but not any subclass of it (like ParmVar,
4217 // ImplicitParm or VarTemplateSpecialization).
4218 if (VD->getKind() != Decl::Var) {
4219 Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type)
4220 << AL << (getLangOpts().CPlusPlus ? ExpectedFunctionVariableOrClass
4221 : ExpectedVariableOrFunction);
4222 return nullptr;
4223 }
4224 // Attribute does not apply to non-static local variables.
4225 if (VD->hasLocalStorage()) {
4226 Diag(VD->getLocation(), diag::warn_internal_linkage_local_storage);
4227 return nullptr;
4228 }
4229 }
4230
4231 if (checkAttrMutualExclusion<CommonAttr>(*this, D, AL))
4232 return nullptr;
4233
4234 return ::new (Context) InternalLinkageAttr(
4235 AL.getRange(), Context, AL.getAttributeSpellingListIndex());
4236}
4237InternalLinkageAttr *
4238Sema::mergeInternalLinkageAttr(Decl *D, const InternalLinkageAttr &AL) {
4239 if (const auto *VD = dyn_cast<VarDecl>(D)) {
4240 // Attribute applies to Var but not any subclass of it (like ParmVar,
4241 // ImplicitParm or VarTemplateSpecialization).
4242 if (VD->getKind() != Decl::Var) {
4243 Diag(AL.getLocation(), diag::warn_attribute_wrong_decl_type)
4244 << &AL << (getLangOpts().CPlusPlus ? ExpectedFunctionVariableOrClass
4245 : ExpectedVariableOrFunction);
4246 return nullptr;
4247 }
4248 // Attribute does not apply to non-static local variables.
4249 if (VD->hasLocalStorage()) {
4250 Diag(VD->getLocation(), diag::warn_internal_linkage_local_storage);
4251 return nullptr;
4252 }
4253 }
4254
4255 if (checkAttrMutualExclusion<CommonAttr>(*this, D, AL))
4256 return nullptr;
4257
4258 return ::new (Context)
4259 InternalLinkageAttr(AL.getRange(), Context, AL.getSpellingListIndex());
4260}
4261
4262MinSizeAttr *Sema::mergeMinSizeAttr(Decl *D, SourceRange Range,
4263 unsigned AttrSpellingListIndex) {
4264 if (OptimizeNoneAttr *Optnone = D->getAttr<OptimizeNoneAttr>()) {
4265 Diag(Range.getBegin(), diag::warn_attribute_ignored) << "'minsize'";
4266 Diag(Optnone->getLocation(), diag::note_conflicting_attribute);
4267 return nullptr;
4268 }
4269
4270 if (D->hasAttr<MinSizeAttr>())
4271 return nullptr;
4272
4273 return ::new (Context) MinSizeAttr(Range, Context, AttrSpellingListIndex);
4274}
4275
4276NoSpeculativeLoadHardeningAttr *Sema::mergeNoSpeculativeLoadHardeningAttr(
4277 Decl *D, const NoSpeculativeLoadHardeningAttr &AL) {
4278 if (checkAttrMutualExclusion<SpeculativeLoadHardeningAttr>(*this, D, AL))
4279 return nullptr;
4280
4281 return ::new (Context) NoSpeculativeLoadHardeningAttr(
4282 AL.getRange(), Context, AL.getSpellingListIndex());
4283}
4284
4285OptimizeNoneAttr *Sema::mergeOptimizeNoneAttr(Decl *D, SourceRange Range,
4286 unsigned AttrSpellingListIndex) {
4287 if (AlwaysInlineAttr *Inline = D->getAttr<AlwaysInlineAttr>()) {
4288 Diag(Inline->getLocation(), diag::warn_attribute_ignored) << Inline;
4289 Diag(Range.getBegin(), diag::note_conflicting_attribute);
4290 D->dropAttr<AlwaysInlineAttr>();
4291 }
4292 if (MinSizeAttr *MinSize = D->getAttr<MinSizeAttr>()) {
4293 Diag(MinSize->getLocation(), diag::warn_attribute_ignored) << MinSize;
4294 Diag(Range.getBegin(), diag::note_conflicting_attribute);
4295 D->dropAttr<MinSizeAttr>();
4296 }
4297
4298 if (D->hasAttr<OptimizeNoneAttr>())
4299 return nullptr;
4300
4301 return ::new (Context) OptimizeNoneAttr(Range, Context,
4302 AttrSpellingListIndex);
4303}
4304
4305SpeculativeLoadHardeningAttr *Sema::mergeSpeculativeLoadHardeningAttr(
4306 Decl *D, const SpeculativeLoadHardeningAttr &AL) {
4307 if (checkAttrMutualExclusion<NoSpeculativeLoadHardeningAttr>(*this, D, AL))
4308 return nullptr;
4309
4310 return ::new (Context) SpeculativeLoadHardeningAttr(
4311 AL.getRange(), Context, AL.getSpellingListIndex());
4312}
4313
4314static void handleAlwaysInlineAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4315 if (checkAttrMutualExclusion<NotTailCalledAttr>(S, D, AL))
4316 return;
4317
4318 if (AlwaysInlineAttr *Inline = S.mergeAlwaysInlineAttr(
4319 D, AL.getRange(), AL.getName(),
4320 AL.getAttributeSpellingListIndex()))
4321 D->addAttr(Inline);
4322}
4323
4324static void handleMinSizeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4325 if (MinSizeAttr *MinSize = S.mergeMinSizeAttr(
4326 D, AL.getRange(), AL.getAttributeSpellingListIndex()))
4327 D->addAttr(MinSize);
4328}
4329
4330static void handleOptimizeNoneAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4331 if (OptimizeNoneAttr *Optnone = S.mergeOptimizeNoneAttr(
4332 D, AL.getRange(), AL.getAttributeSpellingListIndex()))
4333 D->addAttr(Optnone);
4334}
4335
4336static void handleConstantAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4337 if (checkAttrMutualExclusion<CUDASharedAttr>(S, D, AL))
4338 return;
4339 const auto *VD = cast<VarDecl>(D);
4340 if (!VD->hasGlobalStorage()) {
4341 S.Diag(AL.getLoc(), diag::err_cuda_nonglobal_constant);
4342 return;
4343 }
4344 D->addAttr(::new (S.Context) CUDAConstantAttr(
4345 AL.getRange(), S.Context, AL.getAttributeSpellingListIndex()));
4346}
4347
4348static void handleSharedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4349 if (checkAttrMutualExclusion<CUDAConstantAttr>(S, D, AL))
4350 return;
4351 const auto *VD = cast<VarDecl>(D);
4352 // extern __shared__ is only allowed on arrays with no length (e.g.
4353 // "int x[]").
4354 if (!S.getLangOpts().GPURelocatableDeviceCode && VD->hasExternalStorage() &&
4355 !isa<IncompleteArrayType>(VD->getType())) {
4356 S.Diag(AL.getLoc(), diag::err_cuda_extern_shared) << VD;
4357 return;
4358 }
4359 if (S.getLangOpts().CUDA && VD->hasLocalStorage() &&
4360 S.CUDADiagIfHostCode(AL.getLoc(), diag::err_cuda_host_shared)
4361 << S.CurrentCUDATarget())
4362 return;
4363 D->addAttr(::new (S.Context) CUDASharedAttr(
4364 AL.getRange(), S.Context, AL.getAttributeSpellingListIndex()));
4365}
4366
4367static void handleGlobalAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4368 if (checkAttrMutualExclusion<CUDADeviceAttr>(S, D, AL) ||
4369 checkAttrMutualExclusion<CUDAHostAttr>(S, D, AL)) {
4370 return;
4371 }
4372 const auto *FD = cast<FunctionDecl>(D);
4373 if (!FD->getReturnType()->isVoidType()) {
4374 SourceRange RTRange = FD->getReturnTypeSourceRange();
4375 S.Diag(FD->getTypeSpecStartLoc(), diag::err_kern_type_not_void_return)
4376 << FD->getType()
4377 << (RTRange.isValid() ? FixItHint::CreateReplacement(RTRange, "void")
4378 : FixItHint());
4379 return;
4380 }
4381 if (const auto *Method = dyn_cast<CXXMethodDecl>(FD)) {
4382 if (Method->isInstance()) {
4383 S.Diag(Method->getBeginLoc(), diag::err_kern_is_nonstatic_method)
4384 << Method;
4385 return;
4386 }
4387 S.Diag(Method->getBeginLoc(), diag::warn_kern_is_method) << Method;
4388 }
4389 // Only warn for "inline" when compiling for host, to cut down on noise.
4390 if (FD->isInlineSpecified() && !S.getLangOpts().CUDAIsDevice)
4391 S.Diag(FD->getBeginLoc(), diag::warn_kern_is_inline) << FD;
4392
4393 D->addAttr(::new (S.Context)
4394 CUDAGlobalAttr(AL.getRange(), S.Context,
4395 AL.getAttributeSpellingListIndex()));
4396}
4397
4398static void handleGNUInlineAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4399 const auto *Fn = cast<FunctionDecl>(D);
4400 if (!Fn->isInlineSpecified()) {
4401 S.Diag(AL.getLoc(), diag::warn_gnu_inline_attribute_requires_inline);
4402 return;
4403 }
4404
4405 D->addAttr(::new (S.Context)
4406 GNUInlineAttr(AL.getRange(), S.Context,
4407 AL.getAttributeSpellingListIndex()));
4408}
4409
4410static void handleCallConvAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4411 if (hasDeclarator(D)) return;
4412
4413 // Diagnostic is emitted elsewhere: here we store the (valid) AL
4414 // in the Decl node for syntactic reasoning, e.g., pretty-printing.
4415 CallingConv CC;
4416 if (S.CheckCallingConvAttr(AL, CC, /*FD*/nullptr))
4417 return;
4418
4419 if (!isa<ObjCMethodDecl>(D)) {
4420 S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type)
4421 << AL << ExpectedFunctionOrMethod;
4422 return;
4423 }
4424
4425 switch (AL.getKind()) {
4426 case ParsedAttr::AT_FastCall:
4427 D->addAttr(::new (S.Context)
4428 FastCallAttr(AL.getRange(), S.Context,
4429 AL.getAttributeSpellingListIndex()));
4430 return;
4431 case ParsedAttr::AT_StdCall:
4432 D->addAttr(::new (S.Context)
4433 StdCallAttr(AL.getRange(), S.Context,
4434 AL.getAttributeSpellingListIndex()));
4435 return;
4436 case ParsedAttr::AT_ThisCall:
4437 D->addAttr(::new (S.Context)
4438 ThisCallAttr(AL.getRange(), S.Context,
4439 AL.getAttributeSpellingListIndex()));
4440 return;
4441 case ParsedAttr::AT_CDecl:
4442 D->addAttr(::new (S.Context)
4443 CDeclAttr(AL.getRange(), S.Context,
4444 AL.getAttributeSpellingListIndex()));
4445 return;
4446 case ParsedAttr::AT_Pascal:
4447 D->addAttr(::new (S.Context)
4448 PascalAttr(AL.getRange(), S.Context,
4449 AL.getAttributeSpellingListIndex()));
4450 return;
4451 case ParsedAttr::AT_SwiftCall:
4452 D->addAttr(::new (S.Context)
4453 SwiftCallAttr(AL.getRange(), S.Context,
4454 AL.getAttributeSpellingListIndex()));
4455 return;
4456 case ParsedAttr::AT_VectorCall:
4457 D->addAttr(::new (S.Context)
4458 VectorCallAttr(AL.getRange(), S.Context,
4459 AL.getAttributeSpellingListIndex()));
4460 return;
4461 case ParsedAttr::AT_MSABI:
4462 D->addAttr(::new (S.Context)
4463 MSABIAttr(AL.getRange(), S.Context,
4464 AL.getAttributeSpellingListIndex()));
4465 return;
4466 case ParsedAttr::AT_SysVABI:
4467 D->addAttr(::new (S.Context)
4468 SysVABIAttr(AL.getRange(), S.Context,
4469 AL.getAttributeSpellingListIndex()));
4470 return;
4471 case ParsedAttr::AT_RegCall:
4472 D->addAttr(::new (S.Context) RegCallAttr(
4473 AL.getRange(), S.Context, AL.getAttributeSpellingListIndex()));
4474 return;
4475 case ParsedAttr::AT_Pcs: {
4476 PcsAttr::PCSType PCS;
4477 switch (CC) {
4478 case CC_AAPCS:
4479 PCS = PcsAttr::AAPCS;
4480 break;
4481 case CC_AAPCS_VFP:
4482 PCS = PcsAttr::AAPCS_VFP;
4483 break;
4484 default:
4485 llvm_unreachable("unexpected calling convention in pcs attribute")::llvm::llvm_unreachable_internal("unexpected calling convention in pcs attribute"
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 4485)
;
4486 }
4487
4488 D->addAttr(::new (S.Context)
4489 PcsAttr(AL.getRange(), S.Context, PCS,
4490 AL.getAttributeSpellingListIndex()));
4491 return;
4492 }
4493 case ParsedAttr::AT_AArch64VectorPcs:
4494 D->addAttr(::new(S.Context)
4495 AArch64VectorPcsAttr(AL.getRange(), S.Context,
4496 AL.getAttributeSpellingListIndex()));
4497 return;
4498 case ParsedAttr::AT_IntelOclBicc:
4499 D->addAttr(::new (S.Context)
4500 IntelOclBiccAttr(AL.getRange(), S.Context,
4501 AL.getAttributeSpellingListIndex()));
4502 return;
4503 case ParsedAttr::AT_PreserveMost:
4504 D->addAttr(::new (S.Context) PreserveMostAttr(
4505 AL.getRange(), S.Context, AL.getAttributeSpellingListIndex()));
4506 return;
4507 case ParsedAttr::AT_PreserveAll:
4508 D->addAttr(::new (S.Context) PreserveAllAttr(
4509 AL.getRange(), S.Context, AL.getAttributeSpellingListIndex()));
4510 return;
4511 default:
4512 llvm_unreachable("unexpected attribute kind")::llvm::llvm_unreachable_internal("unexpected attribute kind"
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 4512)
;
4513 }
4514}
4515
4516static void handleSuppressAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4517 if (!checkAttributeAtLeastNumArgs(S, AL, 1))
4518 return;
4519
4520 std::vector<StringRef> DiagnosticIdentifiers;
4521 for (unsigned I = 0, E = AL.getNumArgs(); I != E; ++I) {
4522 StringRef RuleName;
4523
4524 if (!S.checkStringLiteralArgumentAttr(AL, I, RuleName, nullptr))
4525 return;
4526
4527 // FIXME: Warn if the rule name is unknown. This is tricky because only
4528 // clang-tidy knows about available rules.
4529 DiagnosticIdentifiers.push_back(RuleName);
4530 }
4531 D->addAttr(::new (S.Context) SuppressAttr(
4532 AL.getRange(), S.Context, DiagnosticIdentifiers.data(),
4533 DiagnosticIdentifiers.size(), AL.getAttributeSpellingListIndex()));
4534}
4535
4536bool Sema::CheckCallingConvAttr(const ParsedAttr &Attrs, CallingConv &CC,
4537 const FunctionDecl *FD) {
4538 if (Attrs.isInvalid())
4539 return true;
4540
4541 if (Attrs.hasProcessingCache()) {
4542 CC = (CallingConv) Attrs.getProcessingCache();
4543 return false;
4544 }
4545
4546 unsigned ReqArgs = Attrs.getKind() == ParsedAttr::AT_Pcs ? 1 : 0;
4547 if (!checkAttributeNumArgs(*this, Attrs, ReqArgs)) {
4548 Attrs.setInvalid();
4549 return true;
4550 }
4551
4552 // TODO: diagnose uses of these conventions on the wrong target.
4553 switch (Attrs.getKind()) {
4554 case ParsedAttr::AT_CDecl:
4555 CC = CC_C;
4556 break;
4557 case ParsedAttr::AT_FastCall:
4558 CC = CC_X86FastCall;
4559 break;
4560 case ParsedAttr::AT_StdCall:
4561 CC = CC_X86StdCall;
4562 break;
4563 case ParsedAttr::AT_ThisCall:
4564 CC = CC_X86ThisCall;
4565 break;
4566 case ParsedAttr::AT_Pascal:
4567 CC = CC_X86Pascal;
4568 break;
4569 case ParsedAttr::AT_SwiftCall:
4570 CC = CC_Swift;
4571 break;
4572 case ParsedAttr::AT_VectorCall:
4573 CC = CC_X86VectorCall;
4574 break;
4575 case ParsedAttr::AT_AArch64VectorPcs:
4576 CC = CC_AArch64VectorCall;
4577 break;
4578 case ParsedAttr::AT_RegCall:
4579 CC = CC_X86RegCall;
4580 break;
4581 case ParsedAttr::AT_MSABI:
4582 CC = Context.getTargetInfo().getTriple().isOSWindows() ? CC_C :
4583 CC_Win64;
4584 break;
4585 case ParsedAttr::AT_SysVABI:
4586 CC = Context.getTargetInfo().getTriple().isOSWindows() ? CC_X86_64SysV :
4587 CC_C;
4588 break;
4589 case ParsedAttr::AT_Pcs: {
4590 StringRef StrRef;
4591 if (!checkStringLiteralArgumentAttr(Attrs, 0, StrRef)) {
4592 Attrs.setInvalid();
4593 return true;
4594 }
4595 if (StrRef == "aapcs") {
4596 CC = CC_AAPCS;
4597 break;
4598 } else if (StrRef == "aapcs-vfp") {
4599 CC = CC_AAPCS_VFP;
4600 break;
4601 }
4602
4603 Attrs.setInvalid();
4604 Diag(Attrs.getLoc(), diag::err_invalid_pcs);
4605 return true;
4606 }
4607 case ParsedAttr::AT_IntelOclBicc:
4608 CC = CC_IntelOclBicc;
4609 break;
4610 case ParsedAttr::AT_PreserveMost:
4611 CC = CC_PreserveMost;
4612 break;
4613 case ParsedAttr::AT_PreserveAll:
4614 CC = CC_PreserveAll;
4615 break;
4616 default: llvm_unreachable("unexpected attribute kind")::llvm::llvm_unreachable_internal("unexpected attribute kind"
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 4616)
;
4617 }
4618
4619 TargetInfo::CallingConvCheckResult A = TargetInfo::CCCR_OK;
4620 const TargetInfo &TI = Context.getTargetInfo();
4621 // CUDA functions may have host and/or device attributes which indicate
4622 // their targeted execution environment, therefore the calling convention
4623 // of functions in CUDA should be checked against the target deduced based
4624 // on their host/device attributes.
4625 if (LangOpts.CUDA) {
4626 auto *Aux = Context.getAuxTargetInfo();
4627 auto CudaTarget = IdentifyCUDATarget(FD);
4628 bool CheckHost = false, CheckDevice = false;
4629 switch (CudaTarget) {
4630 case CFT_HostDevice:
4631 CheckHost = true;
4632 CheckDevice = true;
4633 break;
4634 case CFT_Host:
4635 CheckHost = true;
4636 break;
4637 case CFT_Device:
4638 case CFT_Global:
4639 CheckDevice = true;
4640 break;
4641 case CFT_InvalidTarget:
4642 llvm_unreachable("unexpected cuda target")::llvm::llvm_unreachable_internal("unexpected cuda target", "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 4642)
;
4643 }
4644 auto *HostTI = LangOpts.CUDAIsDevice ? Aux : &TI;
4645 auto *DeviceTI = LangOpts.CUDAIsDevice ? &TI : Aux;
4646 if (CheckHost && HostTI)
4647 A = HostTI->checkCallingConvention(CC);
4648 if (A == TargetInfo::CCCR_OK && CheckDevice && DeviceTI)
4649 A = DeviceTI->checkCallingConvention(CC);
4650 } else {
4651 A = TI.checkCallingConvention(CC);
4652 }
4653 if (A != TargetInfo::CCCR_OK) {
4654 if (A == TargetInfo::CCCR_Warning)
4655 Diag(Attrs.getLoc(), diag::warn_cconv_ignored)
4656 << Attrs << (int)CallingConventionIgnoredReason::ForThisTarget;
4657
4658 // This convention is not valid for the target. Use the default function or
4659 // method calling convention.
4660 bool IsCXXMethod = false, IsVariadic = false;
4661 if (FD) {
4662 IsCXXMethod = FD->isCXXInstanceMember();
4663 IsVariadic = FD->isVariadic();
4664 }
4665 CC = Context.getDefaultCallingConvention(IsVariadic, IsCXXMethod);
4666 }
4667
4668 Attrs.setProcessingCache((unsigned) CC);
4669 return false;
4670}
4671
4672/// Pointer-like types in the default address space.
4673static bool isValidSwiftContextType(QualType Ty) {
4674 if (!Ty->hasPointerRepresentation())
4675 return Ty->isDependentType();
4676 return Ty->getPointeeType().getAddressSpace() == LangAS::Default;
4677}
4678
4679/// Pointers and references in the default address space.
4680static bool isValidSwiftIndirectResultType(QualType Ty) {
4681 if (const auto *PtrType = Ty->getAs<PointerType>()) {
4682 Ty = PtrType->getPointeeType();
4683 } else if (const auto *RefType = Ty->getAs<ReferenceType>()) {
4684 Ty = RefType->getPointeeType();
4685 } else {
4686 return Ty->isDependentType();
4687 }
4688 return Ty.getAddressSpace() == LangAS::Default;
4689}
4690
4691/// Pointers and references to pointers in the default address space.
4692static bool isValidSwiftErrorResultType(QualType Ty) {
4693 if (const auto *PtrType = Ty->getAs<PointerType>()) {
4694 Ty = PtrType->getPointeeType();
4695 } else if (const auto *RefType = Ty->getAs<ReferenceType>()) {
4696 Ty = RefType->getPointeeType();
4697 } else {
4698 return Ty->isDependentType();
4699 }
4700 if (!Ty.getQualifiers().empty())
4701 return false;
4702 return isValidSwiftContextType(Ty);
4703}
4704
4705static void handleParameterABIAttr(Sema &S, Decl *D, const ParsedAttr &Attrs,
4706 ParameterABI Abi) {
4707 S.AddParameterABIAttr(Attrs.getRange(), D, Abi,
4708 Attrs.getAttributeSpellingListIndex());
4709}
4710
4711void Sema::AddParameterABIAttr(SourceRange range, Decl *D, ParameterABI abi,
4712 unsigned spellingIndex) {
4713
4714 QualType type = cast<ParmVarDecl>(D)->getType();
4715
4716 if (auto existingAttr = D->getAttr<ParameterABIAttr>()) {
4717 if (existingAttr->getABI() != abi) {
4718 Diag(range.getBegin(), diag::err_attributes_are_not_compatible)
4719 << getParameterABISpelling(abi) << existingAttr;
4720 Diag(existingAttr->getLocation(), diag::note_conflicting_attribute);
4721 return;
4722 }
4723 }
4724
4725 switch (abi) {
4726 case ParameterABI::Ordinary:
4727 llvm_unreachable("explicit attribute for ordinary parameter ABI?")::llvm::llvm_unreachable_internal("explicit attribute for ordinary parameter ABI?"
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 4727)
;
4728
4729 case ParameterABI::SwiftContext:
4730 if (!isValidSwiftContextType(type)) {
4731 Diag(range.getBegin(), diag::err_swift_abi_parameter_wrong_type)
4732 << getParameterABISpelling(abi)
4733 << /*pointer to pointer */ 0 << type;
4734 }
4735 D->addAttr(::new (Context)
4736 SwiftContextAttr(range, Context, spellingIndex));
4737 return;
4738
4739 case ParameterABI::SwiftErrorResult:
4740 if (!isValidSwiftErrorResultType(type)) {
4741 Diag(range.getBegin(), diag::err_swift_abi_parameter_wrong_type)
4742 << getParameterABISpelling(abi)
4743 << /*pointer to pointer */ 1 << type;
4744 }
4745 D->addAttr(::new (Context)
4746 SwiftErrorResultAttr(range, Context, spellingIndex));
4747 return;
4748
4749 case ParameterABI::SwiftIndirectResult:
4750 if (!isValidSwiftIndirectResultType(type)) {
4751 Diag(range.getBegin(), diag::err_swift_abi_parameter_wrong_type)
4752 << getParameterABISpelling(abi)
4753 << /*pointer*/ 0 << type;
4754 }
4755 D->addAttr(::new (Context)
4756 SwiftIndirectResultAttr(range, Context, spellingIndex));
4757 return;
4758 }
4759 llvm_unreachable("bad parameter ABI attribute")::llvm::llvm_unreachable_internal("bad parameter ABI attribute"
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 4759)
;
4760}
4761
4762/// Checks a regparm attribute, returning true if it is ill-formed and
4763/// otherwise setting numParams to the appropriate value.
4764bool Sema::CheckRegparmAttr(const ParsedAttr &AL, unsigned &numParams) {
4765 if (AL.isInvalid())
4766 return true;
4767
4768 if (!checkAttributeNumArgs(*this, AL, 1)) {
4769 AL.setInvalid();
4770 return true;
4771 }
4772
4773 uint32_t NP;
4774 Expr *NumParamsExpr = AL.getArgAsExpr(0);
4775 if (!checkUInt32Argument(*this, AL, NumParamsExpr, NP)) {
4776 AL.setInvalid();
4777 return true;
4778 }
4779
4780 if (Context.getTargetInfo().getRegParmMax() == 0) {
4781 Diag(AL.getLoc(), diag::err_attribute_regparm_wrong_platform)
4782 << NumParamsExpr->getSourceRange();
4783 AL.setInvalid();
4784 return true;
4785 }
4786
4787 numParams = NP;
4788 if (numParams > Context.getTargetInfo().getRegParmMax()) {
4789 Diag(AL.getLoc(), diag::err_attribute_regparm_invalid_number)
4790 << Context.getTargetInfo().getRegParmMax() << NumParamsExpr->getSourceRange();
4791 AL.setInvalid();
4792 return true;
4793 }
4794
4795 return false;
4796}
4797
4798// Checks whether an argument of launch_bounds attribute is
4799// acceptable, performs implicit conversion to Rvalue, and returns
4800// non-nullptr Expr result on success. Otherwise, it returns nullptr
4801// and may output an error.
4802static Expr *makeLaunchBoundsArgExpr(Sema &S, Expr *E,
4803 const CUDALaunchBoundsAttr &AL,
4804 const unsigned Idx) {
4805 if (S.DiagnoseUnexpandedParameterPack(E))
4806 return nullptr;
4807
4808 // Accept template arguments for now as they depend on something else.
4809 // We'll get to check them when they eventually get instantiated.
4810 if (E->isValueDependent())
4811 return E;
4812
4813 llvm::APSInt I(64);
4814 if (!E->isIntegerConstantExpr(I, S.Context)) {
4815 S.Diag(E->getExprLoc(), diag::err_attribute_argument_n_type)
4816 << &AL << Idx << AANT_ArgumentIntegerConstant << E->getSourceRange();
4817 return nullptr;
4818 }
4819 // Make sure we can fit it in 32 bits.
4820 if (!I.isIntN(32)) {
4821 S.Diag(E->getExprLoc(), diag::err_ice_too_large) << I.toString(10, false)
4822 << 32 << /* Unsigned */ 1;
4823 return nullptr;
4824 }
4825 if (I < 0)
4826 S.Diag(E->getExprLoc(), diag::warn_attribute_argument_n_negative)
4827 << &AL << Idx << E->getSourceRange();
4828
4829 // We may need to perform implicit conversion of the argument.
4830 InitializedEntity Entity = InitializedEntity::InitializeParameter(
4831 S.Context, S.Context.getConstType(S.Context.IntTy), /*consume*/ false);
4832 ExprResult ValArg = S.PerformCopyInitialization(Entity, SourceLocation(), E);
4833 assert(!ValArg.isInvalid() &&((!ValArg.isInvalid() && "Unexpected PerformCopyInitialization() failure."
) ? static_cast<void> (0) : __assert_fail ("!ValArg.isInvalid() && \"Unexpected PerformCopyInitialization() failure.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 4834, __PRETTY_FUNCTION__))
4834 "Unexpected PerformCopyInitialization() failure.")((!ValArg.isInvalid() && "Unexpected PerformCopyInitialization() failure."
) ? static_cast<void> (0) : __assert_fail ("!ValArg.isInvalid() && \"Unexpected PerformCopyInitialization() failure.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 4834, __PRETTY_FUNCTION__))
;
4835
4836 return ValArg.getAs<Expr>();
4837}
4838
4839void Sema::AddLaunchBoundsAttr(SourceRange AttrRange, Decl *D, Expr *MaxThreads,
4840 Expr *MinBlocks, unsigned SpellingListIndex) {
4841 CUDALaunchBoundsAttr TmpAttr(AttrRange, Context, MaxThreads, MinBlocks,
4842 SpellingListIndex);
4843 MaxThreads = makeLaunchBoundsArgExpr(*this, MaxThreads, TmpAttr, 0);
4844 if (MaxThreads == nullptr)
4845 return;
4846
4847 if (MinBlocks) {
4848 MinBlocks = makeLaunchBoundsArgExpr(*this, MinBlocks, TmpAttr, 1);
4849 if (MinBlocks == nullptr)
4850 return;
4851 }
4852
4853 D->addAttr(::new (Context) CUDALaunchBoundsAttr(
4854 AttrRange, Context, MaxThreads, MinBlocks, SpellingListIndex));
4855}
4856
4857static void handleLaunchBoundsAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4858 if (!checkAttributeAtLeastNumArgs(S, AL, 1) ||
4859 !checkAttributeAtMostNumArgs(S, AL, 2))
4860 return;
4861
4862 S.AddLaunchBoundsAttr(AL.getRange(), D, AL.getArgAsExpr(0),
4863 AL.getNumArgs() > 1 ? AL.getArgAsExpr(1) : nullptr,
4864 AL.getAttributeSpellingListIndex());
4865}
4866
4867static void handleArgumentWithTypeTagAttr(Sema &S, Decl *D,
4868 const ParsedAttr &AL) {
4869 if (!AL.isArgIdent(0)) {
4870 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
4871 << AL << /* arg num = */ 1 << AANT_ArgumentIdentifier;
4872 return;
4873 }
4874
4875 ParamIdx ArgumentIdx;
4876 if (!checkFunctionOrMethodParameterIndex(S, D, AL, 2, AL.getArgAsExpr(1),
4877 ArgumentIdx))
4878 return;
4879
4880 ParamIdx TypeTagIdx;
4881 if (!checkFunctionOrMethodParameterIndex(S, D, AL, 3, AL.getArgAsExpr(2),
4882 TypeTagIdx))
4883 return;
4884
4885 bool IsPointer = AL.getName()->getName() == "pointer_with_type_tag";
4886 if (IsPointer) {
4887 // Ensure that buffer has a pointer type.
4888 unsigned ArgumentIdxAST = ArgumentIdx.getASTIndex();
4889 if (ArgumentIdxAST >= getFunctionOrMethodNumParams(D) ||
4890 !getFunctionOrMethodParamType(D, ArgumentIdxAST)->isPointerType())
4891 S.Diag(AL.getLoc(), diag::err_attribute_pointers_only) << AL << 0;
4892 }
4893
4894 D->addAttr(::new (S.Context) ArgumentWithTypeTagAttr(
4895 AL.getRange(), S.Context, AL.getArgAsIdent(0)->Ident, ArgumentIdx,
4896 TypeTagIdx, IsPointer, AL.getAttributeSpellingListIndex()));
4897}
4898
4899static void handleTypeTagForDatatypeAttr(Sema &S, Decl *D,
4900 const ParsedAttr &AL) {
4901 if (!AL.isArgIdent(0)) {
4902 S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
4903 << AL << 1 << AANT_ArgumentIdentifier;
4904 return;
4905 }
4906
4907 if (!checkAttributeNumArgs(S, AL, 1))
4908 return;
4909
4910 if (!isa<VarDecl>(D)) {
4911 S.Diag(AL.getLoc(), diag::err_attribute_wrong_decl_type)
4912 << AL << ExpectedVariable;
4913 return;
4914 }
4915
4916 IdentifierInfo *PointerKind = AL.getArgAsIdent(0)->Ident;
4917 TypeSourceInfo *MatchingCTypeLoc = nullptr;
4918 S.GetTypeFromParser(AL.getMatchingCType(), &MatchingCTypeLoc);
4919 assert(MatchingCTypeLoc && "no type source info for attribute argument")((MatchingCTypeLoc && "no type source info for attribute argument"
) ? static_cast<void> (0) : __assert_fail ("MatchingCTypeLoc && \"no type source info for attribute argument\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 4919, __PRETTY_FUNCTION__))
;
4920
4921 D->addAttr(::new (S.Context)
4922 TypeTagForDatatypeAttr(AL.getRange(), S.Context, PointerKind,
4923 MatchingCTypeLoc,
4924 AL.getLayoutCompatible(),
4925 AL.getMustBeNull(),
4926 AL.getAttributeSpellingListIndex()));
4927}
4928
4929static void handleXRayLogArgsAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
4930 ParamIdx ArgCount;
4931
4932 if (!checkFunctionOrMethodParameterIndex(S, D, AL, 1, AL.getArgAsExpr(0),
4933 ArgCount,
4934 true /* CanIndexImplicitThis */))
4935 return;
4936
4937 // ArgCount isn't a parameter index [0;n), it's a count [1;n]
4938 D->addAttr(::new (S.Context) XRayLogArgsAttr(
4939 AL.getRange(), S.Context, ArgCount.getSourceIndex(),
4940 AL.getAttributeSpellingListIndex()));
4941}
4942
4943//===----------------------------------------------------------------------===//
4944// Checker-specific attribute handlers.
4945//===----------------------------------------------------------------------===//
4946static bool isValidSubjectOfNSReturnsRetainedAttribute(QualType QT) {
4947 return QT->isDependentType() || QT->isObjCRetainableType();
4948}
4949
4950static bool isValidSubjectOfNSAttribute(QualType QT) {
4951 return QT->isDependentType() || QT->isObjCObjectPointerType() ||
4952 QT->isObjCNSObjectType();
4953}
4954
4955static bool isValidSubjectOfCFAttribute(QualType QT) {
4956 return QT->isDependentType() || QT->isPointerType() ||
4957 isValidSubjectOfNSAttribute(QT);
4958}
4959
4960static bool isValidSubjectOfOSAttribute(QualType QT) {
4961 if (QT->isDependentType())
4962 return true;
4963 QualType PT = QT->getPointeeType();
4964 return !PT.isNull() && PT->getAsCXXRecordDecl() != nullptr;
4965}
4966
4967void Sema::AddXConsumedAttr(Decl *D, SourceRange SR, unsigned SpellingIndex,
4968 RetainOwnershipKind K,
4969 bool IsTemplateInstantiation) {
4970 ValueDecl *VD = cast<ValueDecl>(D);
4971 switch (K) {
4972 case RetainOwnershipKind::OS:
4973 handleSimpleAttributeOrDiagnose<OSConsumedAttr>(
4974 *this, VD, SR, SpellingIndex, isValidSubjectOfOSAttribute(VD->getType()),
4975 diag::warn_ns_attribute_wrong_parameter_type,
4976 /*ExtraArgs=*/SR, "os_consumed", /*pointers*/ 1);
4977 return;
4978 case RetainOwnershipKind::NS:
4979 handleSimpleAttributeOrDiagnose<NSConsumedAttr>(
4980 *this, VD, SR, SpellingIndex, isValidSubjectOfNSAttribute(VD->getType()),
4981
4982 // These attributes are normally just advisory, but in ARC, ns_consumed
4983 // is significant. Allow non-dependent code to contain inappropriate
4984 // attributes even in ARC, but require template instantiations to be
4985 // set up correctly.
4986 ((IsTemplateInstantiation && getLangOpts().ObjCAutoRefCount)
4987 ? diag::err_ns_attribute_wrong_parameter_type
4988 : diag::warn_ns_attribute_wrong_parameter_type),
4989 /*ExtraArgs=*/SR, "ns_consumed", /*objc pointers*/ 0);
4990 return;
4991 case RetainOwnershipKind::CF:
4992 handleSimpleAttributeOrDiagnose<CFConsumedAttr>(
4993 *this, VD, SR, SpellingIndex,
4994 isValidSubjectOfCFAttribute(VD->getType()),
4995 diag::warn_ns_attribute_wrong_parameter_type,
4996 /*ExtraArgs=*/SR, "cf_consumed", /*pointers*/1);
4997 return;
4998 }
4999}
5000
5001static Sema::RetainOwnershipKind
5002parsedAttrToRetainOwnershipKind(const ParsedAttr &AL) {
5003 switch (AL.getKind()) {
5004 case ParsedAttr::AT_CFConsumed:
5005 case ParsedAttr::AT_CFReturnsRetained:
5006 case ParsedAttr::AT_CFReturnsNotRetained:
5007 return Sema::RetainOwnershipKind::CF;
5008 case ParsedAttr::AT_OSConsumesThis:
5009 case ParsedAttr::AT_OSConsumed:
5010 case ParsedAttr::AT_OSReturnsRetained:
5011 case ParsedAttr::AT_OSReturnsNotRetained:
5012 case ParsedAttr::AT_OSReturnsRetainedOnZero:
5013 case ParsedAttr::AT_OSReturnsRetainedOnNonZero:
5014 return Sema::RetainOwnershipKind::OS;
5015 case ParsedAttr::AT_NSConsumesSelf:
5016 case ParsedAttr::AT_NSConsumed:
5017 case ParsedAttr::AT_NSReturnsRetained:
5018 case ParsedAttr::AT_NSReturnsNotRetained:
5019 case ParsedAttr::AT_NSReturnsAutoreleased:
5020 return Sema::RetainOwnershipKind::NS;
5021 default:
5022 llvm_unreachable("Wrong argument supplied")::llvm::llvm_unreachable_internal("Wrong argument supplied", "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 5022)
;
5023 }
5024}
5025
5026bool Sema::checkNSReturnsRetainedReturnType(SourceLocation Loc, QualType QT) {
5027 if (isValidSubjectOfNSReturnsRetainedAttribute(QT))
5028 return false;
5029
5030 Diag(Loc, diag::warn_ns_attribute_wrong_return_type)
5031 << "'ns_returns_retained'" << 0 << 0;
5032 return true;
5033}
5034
5035/// \return whether the parameter is a pointer to OSObject pointer.
5036static bool isValidOSObjectOutParameter(const Decl *D) {
5037 const auto *PVD = dyn_cast<ParmVarDecl>(D);
5038 if (!PVD)
5039 return false;
5040 QualType QT = PVD->getType();
5041 QualType PT = QT->getPointeeType();
5042 return !PT.isNull() && isValidSubjectOfOSAttribute(PT);
5043}
5044
5045static void handleXReturnsXRetainedAttr(Sema &S, Decl *D,
5046 const ParsedAttr &AL) {
5047 QualType ReturnType;
5048 Sema::RetainOwnershipKind K = parsedAttrToRetainOwnershipKind(AL);
5049
5050 if (const auto *MD = dyn_cast<ObjCMethodDecl>(D)) {
5051 ReturnType = MD->getReturnType();
5052 } else if (S.getLangOpts().ObjCAutoRefCount && hasDeclarator(D) &&
5053 (AL.getKind() == ParsedAttr::AT_NSReturnsRetained)) {
5054 return; // ignore: was handled as a type attribute
5055 } else if (const auto *PD = dyn_cast<ObjCPropertyDecl>(D)) {
5056 ReturnType = PD->getType();
5057 } else if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
5058 ReturnType = FD->getReturnType();
5059 } else if (const auto *Param = dyn_cast<ParmVarDecl>(D)) {
5060 // Attributes on parameters are used for out-parameters,
5061 // passed as pointers-to-pointers.
5062 unsigned DiagID = K == Sema::RetainOwnershipKind::CF
5063 ? /*pointer-to-CF-pointer*/2
5064 : /*pointer-to-OSObject-pointer*/3;
5065 ReturnType = Param->getType()->getPointeeType();
5066 if (ReturnType.isNull()) {
5067 S.Diag(D->getBeginLoc(), diag::warn_ns_attribute_wrong_parameter_type)
5068 << AL << DiagID << AL.getRange();
5069 return;
5070 }
5071 } else if (AL.isUsedAsTypeAttr()) {
5072 return;
5073 } else {
5074 AttributeDeclKind ExpectedDeclKind;
5075 switch (AL.getKind()) {
5076 default: llvm_unreachable("invalid ownership attribute")::llvm::llvm_unreachable_internal("invalid ownership attribute"
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 5076)
;
5077 case ParsedAttr::AT_NSReturnsRetained:
5078 case ParsedAttr::AT_NSReturnsAutoreleased:
5079 case ParsedAttr::AT_NSReturnsNotRetained:
5080 ExpectedDeclKind = ExpectedFunctionOrMethod;
5081 break;
5082
5083 case ParsedAttr::AT_OSReturnsRetained:
5084 case ParsedAttr::AT_OSReturnsNotRetained:
5085 case ParsedAttr::AT_CFReturnsRetained:
5086 case ParsedAttr::AT_CFReturnsNotRetained:
5087 ExpectedDeclKind = ExpectedFunctionMethodOrParameter;
5088 break;
5089 }
5090 S.Diag(D->getBeginLoc(), diag::warn_attribute_wrong_decl_type)
5091 << AL.getRange() << AL << ExpectedDeclKind;
5092 return;
5093 }
5094
5095 bool TypeOK;
5096 bool Cf;
5097 unsigned ParmDiagID = 2; // Pointer-to-CF-pointer
5098 switch (AL.getKind()) {
5099 default: llvm_unreachable("invalid ownership attribute")::llvm::llvm_unreachable_internal("invalid ownership attribute"
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 5099)
;
5100 case ParsedAttr::AT_NSReturnsRetained:
5101 TypeOK = isValidSubjectOfNSReturnsRetainedAttribute(ReturnType);
5102 Cf = false;
5103 break;
5104
5105 case ParsedAttr::AT_NSReturnsAutoreleased:
5106 case ParsedAttr::AT_NSReturnsNotRetained:
5107 TypeOK = isValidSubjectOfNSAttribute(ReturnType);
5108 Cf = false;
5109 break;
5110
5111 case ParsedAttr::AT_CFReturnsRetained:
5112 case ParsedAttr::AT_CFReturnsNotRetained:
5113 TypeOK = isValidSubjectOfCFAttribute(ReturnType);
5114 Cf = true;
5115 break;
5116
5117 case ParsedAttr::AT_OSReturnsRetained:
5118 case ParsedAttr::AT_OSReturnsNotRetained:
5119 TypeOK = isValidSubjectOfOSAttribute(ReturnType);
5120 Cf = true;
5121 ParmDiagID = 3; // Pointer-to-OSObject-pointer
5122 break;
5123 }
5124
5125 if (!TypeOK) {
5126 if (AL.isUsedAsTypeAttr())
5127 return;
5128
5129 if (isa<ParmVarDecl>(D)) {
5130 S.Diag(D->getBeginLoc(), diag::warn_ns_attribute_wrong_parameter_type)
5131 << AL << ParmDiagID << AL.getRange();
5132 } else {
5133 // Needs to be kept in sync with warn_ns_attribute_wrong_return_type.
5134 enum : unsigned {
5135 Function,
5136 Method,
5137 Property
5138 } SubjectKind = Function;
5139 if (isa<ObjCMethodDecl>(D))
5140 SubjectKind = Method;
5141 else if (isa<ObjCPropertyDecl>(D))
5142 SubjectKind = Property;
5143 S.Diag(D->getBeginLoc(), diag::warn_ns_attribute_wrong_return_type)
5144 << AL << SubjectKind << Cf << AL.getRange();
5145 }
5146 return;
5147 }
5148
5149 switch (AL.getKind()) {
5150 default:
5151 llvm_unreachable("invalid ownership attribute")::llvm::llvm_unreachable_internal("invalid ownership attribute"
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 5151)
;
5152 case ParsedAttr::AT_NSReturnsAutoreleased:
5153 handleSimpleAttribute<NSReturnsAutoreleasedAttr>(S, D, AL);
5154 return;
5155 case ParsedAttr::AT_CFReturnsNotRetained:
5156 handleSimpleAttribute<CFReturnsNotRetainedAttr>(S, D, AL);
5157 return;
5158 case ParsedAttr::AT_NSReturnsNotRetained:
5159 handleSimpleAttribute<NSReturnsNotRetainedAttr>(S, D, AL);
5160 return;
5161 case ParsedAttr::AT_CFReturnsRetained:
5162 handleSimpleAttribute<CFReturnsRetainedAttr>(S, D, AL);
5163 return;
5164 case ParsedAttr::AT_NSReturnsRetained:
5165 handleSimpleAttribute<NSReturnsRetainedAttr>(S, D, AL);
5166 return;
5167 case ParsedAttr::AT_OSReturnsRetained:
5168 handleSimpleAttribute<OSReturnsRetainedAttr>(S, D, AL);
5169 return;
5170 case ParsedAttr::AT_OSReturnsNotRetained:
5171 handleSimpleAttribute<OSReturnsNotRetainedAttr>(S, D, AL);
5172 return;
5173 };
5174}
5175
5176static void handleObjCReturnsInnerPointerAttr(Sema &S, Decl *D,
5177 const ParsedAttr &Attrs) {
5178 const int EP_ObjCMethod = 1;
5179 const int EP_ObjCProperty = 2;
5180
5181 SourceLocation loc = Attrs.getLoc();
5182 QualType resultType;
5183 if (isa<ObjCMethodDecl>(D))
5184 resultType = cast<ObjCMethodDecl>(D)->getReturnType();
5185 else
5186 resultType = cast<ObjCPropertyDecl>(D)->getType();
5187
5188 if (!resultType->isReferenceType() &&
5189 (!resultType->isPointerType() || resultType->isObjCRetainableType())) {
5190 S.Diag(D->getBeginLoc(), diag::warn_ns_attribute_wrong_return_type)
5191 << SourceRange(loc) << Attrs
5192 << (isa<ObjCMethodDecl>(D) ? EP_ObjCMethod : EP_ObjCProperty)
5193 << /*non-retainable pointer*/ 2;
5194
5195 // Drop the attribute.
5196 return;
5197 }
5198
5199 D->addAttr(::new (S.Context) ObjCReturnsInnerPointerAttr(
5200 Attrs.getRange(), S.Context, Attrs.getAttributeSpellingListIndex()));
5201}
5202
5203static void handleObjCRequiresSuperAttr(Sema &S, Decl *D,
5204 const ParsedAttr &Attrs) {
5205 const auto *Method = cast<ObjCMethodDecl>(D);
5206
5207 const DeclContext *DC = Method->getDeclContext();
5208 if (const auto *PDecl = dyn_cast_or_null<ObjCProtocolDecl>(DC)) {
5209 S.Diag(D->getBeginLoc(), diag::warn_objc_requires_super_protocol) << Attrs
5210 << 0;
5211 S.Diag(PDecl->getLocation(), diag::note_protocol_decl);
5212 return;
5213 }
5214 if (Method->getMethodFamily() == OMF_dealloc) {
5215 S.Diag(D->getBeginLoc(), diag::warn_objc_requires_super_protocol) << Attrs
5216 << 1;
5217 return;
5218 }
5219
5220 D->addAttr(::new (S.Context) ObjCRequiresSuperAttr(
5221 Attrs.getRange(), S.Context, Attrs.getAttributeSpellingListIndex()));
5222}
5223
5224static void handleObjCBridgeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5225 IdentifierLoc *Parm = AL.isArgIdent(0) ? AL.getArgAsIdent(0) : nullptr;
5226
5227 if (!Parm) {
5228 S.Diag(D->getBeginLoc(), diag::err_objc_attr_not_id) << AL << 0;
5229 return;
5230 }
5231
5232 // Typedefs only allow objc_bridge(id) and have some additional checking.
5233 if (const auto *TD = dyn_cast<TypedefNameDecl>(D)) {
5234 if (!Parm->Ident->isStr("id")) {
5235 S.Diag(AL.getLoc(), diag::err_objc_attr_typedef_not_id) << AL;
5236 return;
5237 }
5238
5239 // Only allow 'cv void *'.
5240 QualType T = TD->getUnderlyingType();
5241 if (!T->isVoidPointerType()) {
5242 S.Diag(AL.getLoc(), diag::err_objc_attr_typedef_not_void_pointer);
5243 return;
5244 }
5245 }
5246
5247 D->addAttr(::new (S.Context)
5248 ObjCBridgeAttr(AL.getRange(), S.Context, Parm->Ident,
5249 AL.getAttributeSpellingListIndex()));
5250}
5251
5252static void handleObjCBridgeMutableAttr(Sema &S, Decl *D,
5253 const ParsedAttr &AL) {
5254 IdentifierLoc *Parm = AL.isArgIdent(0) ? AL.getArgAsIdent(0) : nullptr;
5255
5256 if (!Parm) {
5257 S.Diag(D->getBeginLoc(), diag::err_objc_attr_not_id) << AL << 0;
5258 return;
5259 }
5260
5261 D->addAttr(::new (S.Context)
5262 ObjCBridgeMutableAttr(AL.getRange(), S.Context, Parm->Ident,
5263 AL.getAttributeSpellingListIndex()));
5264}
5265
5266static void handleObjCBridgeRelatedAttr(Sema &S, Decl *D,
5267 const ParsedAttr &AL) {
5268 IdentifierInfo *RelatedClass =
5269 AL.isArgIdent(0) ? AL.getArgAsIdent(0)->Ident : nullptr;
5270 if (!RelatedClass) {
5271 S.Diag(D->getBeginLoc(), diag::err_objc_attr_not_id) << AL << 0;
5272 return;
5273 }
5274 IdentifierInfo *ClassMethod =
5275 AL.getArgAsIdent(1) ? AL.getArgAsIdent(1)->Ident : nullptr;
5276 IdentifierInfo *InstanceMethod =
5277 AL.getArgAsIdent(2) ? AL.getArgAsIdent(2)->Ident : nullptr;
5278 D->addAttr(::new (S.Context)
5279 ObjCBridgeRelatedAttr(AL.getRange(), S.Context, RelatedClass,
5280 ClassMethod, InstanceMethod,
5281 AL.getAttributeSpellingListIndex()));
5282}
5283
5284static void handleObjCDesignatedInitializer(Sema &S, Decl *D,
5285 const ParsedAttr &AL) {
5286 DeclContext *Ctx = D->getDeclContext();
5287
5288 // This attribute can only be applied to methods in interfaces or class
5289 // extensions.
5290 if (!isa<ObjCInterfaceDecl>(Ctx) &&
5291 !(isa<ObjCCategoryDecl>(Ctx) &&
5292 cast<ObjCCategoryDecl>(Ctx)->IsClassExtension())) {
5293 S.Diag(D->getLocation(), diag::err_designated_init_attr_non_init);
5294 return;
5295 }
5296
5297 ObjCInterfaceDecl *IFace;
5298 if (auto *CatDecl = dyn_cast<ObjCCategoryDecl>(Ctx))
5299 IFace = CatDecl->getClassInterface();
5300 else
5301 IFace = cast<ObjCInterfaceDecl>(Ctx);
5302
5303 if (!IFace)
5304 return;
5305
5306 IFace->setHasDesignatedInitializers();
5307 D->addAttr(::new (S.Context)
5308 ObjCDesignatedInitializerAttr(AL.getRange(), S.Context,
5309 AL.getAttributeSpellingListIndex()));
5310}
5311
5312static void handleObjCRuntimeName(Sema &S, Decl *D, const ParsedAttr &AL) {
5313 StringRef MetaDataName;
5314 if (!S.checkStringLiteralArgumentAttr(AL, 0, MetaDataName))
5315 return;
5316 D->addAttr(::new (S.Context)
5317 ObjCRuntimeNameAttr(AL.getRange(), S.Context,
5318 MetaDataName,
5319 AL.getAttributeSpellingListIndex()));
5320}
5321
5322// When a user wants to use objc_boxable with a union or struct
5323// but they don't have access to the declaration (legacy/third-party code)
5324// then they can 'enable' this feature with a typedef:
5325// typedef struct __attribute((objc_boxable)) legacy_struct legacy_struct;
5326static void handleObjCBoxable(Sema &S, Decl *D, const ParsedAttr &AL) {
5327 bool notify = false;
5328
5329 auto *RD = dyn_cast<RecordDecl>(D);
5330 if (RD && RD->getDefinition()) {
5331 RD = RD->getDefinition();
5332 notify = true;
5333 }
5334
5335 if (RD) {
5336 ObjCBoxableAttr *BoxableAttr = ::new (S.Context)
5337 ObjCBoxableAttr(AL.getRange(), S.Context,
5338 AL.getAttributeSpellingListIndex());
5339 RD->addAttr(BoxableAttr);
5340 if (notify) {
5341 // we need to notify ASTReader/ASTWriter about
5342 // modification of existing declaration
5343 if (ASTMutationListener *L = S.getASTMutationListener())
5344 L->AddedAttributeToRecord(BoxableAttr, RD);
5345 }
5346 }
5347}
5348
5349static void handleObjCOwnershipAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5350 if (hasDeclarator(D)) return;
5351
5352 S.Diag(D->getBeginLoc(), diag::err_attribute_wrong_decl_type)
5353 << AL.getRange() << AL << ExpectedVariable;
5354}
5355
5356static void handleObjCPreciseLifetimeAttr(Sema &S, Decl *D,
5357 const ParsedAttr &AL) {
5358 const auto *VD = cast<ValueDecl>(D);
5359 QualType QT = VD->getType();
5360
5361 if (!QT->isDependentType() &&
5362 !QT->isObjCLifetimeType()) {
5363 S.Diag(AL.getLoc(), diag::err_objc_precise_lifetime_bad_type)
5364 << QT;
5365 return;
5366 }
5367
5368 Qualifiers::ObjCLifetime Lifetime = QT.getObjCLifetime();
5369
5370 // If we have no lifetime yet, check the lifetime we're presumably
5371 // going to infer.
5372 if (Lifetime == Qualifiers::OCL_None && !QT->isDependentType())
5373 Lifetime = QT->getObjCARCImplicitLifetime();
5374
5375 switch (Lifetime) {
5376 case Qualifiers::OCL_None:
5377 assert(QT->isDependentType() &&((QT->isDependentType() && "didn't infer lifetime for non-dependent type?"
) ? static_cast<void> (0) : __assert_fail ("QT->isDependentType() && \"didn't infer lifetime for non-dependent type?\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 5378, __PRETTY_FUNCTION__))
5378 "didn't infer lifetime for non-dependent type?")((QT->isDependentType() && "didn't infer lifetime for non-dependent type?"
) ? static_cast<void> (0) : __assert_fail ("QT->isDependentType() && \"didn't infer lifetime for non-dependent type?\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclAttr.cpp"
, 5378, __PRETTY_FUNCTION__))
;
5379 break;
5380
5381 case Qualifiers::OCL_Weak: // meaningful
5382 case Qualifiers::OCL_Strong: // meaningful
5383 break;
5384
5385 case Qualifiers::OCL_ExplicitNone:
5386 case Qualifiers::OCL_Autoreleasing:
5387 S.Diag(AL.getLoc(), diag::warn_objc_precise_lifetime_meaningless)
5388 << (Lifetime == Qualifiers::OCL_Autoreleasing);
5389 break;
5390 }
5391
5392 D->addAttr(::new (S.Context)
5393 ObjCPreciseLifetimeAttr(AL.getRange(), S.Context,
5394 AL.getAttributeSpellingListIndex()));
5395}
5396
5397//===----------------------------------------------------------------------===//
5398// Microsoft specific attribute handlers.
5399//===----------------------------------------------------------------------===//
5400
5401UuidAttr *Sema::mergeUuidAttr(Decl *D, SourceRange Range,
5402 unsigned AttrSpellingListIndex, StringRef Uuid) {
5403 if (const auto *UA = D->getAttr<UuidAttr>()) {
5404 if (UA->getGuid().equals_lower(Uuid))
5405 return nullptr;
5406 Diag(UA->getLocation(), diag::err_mismatched_uuid);
5407 Diag(Range.getBegin(), diag::note_previous_uuid);
5408 D->dropAttr<UuidAttr>();
5409 }
5410
5411 return ::new (Context) UuidAttr(Range, Context, Uuid, AttrSpellingListIndex);
5412}
5413
5414static void handleUuidAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5415 if (!S.LangOpts.CPlusPlus) {
5416 S.Diag(AL.getLoc(), diag::err_attribute_not_supported_in_lang)
5417 << AL << AttributeLangSupport::C;
5418 return;
5419 }
5420
5421 StringRef StrRef;
5422 SourceLocation LiteralLoc;
5423 if (!S.checkStringLiteralArgumentAttr(AL, 0, StrRef, &LiteralLoc))
5424 return;
5425
5426 // GUID format is "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX" or
5427 // "{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}", normalize to the former.
5428 if (StrRef.size() == 38 && StrRef.front() == '{' && StrRef.back() == '}')
5429 StrRef = StrRef.drop_front().drop_back();
5430
5431 // Validate GUID length.
5432 if (StrRef.size() != 36) {
5433 S.Diag(LiteralLoc, diag::err_attribute_uuid_malformed_guid);
5434 return;
5435 }
5436
5437 for (unsigned i = 0; i < 36; ++i) {
5438 if (i == 8 || i == 13 || i == 18 || i == 23) {
5439 if (StrRef[i] != '-') {
5440 S.Diag(LiteralLoc, diag::err_attribute_uuid_malformed_guid);
5441 return;
5442 }
5443 } else if (!isHexDigit(StrRef[i])) {
5444 S.Diag(LiteralLoc, diag::err_attribute_uuid_malformed_guid);
5445 return;
5446 }
5447 }
5448
5449 // FIXME: It'd be nice to also emit a fixit removing uuid(...) (and, if it's
5450 // the only thing in the [] list, the [] too), and add an insertion of
5451 // __declspec(uuid(...)). But sadly, neither the SourceLocs of the commas
5452 // separating attributes nor of the [ and the ] are in the AST.
5453 // Cf "SourceLocations of attribute list delimiters - [[ ... , ... ]] etc"
5454 // on cfe-dev.
5455 if (AL.isMicrosoftAttribute()) // Check for [uuid(...)] spelling.
5456 S.Diag(AL.getLoc(), diag::warn_atl_uuid_deprecated);
5457
5458 UuidAttr *UA = S.mergeUuidAttr(D, AL.getRange(),
5459 AL.getAttributeSpellingListIndex(), StrRef);
5460 if (UA)
5461 D->addAttr(UA);
5462}
5463
5464static void handleMSInheritanceAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5465 if (!S.LangOpts.CPlusPlus) {
5466 S.Diag(AL.getLoc(), diag::err_attribute_not_supported_in_lang)
5467 << AL << AttributeLangSupport::C;
5468 return;
5469 }
5470 MSInheritanceAttr *IA = S.mergeMSInheritanceAttr(
5471 D, AL.getRange(), /*BestCase=*/true,
5472 AL.getAttributeSpellingListIndex(),
5473 (MSInheritanceAttr::Spelling)AL.getSemanticSpelling());
5474 if (IA) {
5475 D->addAttr(IA);
5476 S.Consumer.AssignInheritanceModel(cast<CXXRecordDecl>(D));
5477 }
5478}
5479
5480static void handleDeclspecThreadAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5481 const auto *VD = cast<VarDecl>(D);
5482 if (!S.Context.getTargetInfo().isTLSSupported()) {
5483 S.Diag(AL.getLoc(), diag::err_thread_unsupported);
5484 return;
5485 }
5486 if (VD->getTSCSpec() != TSCS_unspecified) {
5487 S.Diag(AL.getLoc(), diag::err_declspec_thread_on_thread_variable);
5488 return;
5489 }
5490 if (VD->hasLocalStorage()) {
5491 S.Diag(AL.getLoc(), diag::err_thread_non_global) << "__declspec(thread)";
5492 return;
5493 }
5494 D->addAttr(::new (S.Context) ThreadAttr(AL.getRange(), S.Context,
5495 AL.getAttributeSpellingListIndex()));
5496}
5497
5498static void handleAbiTagAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5499 SmallVector<StringRef, 4> Tags;
5500 for (unsigned I = 0, E = AL.getNumArgs(); I != E; ++I) {
5501 StringRef Tag;
5502 if (!S.checkStringLiteralArgumentAttr(AL, I, Tag))
5503 return;
5504 Tags.push_back(Tag);
5505 }
5506
5507 if (const auto *NS = dyn_cast<NamespaceDecl>(D)) {
5508 if (!NS->isInline()) {
5509 S.Diag(AL.getLoc(), diag::warn_attr_abi_tag_namespace) << 0;
5510 return;
5511 }
5512 if (NS->isAnonymousNamespace()) {
5513 S.Diag(AL.getLoc(), diag::warn_attr_abi_tag_namespace) << 1;
5514 return;
5515 }
5516 if (AL.getNumArgs() == 0)
5517 Tags.push_back(NS->getName());
5518 } else if (!checkAttributeAtLeastNumArgs(S, AL, 1))
5519 return;
5520
5521 // Store tags sorted and without duplicates.
5522 llvm::sort(Tags);
5523 Tags.erase(std::unique(Tags.begin(), Tags.end()), Tags.end());
5524
5525 D->addAttr(::new (S.Context)
5526 AbiTagAttr(AL.getRange(), S.Context, Tags.data(), Tags.size(),
5527 AL.getAttributeSpellingListIndex()));
5528}
5529
5530static void handleARMInterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5531 // Check the attribute arguments.
5532 if (AL.getNumArgs() > 1) {
5533 S.Diag(AL.getLoc(), diag::err_attribute_too_many_arguments) << AL << 1;
5534 return;
5535 }
5536
5537 StringRef Str;
5538 SourceLocation ArgLoc;
5539
5540 if (AL.getNumArgs() == 0)
5541 Str = "";
5542 else if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &ArgLoc))
5543 return;
5544
5545 ARMInterruptAttr::InterruptType Kind;
5546 if (!ARMInterruptAttr::ConvertStrToInterruptType(Str, Kind)) {
5547 S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported) << AL << Str
5548 << ArgLoc;
5549 return;
5550 }
5551
5552 unsigned Index = AL.getAttributeSpellingListIndex();
5553 D->addAttr(::new (S.Context)
5554 ARMInterruptAttr(AL.getLoc(), S.Context, Kind, Index));
5555}
5556
5557static void handleMSP430InterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5558 // MSP430 'interrupt' attribute is applied to
5559 // a function with no parameters and void return type.
5560 if (!isFunctionOrMethod(D)) {
5561 S.Diag(D->getLocation(), diag::warn_attribute_wrong_decl_type)
5562 << "'interrupt'" << ExpectedFunctionOrMethod;
5563 return;
5564 }
5565
5566 if (hasFunctionProto(D) && getFunctionOrMethodNumParams(D) != 0) {
5567 S.Diag(D->getLocation(), diag::warn_interrupt_attribute_invalid)
5568 << /*MSP430*/ 1 << 0;
5569 return;
5570 }
5571
5572 if (!getFunctionOrMethodResultType(D)->isVoidType()) {
5573 S.Diag(D->getLocation(), diag::warn_interrupt_attribute_invalid)
5574 << /*MSP430*/ 1 << 1;
5575 return;
5576 }
5577
5578 // The attribute takes one integer argument.
5579 if (!checkAttributeNumArgs(S, AL, 1))
5580 return;
5581
5582 if (!AL.isArgExpr(0)) {
5583 S.Diag(AL.getLoc(), diag::err_attribute_argument_type)
5584 << AL << AANT_ArgumentIntegerConstant;
5585 return;
5586 }
5587
5588 Expr *NumParamsExpr = static_cast<Expr *>(AL.getArgAsExpr(0));
5589 llvm::APSInt NumParams(32);
5590 if (!NumParamsExpr->isIntegerConstantExpr(NumParams, S.Context)) {
5591 S.Diag(AL.getLoc(), diag::err_attribute_argument_type)
5592 << AL << AANT_ArgumentIntegerConstant
5593 << NumParamsExpr->getSourceRange();
5594 return;
5595 }
5596 // The argument should be in range 0..63.
5597 unsigned Num = NumParams.getLimitedValue(255);
5598 if (Num > 63) {
5599 S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_bounds)
5600 << AL << (int)NumParams.getSExtValue()
5601 << NumParamsExpr->getSourceRange();
5602 return;
5603 }
5604
5605 D->addAttr(::new (S.Context)
5606 MSP430InterruptAttr(AL.getLoc(), S.Context, Num,
5607 AL.getAttributeSpellingListIndex()));
5608 D->addAttr(UsedAttr::CreateImplicit(S.Context));
5609}
5610
5611static void handleMipsInterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5612 // Only one optional argument permitted.
5613 if (AL.getNumArgs() > 1) {
5614 S.Diag(AL.getLoc(), diag::err_attribute_too_many_arguments) << AL << 1;
5615 return;
5616 }
5617
5618 StringRef Str;
5619 SourceLocation ArgLoc;
5620
5621 if (AL.getNumArgs() == 0)
5622 Str = "";
5623 else if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &ArgLoc))
5624 return;
5625
5626 // Semantic checks for a function with the 'interrupt' attribute for MIPS:
5627 // a) Must be a function.
5628 // b) Must have no parameters.
5629 // c) Must have the 'void' return type.
5630 // d) Cannot have the 'mips16' attribute, as that instruction set
5631 // lacks the 'eret' instruction.
5632 // e) The attribute itself must either have no argument or one of the
5633 // valid interrupt types, see [MipsInterruptDocs].
5634
5635 if (!isFunctionOrMethod(D)) {
5636 S.Diag(D->getLocation(), diag::warn_attribute_wrong_decl_type)
5637 << "'interrupt'" << ExpectedFunctionOrMethod;
5638 return;
5639 }
5640
5641 if (hasFunctionProto(D) && getFunctionOrMethodNumParams(D) != 0) {
5642 S.Diag(D->getLocation(), diag::warn_interrupt_attribute_invalid)
5643 << /*MIPS*/ 0 << 0;
5644 return;
5645 }
5646
5647 if (!getFunctionOrMethodResultType(D)->isVoidType()) {
5648 S.Diag(D->getLocation(), diag::warn_interrupt_attribute_invalid)
5649 << /*MIPS*/ 0 << 1;
5650 return;
5651 }
5652
5653 if (checkAttrMutualExclusion<Mips16Attr>(S, D, AL))
5654 return;
5655
5656 MipsInterruptAttr::InterruptType Kind;
5657 if (!MipsInterruptAttr::ConvertStrToInterruptType(Str, Kind)) {
5658 S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported)
5659 << AL << "'" + std::string(Str) + "'";
5660 return;
5661 }
5662
5663 D->addAttr(::new (S.Context) MipsInterruptAttr(
5664 AL.getLoc(), S.Context, Kind, AL.getAttributeSpellingListIndex()));
5665}
5666
5667static void handleAnyX86InterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5668 // Semantic checks for a function with the 'interrupt' attribute.
5669 // a) Must be a function.
5670 // b) Must have the 'void' return type.
5671 // c) Must take 1 or 2 arguments.
5672 // d) The 1st argument must be a pointer.
5673 // e) The 2nd argument (if any) must be an unsigned integer.
5674 if (!isFunctionOrMethod(D) || !hasFunctionProto(D) || isInstanceMethod(D) ||
5675 CXXMethodDecl::isStaticOverloadedOperator(
5676 cast<NamedDecl>(D)->getDeclName().getCXXOverloadedOperator())) {
5677 S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type)
5678 << AL << ExpectedFunctionWithProtoType;
5679 return;
5680 }
5681 // Interrupt handler must have void return type.
5682 if (!getFunctionOrMethodResultType(D)->isVoidType()) {
5683 S.Diag(getFunctionOrMethodResultSourceRange(D).getBegin(),
5684 diag::err_anyx86_interrupt_attribute)
5685 << (S.Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86
5686 ? 0
5687 : 1)
5688 << 0;
5689 return;
5690 }
5691 // Interrupt handler must have 1 or 2 parameters.
5692 unsigned NumParams = getFunctionOrMethodNumParams(D);
5693 if (NumParams < 1 || NumParams > 2) {
5694 S.Diag(D->getBeginLoc(), diag::err_anyx86_interrupt_attribute)
5695 << (S.Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86
5696 ? 0
5697 : 1)
5698 << 1;
5699 return;
5700 }
5701 // The first argument must be a pointer.
5702 if (!getFunctionOrMethodParamType(D, 0)->isPointerType()) {
5703 S.Diag(getFunctionOrMethodParamRange(D, 0).getBegin(),
5704 diag::err_anyx86_interrupt_attribute)
5705 << (S.Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86
5706 ? 0
5707 : 1)
5708 << 2;
5709 return;
5710 }
5711 // The second argument, if present, must be an unsigned integer.
5712 unsigned TypeSize =
5713 S.Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86_64
5714 ? 64
5715 : 32;
5716 if (NumParams == 2 &&
5717 (!getFunctionOrMethodParamType(D, 1)->isUnsignedIntegerType() ||
5718 S.Context.getTypeSize(getFunctionOrMethodParamType(D, 1)) != TypeSize)) {
5719 S.Diag(getFunctionOrMethodParamRange(D, 1).getBegin(),
5720 diag::err_anyx86_interrupt_attribute)
5721 << (S.Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86
5722 ? 0
5723 : 1)
5724 << 3 << S.Context.getIntTypeForBitwidth(TypeSize, /*Signed=*/false);
5725 return;
5726 }
5727 D->addAttr(::new (S.Context) AnyX86InterruptAttr(
5728 AL.getLoc(), S.Context, AL.getAttributeSpellingListIndex()));
5729 D->addAttr(UsedAttr::CreateImplicit(S.Context));
5730}
5731
5732static void handleAVRInterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5733 if (!isFunctionOrMethod(D)) {
5734 S.Diag(D->getLocation(), diag::warn_attribute_wrong_decl_type)
5735 << "'interrupt'" << ExpectedFunction;
5736 return;
5737 }
5738
5739 if (!checkAttributeNumArgs(S, AL, 0))
5740 return;
5741
5742 handleSimpleAttribute<AVRInterruptAttr>(S, D, AL);
5743}
5744
5745static void handleAVRSignalAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5746 if (!isFunctionOrMethod(D)) {
5747 S.Diag(D->getLocation(), diag::warn_attribute_wrong_decl_type)
5748 << "'signal'" << ExpectedFunction;
5749 return;
5750 }
5751
5752 if (!checkAttributeNumArgs(S, AL, 0))
5753 return;
5754
5755 handleSimpleAttribute<AVRSignalAttr>(S, D, AL);
5756}
5757
5758static void handleWebAssemblyImportModuleAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5759 if (!isFunctionOrMethod(D)) {
5760 S.Diag(D->getLocation(), diag::warn_attribute_wrong_decl_type)
5761 << "'import_module'" << ExpectedFunction;
5762 return;
5763 }
5764
5765 auto *FD = cast<FunctionDecl>(D);
5766 if (FD->isThisDeclarationADefinition()) {
5767 S.Diag(D->getLocation(), diag::err_alias_is_definition) << FD << 0;
5768 return;
5769 }
5770
5771 StringRef Str;
5772 SourceLocation ArgLoc;
5773 if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &ArgLoc))
5774 return;
5775
5776 FD->addAttr(::new (S.Context) WebAssemblyImportModuleAttr(
5777 AL.getRange(), S.Context, Str,
5778 AL.getAttributeSpellingListIndex()));
5779}
5780
5781static void handleWebAssemblyImportNameAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5782 if (!isFunctionOrMethod(D)) {
5783 S.Diag(D->getLocation(), diag::warn_attribute_wrong_decl_type)
5784 << "'import_name'" << ExpectedFunction;
5785 return;
5786 }
5787
5788 auto *FD = cast<FunctionDecl>(D);
5789 if (FD->isThisDeclarationADefinition()) {
5790 S.Diag(D->getLocation(), diag::err_alias_is_definition) << FD << 0;
5791 return;
5792 }
5793
5794 StringRef Str;
5795 SourceLocation ArgLoc;
5796 if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &ArgLoc))
5797 return;
5798
5799 FD->addAttr(::new (S.Context) WebAssemblyImportNameAttr(
5800 AL.getRange(), S.Context, Str,
5801 AL.getAttributeSpellingListIndex()));
5802}
5803
5804static void handleRISCVInterruptAttr(Sema &S, Decl *D,
5805 const ParsedAttr &AL) {
5806 // Warn about repeated attributes.
5807 if (const auto *A = D->getAttr<RISCVInterruptAttr>()) {
5808 S.Diag(AL.getRange().getBegin(),
5809 diag::warn_riscv_repeated_interrupt_attribute);
5810 S.Diag(A->getLocation(), diag::note_riscv_repeated_interrupt_attribute);
5811 return;
5812 }
5813
5814 // Check the attribute argument. Argument is optional.
5815 if (!checkAttributeAtMostNumArgs(S, AL, 1))
5816 return;
5817
5818 StringRef Str;
5819 SourceLocation ArgLoc;
5820
5821 // 'machine'is the default interrupt mode.
5822 if (AL.getNumArgs() == 0)
5823 Str = "machine";
5824 else if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &ArgLoc))
5825 return;
5826
5827 // Semantic checks for a function with the 'interrupt' attribute:
5828 // - Must be a function.
5829 // - Must have no parameters.
5830 // - Must have the 'void' return type.
5831 // - The attribute itself must either have no argument or one of the
5832 // valid interrupt types, see [RISCVInterruptDocs].
5833
5834 if (D->getFunctionType() == nullptr) {
5835 S.Diag(D->getLocation(), diag::warn_attribute_wrong_decl_type)
5836 << "'interrupt'" << ExpectedFunction;
5837 return;
5838 }
5839
5840 if (hasFunctionProto(D) && getFunctionOrMethodNumParams(D) != 0) {
5841 S.Diag(D->getLocation(), diag::warn_interrupt_attribute_invalid)
5842 << /*RISC-V*/ 2 << 0;
5843 return;
5844 }
5845
5846 if (!getFunctionOrMethodResultType(D)->isVoidType()) {
5847 S.Diag(D->getLocation(), diag::warn_interrupt_attribute_invalid)
5848 << /*RISC-V*/ 2 << 1;
5849 return;
5850 }
5851
5852 RISCVInterruptAttr::InterruptType Kind;
5853 if (!RISCVInterruptAttr::ConvertStrToInterruptType(Str, Kind)) {
5854 S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported) << AL << Str
5855 << ArgLoc;
5856 return;
5857 }
5858
5859 D->addAttr(::new (S.Context) RISCVInterruptAttr(
5860 AL.getLoc(), S.Context, Kind, AL.getAttributeSpellingListIndex()));
5861}
5862
5863static void handleInterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5864 // Dispatch the interrupt attribute based on the current target.
5865 switch (S.Context.getTargetInfo().getTriple().getArch()) {
5866 case llvm::Triple::msp430:
5867 handleMSP430InterruptAttr(S, D, AL);
5868 break;
5869 case llvm::Triple::mipsel:
5870 case llvm::Triple::mips:
5871 handleMipsInterruptAttr(S, D, AL);
5872 break;
5873 case llvm::Triple::x86:
5874 case llvm::Triple::x86_64:
5875 handleAnyX86InterruptAttr(S, D, AL);
5876 break;
5877 case llvm::Triple::avr:
5878 handleAVRInterruptAttr(S, D, AL);
5879 break;
5880 case llvm::Triple::riscv32:
5881 case llvm::Triple::riscv64:
5882 handleRISCVInterruptAttr(S, D, AL);
5883 break;
5884 default:
5885 handleARMInterruptAttr(S, D, AL);
5886 break;
5887 }
5888}
5889
5890static bool
5891checkAMDGPUFlatWorkGroupSizeArguments(Sema &S, Expr *MinExpr, Expr *MaxExpr,
5892 const AMDGPUFlatWorkGroupSizeAttr &Attr) {
5893 // Accept template arguments for now as they depend on something else.
5894 // We'll get to check them when they eventually get instantiated.
5895 if (MinExpr->isValueDependent() || MaxExpr->isValueDependent())
5896 return false;
5897
5898 uint32_t Min = 0;
5899 if (!checkUInt32Argument(S, Attr, MinExpr, Min, 0))
5900 return true;
5901
5902 uint32_t Max = 0;
5903 if (!checkUInt32Argument(S, Attr, MaxExpr, Max, 1))
5904 return true;
5905
5906 if (Min == 0 && Max != 0) {
5907 S.Diag(Attr.getLocation(), diag::err_attribute_argument_invalid)
5908 << &Attr << 0;
5909 return true;
5910 }
5911 if (Min > Max) {
5912 S.Diag(Attr.getLocation(), diag::err_attribute_argument_invalid)
5913 << &Attr << 1;
5914 return true;
5915 }
5916
5917 return false;
5918}
5919
5920void Sema::addAMDGPUFlatWorkGroupSizeAttr(SourceRange AttrRange, Decl *D,
5921 Expr *MinExpr, Expr *MaxExpr,
5922 unsigned SpellingListIndex) {
5923 AMDGPUFlatWorkGroupSizeAttr TmpAttr(AttrRange, Context, MinExpr, MaxExpr,
5924 SpellingListIndex);
5925
5926 if (checkAMDGPUFlatWorkGroupSizeArguments(*this, MinExpr, MaxExpr, TmpAttr))
5927 return;
5928
5929 D->addAttr(::new (Context) AMDGPUFlatWorkGroupSizeAttr(
5930 AttrRange, Context, MinExpr, MaxExpr, SpellingListIndex));
5931}
5932
5933static void handleAMDGPUFlatWorkGroupSizeAttr(Sema &S, Decl *D,
5934 const ParsedAttr &AL) {
5935 Expr *MinExpr = AL.getArgAsExpr(0);
5936 Expr *MaxExpr = AL.getArgAsExpr(1);
5937
5938 S.addAMDGPUFlatWorkGroupSizeAttr(AL.getRange(), D, MinExpr, MaxExpr,
5939 AL.getAttributeSpellingListIndex());
5940}
5941
5942static bool checkAMDGPUWavesPerEUArguments(Sema &S, Expr *MinExpr,
5943 Expr *MaxExpr,
5944 const AMDGPUWavesPerEUAttr &Attr) {
5945 if (S.DiagnoseUnexpandedParameterPack(MinExpr) ||
5946 (MaxExpr && S.DiagnoseUnexpandedParameterPack(MaxExpr)))
5947 return true;
5948
5949 // Accept template arguments for now as they depend on something else.
5950 // We'll get to check them when they eventually get instantiated.
5951 if (MinExpr->isValueDependent() || (MaxExpr && MaxExpr->isValueDependent()))
5952 return false;
5953
5954 uint32_t Min = 0;
5955 if (!checkUInt32Argument(S, Attr, MinExpr, Min, 0))
5956 return true;
5957
5958 uint32_t Max = 0;
5959 if (MaxExpr && !checkUInt32Argument(S, Attr, MaxExpr, Max, 1))
5960 return true;
5961
5962 if (Min == 0 && Max != 0) {
5963 S.Diag(Attr.getLocation(), diag::err_attribute_argument_invalid)
5964 << &Attr << 0;
5965 return true;
5966 }
5967 if (Max != 0 && Min > Max) {
5968 S.Diag(Attr.getLocation(), diag::err_attribute_argument_invalid)
5969 << &Attr << 1;
5970 return true;
5971 }
5972
5973 return false;
5974}
5975
5976void Sema::addAMDGPUWavesPerEUAttr(SourceRange AttrRange, Decl *D,
5977 Expr *MinExpr, Expr *MaxExpr,
5978 unsigned SpellingListIndex) {
5979 AMDGPUWavesPerEUAttr TmpAttr(AttrRange, Context, MinExpr, MaxExpr,
5980 SpellingListIndex);
5981
5982 if (checkAMDGPUWavesPerEUArguments(*this, MinExpr, MaxExpr, TmpAttr))
5983 return;
5984
5985 D->addAttr(::new (Context) AMDGPUWavesPerEUAttr(AttrRange, Context, MinExpr,
5986 MaxExpr, SpellingListIndex));
5987}
5988
5989static void handleAMDGPUWavesPerEUAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
5990 if (!checkAttributeAtLeastNumArgs(S, AL, 1) ||
5991 !checkAttributeAtMostNumArgs(S, AL, 2))
5992 return;
5993
5994 Expr *MinExpr = AL.getArgAsExpr(0);
5995 Expr *MaxExpr = (AL.getNumArgs() > 1) ? AL.getArgAsExpr(1) : nullptr;
5996
5997 S.addAMDGPUWavesPerEUAttr(AL.getRange(), D, MinExpr, MaxExpr,
5998 AL.getAttributeSpellingListIndex());
5999}
6000
6001static void handleAMDGPUNumSGPRAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
6002 uint32_t NumSGPR = 0;
6003 Expr *NumSGPRExpr = AL.getArgAsExpr(0);
6004 if (!checkUInt32Argument(S, AL, NumSGPRExpr, NumSGPR))
6005 return;
6006
6007 D->addAttr(::new (S.Context)
6008 AMDGPUNumSGPRAttr(AL.getLoc(), S.Context, NumSGPR,
6009 AL.getAttributeSpellingListIndex()));
6010}
6011
6012static void handleAMDGPUNumVGPRAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
6013 uint32_t NumVGPR = 0;
6014 Expr *NumVGPRExpr = AL.getArgAsExpr(0);
6015 if (!checkUInt32Argument(S, AL, NumVGPRExpr, NumVGPR))
6016 return;
6017
6018 D->addAttr(::new (S.Context)
6019 AMDGPUNumVGPRAttr(AL.getLoc(), S.Context, NumVGPR,
6020 AL.getAttributeSpellingListIndex()));
6021}
6022
6023static void handleX86ForceAlignArgPointerAttr(Sema &S, Decl *D,
6024 const ParsedAttr &AL) {
6025 // If we try to apply it to a function pointer, don't warn, but don't
6026 // do anything, either. It doesn't matter anyway, because there's nothing
6027 // special about calling a force_align_arg_pointer function.
6028 const auto *VD = dyn_cast<ValueDecl>(D);
6029 if (VD && VD->getType()->isFunctionPointerType())
6030 return;
6031 // Also don't warn on function pointer typedefs.
6032 const auto *TD = dyn_cast<TypedefNameDecl>(D);
6033 if (TD && (TD->getUnderlyingType()->isFunctionPointerType() ||
6034 TD->getUnderlyingType()->isFunctionType()))
6035 return;
6036 // Attribute can only be applied to function types.
6037 if (!isa<FunctionDecl>(D)) {
6038 S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type)
6039 << AL << ExpectedFunction;
6040 return;
6041 }
6042
6043 D->addAttr(::new (S.Context)
6044 X86ForceAlignArgPointerAttr(AL.getRange(), S.Context,
6045 AL.getAttributeSpellingListIndex()));
6046}
6047
6048static void handleLayoutVersion(Sema &S, Decl *D, const ParsedAttr &AL) {
6049 uint32_t Version;
6050 Expr *VersionExpr = static_cast<Expr *>(AL.getArgAsExpr(0));
6051 if (!checkUInt32Argument(S, AL, AL.getArgAsExpr(0), Version))
6052 return;
6053
6054 // TODO: Investigate what happens with the next major version of MSVC.
6055 if (Version != LangOptions::MSVC2015 / 100) {
6056 S.Diag(AL.getLoc(), diag::err_attribute_argument_out_of_bounds)
6057 << AL << Version << VersionExpr->getSourceRange();
6058 return;
6059 }
6060
6061 // The attribute expects a "major" version number like 19, but new versions of
6062 // MSVC have moved to updating the "minor", or less significant numbers, so we
6063 // have to multiply by 100 now.
6064 Version *= 100;
6065
6066 D->addAttr(::new (S.Context)
6067 LayoutVersionAttr(AL.getRange(), S.Context, Version,
6068 AL.getAttributeSpellingListIndex()));
6069}
6070
6071DLLImportAttr *Sema::mergeDLLImportAttr(Decl *D, SourceRange Range,
6072 unsigned AttrSpellingListIndex) {
6073 if (D->hasAttr<DLLExportAttr>()) {
6074 Diag(Range.getBegin(), diag::warn_attribute_ignored) << "'dllimport'";
6075 return nullptr;
6076 }
6077
6078 if (D->hasAttr<DLLImportAttr>())
6079 return nullptr;
6080
6081 return ::new (Context) DLLImportAttr(Range, Context, AttrSpellingListIndex);
6082}
6083
6084DLLExportAttr *Sema::mergeDLLExportAttr(Decl *D, SourceRange Range,
6085 unsigned AttrSpellingListIndex) {
6086 if (DLLImportAttr *Import = D->getAttr<DLLImportAttr>()) {
6087 Diag(Import->getLocation(), diag::warn_attribute_ignored) << Import;
6088 D->dropAttr<DLLImportAttr>();
6089 }
6090
6091 if (D->hasAttr<DLLExportAttr>())
6092 return nullptr;
6093
6094 return ::new (Context) DLLExportAttr(Range, Context, AttrSpellingListIndex);
6095}
6096
6097static void handleDLLAttr(Sema &S, Decl *D, const ParsedAttr &A) {
6098 if (isa<ClassTemplatePartialSpecializationDecl>(D) &&
6099 S.Context.getTargetInfo().getCXXABI().isMicrosoft()) {
6100 S.Diag(A.getRange().getBegin(), diag::warn_attribute_ignored) << A;
6101 return;
6102 }
6103
6104 if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
6105 if (FD->isInlined() && A.getKind() == ParsedAttr::AT_DLLImport &&
6106 !S.Context.getTargetInfo().getCXXABI().isMicrosoft()) {
6107 // MinGW doesn't allow dllimport on inline functions.
6108 S.Diag(A.getRange().getBegin(), diag::warn_attribute_ignored_on_inline)
6109 << A;
6110 return;
6111 }
6112 }
6113
6114 if (const auto *MD = dyn_cast<CXXMethodDecl>(D)) {
6115 if (S.Context.getTargetInfo().getCXXABI().isMicrosoft() &&
6116 MD->getParent()->isLambda()) {
6117 S.Diag(A.getRange().getBegin(), diag::err_attribute_dll_lambda) << A;
6118 return;
6119 }
6120 }
6121
6122 unsigned Index = A.getAttributeSpellingListIndex();
6123 Attr *NewAttr = A.getKind() == ParsedAttr::AT_DLLExport
6124 ? (Attr *)S.mergeDLLExportAttr(D, A.getRange(), Index)
6125 : (Attr *)S.mergeDLLImportAttr(D, A.getRange(), Index);
6126 if (NewAttr)
6127 D->addAttr(NewAttr);
6128}
6129
6130MSInheritanceAttr *
6131Sema::mergeMSInheritanceAttr(Decl *D, SourceRange Range, bool BestCase,
6132 unsigned AttrSpellingListIndex,
6133 MSInheritanceAttr::Spelling SemanticSpelling) {
6134 if (MSInheritanceAttr *IA = D->getAttr<MSInheritanceAttr>()) {
6135 if (IA->getSemanticSpelling() == SemanticSpelling)
6136 return nullptr;
6137 Diag(IA->getLocation(), diag::err_mismatched_ms_inheritance)
6138 << 1 /*previous declaration*/;
6139 Diag(Range.getBegin(), diag::note_previous_ms_inheritance);
6140 D->dropAttr<MSInheritanceAttr>();
6141 }
6142
6143 auto *RD = cast<CXXRecordDecl>(D);
6144 if (RD->hasDefinition()) {
6145 if (checkMSInheritanceAttrOnDefinition(RD, Range, BestCase,
6146 SemanticSpelling)) {
6147 return nullptr;
6148 }
6149 } else {
6150 if (isa<ClassTemplatePartialSpecializationDecl>(RD)) {
6151 Diag(Range.getBegin(), diag::warn_ignored_ms_inheritance)
6152 << 1 /*partial specialization*/;
6153 return nullptr;
6154 }
6155 if (RD->getDescribedClassTemplate()) {
6156 Diag(Range.getBegin(), diag::warn_ignored_ms_inheritance)
6157 << 0 /*primary template*/;
6158 return nullptr;
6159 }
6160 }
6161
6162 return ::new (Context)
6163 MSInheritanceAttr(Range, Context, BestCase, AttrSpellingListIndex);
6164}
6165
6166static void handleCapabilityAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
6167 // The capability attributes take a single string parameter for the name of
6168 // the capability they represent. The lockable attribute does not take any
6169 // parameters. However, semantically, both attributes represent the same
6170 // concept, and so they use the same semantic attribute. Eventually, the
6171 // lockable attribute will be removed.
6172 //
6173 // For backward compatibility, any capability which has no specified string
6174 // literal will be considered a "mutex."
6175 StringRef N("mutex");
6176 SourceLocation LiteralLoc;
6177 if (AL.getKind() == ParsedAttr::AT_Capability &&
6178 !S.checkStringLiteralArgumentAttr(AL, 0, N, &LiteralLoc))
6179 return;
6180
6181 // Currently, there are only two names allowed for a capability: role and
6182 // mutex (case insensitive). Diagnose other capability names.
6183 if (!N.equals_lower("mutex") && !N.equals_lower("role"))
6184 S.Diag(LiteralLoc, diag::warn_invalid_capability_name) << N;
6185
6186 D->addAttr(::new (S.Context) CapabilityAttr(AL.getRange(), S.Context, N,
6187 AL.getAttributeSpellingListIndex()));
6188}
6189
6190static void handleAssertCapabilityAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
6191 SmallVector<Expr*, 1> Args;
6192 if (!checkLockFunAttrCommon(S, D, AL, Args))
6193 return;
6194
6195 D->addAttr(::new (S.Context) AssertCapabilityAttr(AL.getRange(), S.Context,
6196 Args.data(), Args.size(),
6197 AL.getAttributeSpellingListIndex()));
6198}
6199
6200static void handleAcquireCapabilityAttr(Sema &S, Decl *D,
6201 const ParsedAttr &AL) {
6202 SmallVector<Expr*, 1> Args;
6203 if (!checkLockFunAttrCommon(S, D, AL, Args))
6204 return;
6205
6206 D->addAttr(::new (S.Context) AcquireCapabilityAttr(AL.getRange(),
6207 S.Context,
6208 Args.data(), Args.size(),
6209 AL.getAttributeSpellingListIndex()));
6210}
6211
6212static void handleTryAcquireCapabilityAttr(Sema &S, Decl *D,
6213 const ParsedAttr &AL) {
6214 SmallVector<Expr*, 2> Args;
6215 if (!checkTryLockFunAttrCommon(S, D, AL, Args))
6216 return;
6217
6218 D->addAttr(::new (S.Context) TryAcquireCapabilityAttr(AL.getRange(),
6219 S.Context,
6220 AL.getArgAsExpr(0),
6221 Args.data(),
6222 Args.size(),
6223 AL.getAttributeSpellingListIndex()));
6224}
6225
6226static void handleReleaseCapabilityAttr(Sema &S, Decl *D,
6227 const ParsedAttr &AL) {
6228 // Check that all arguments are lockable objects.
6229 SmallVector<Expr *, 1> Args;
6230 checkAttrArgsAreCapabilityObjs(S, D, AL, Args, 0, true);
6231
6232 D->addAttr(::new (S.Context) ReleaseCapabilityAttr(
6233 AL.getRange(), S.Context, Args.data(), Args.size(),
6234 AL.getAttributeSpellingListIndex()));
6235}
6236
6237static void handleRequiresCapabilityAttr(Sema &S, Decl *D,
6238 const ParsedAttr &AL) {
6239 if (!checkAttributeAtLeastNumArgs(S, AL, 1))
6240 return;
6241
6242 // check that all arguments are lockable objects
6243 SmallVector<Expr*, 1> Args;
6244 checkAttrArgsAreCapabilityObjs(S, D, AL, Args);
6245 if (Args.empty())
6246 return;
6247
6248 RequiresCapabilityAttr *RCA = ::new (S.Context)
6249 RequiresCapabilityAttr(AL.getRange(), S.Context, Args.data(),
6250 Args.size(), AL.getAttributeSpellingListIndex());
6251
6252 D->addAttr(RCA);
6253}
6254
6255static void handleDeprecatedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
6256 if (const auto *NSD = dyn_cast<NamespaceDecl>(D)) {