Bug Summary

File:build-llvm/tools/clang/include/clang/AST/Attrs.inc
Warning:line 1889, column 5
Called C++ object pointer is null

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 SemaCUDA.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-eagerly-assume -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 -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-7/lib/clang/7.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn338205/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/c++/8 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/x86_64-linux-gnu/c++/8 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/x86_64-linux-gnu/c++/8 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/c++/8/backward -internal-isystem /usr/include/clang/7.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-7/lib/clang/7.0.0/include -internal-externc-isystem /usr/lib/gcc/x86_64-linux-gnu/8/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-class-memaccess -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/lib/Sema -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -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-2018-07-29-043837-17923-1 -x c++ /build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaCUDA.cpp -faddrsig

/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaCUDA.cpp

1//===--- SemaCUDA.cpp - Semantic Analysis for CUDA constructs -------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9/// \file
10/// This file implements semantic analysis for CUDA constructs.
11///
12//===----------------------------------------------------------------------===//
13
14#include "clang/AST/ASTContext.h"
15#include "clang/AST/Decl.h"
16#include "clang/AST/ExprCXX.h"
17#include "clang/Lex/Preprocessor.h"
18#include "clang/Sema/Lookup.h"
19#include "clang/Sema/Sema.h"
20#include "clang/Sema/SemaDiagnostic.h"
21#include "clang/Sema/SemaInternal.h"
22#include "clang/Sema/Template.h"
23#include "llvm/ADT/Optional.h"
24#include "llvm/ADT/SmallVector.h"
25using namespace clang;
26
27void Sema::PushForceCUDAHostDevice() {
28 assert(getLangOpts().CUDA && "Should only be called during CUDA compilation")(static_cast <bool> (getLangOpts().CUDA && "Should only be called during CUDA compilation"
) ? void (0) : __assert_fail ("getLangOpts().CUDA && \"Should only be called during CUDA compilation\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaCUDA.cpp"
, 28, __extension__ __PRETTY_FUNCTION__))
;
29 ForceCUDAHostDeviceDepth++;
30}
31
32bool Sema::PopForceCUDAHostDevice() {
33 assert(getLangOpts().CUDA && "Should only be called during CUDA compilation")(static_cast <bool> (getLangOpts().CUDA && "Should only be called during CUDA compilation"
) ? void (0) : __assert_fail ("getLangOpts().CUDA && \"Should only be called during CUDA compilation\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaCUDA.cpp"
, 33, __extension__ __PRETTY_FUNCTION__))
;
34 if (ForceCUDAHostDeviceDepth == 0)
35 return false;
36 ForceCUDAHostDeviceDepth--;
37 return true;
38}
39
40ExprResult Sema::ActOnCUDAExecConfigExpr(Scope *S, SourceLocation LLLLoc,
41 MultiExprArg ExecConfig,
42 SourceLocation GGGLoc) {
43 FunctionDecl *ConfigDecl = Context.getcudaConfigureCallDecl();
44 if (!ConfigDecl)
45 return ExprError(
46 Diag(LLLLoc, diag::err_undeclared_var_use)
47 << (getLangOpts().HIP ? "hipConfigureCall" : "cudaConfigureCall"));
48 QualType ConfigQTy = ConfigDecl->getType();
49
50 DeclRefExpr *ConfigDR = new (Context)
51 DeclRefExpr(ConfigDecl, false, ConfigQTy, VK_LValue, LLLLoc);
52 MarkFunctionReferenced(LLLLoc, ConfigDecl);
53
54 return ActOnCallExpr(S, ConfigDR, LLLLoc, ExecConfig, GGGLoc, nullptr,
55 /*IsExecConfig=*/true);
56}
57
58Sema::CUDAFunctionTarget
59Sema::IdentifyCUDATarget(const ParsedAttributesView &Attrs) {
60 bool HasHostAttr = false;
61 bool HasDeviceAttr = false;
62 bool HasGlobalAttr = false;
63 bool HasInvalidTargetAttr = false;
64 for (const ParsedAttr &AL : Attrs) {
65 switch (AL.getKind()) {
66 case ParsedAttr::AT_CUDAGlobal:
67 HasGlobalAttr = true;
68 break;
69 case ParsedAttr::AT_CUDAHost:
70 HasHostAttr = true;
71 break;
72 case ParsedAttr::AT_CUDADevice:
73 HasDeviceAttr = true;
74 break;
75 case ParsedAttr::AT_CUDAInvalidTarget:
76 HasInvalidTargetAttr = true;
77 break;
78 default:
79 break;
80 }
81 }
82
83 if (HasInvalidTargetAttr)
84 return CFT_InvalidTarget;
85
86 if (HasGlobalAttr)
87 return CFT_Global;
88
89 if (HasHostAttr && HasDeviceAttr)
90 return CFT_HostDevice;
91
92 if (HasDeviceAttr)
93 return CFT_Device;
94
95 return CFT_Host;
96}
97
98template <typename A>
99static bool hasAttr(const FunctionDecl *D, bool IgnoreImplicitAttr) {
100 return D->hasAttrs() && llvm::any_of(D->getAttrs(), [&](Attr *Attribute) {
101 return isa<A>(Attribute) &&
102 !(IgnoreImplicitAttr && Attribute->isImplicit());
103 });
104}
105
106/// IdentifyCUDATarget - Determine the CUDA compilation target for this function
107Sema::CUDAFunctionTarget Sema::IdentifyCUDATarget(const FunctionDecl *D,
108 bool IgnoreImplicitHDAttr) {
109 // Code that lives outside a function is run on the host.
110 if (D == nullptr)
111 return CFT_Host;
112
113 if (D->hasAttr<CUDAInvalidTargetAttr>())
114 return CFT_InvalidTarget;
115
116 if (D->hasAttr<CUDAGlobalAttr>())
117 return CFT_Global;
118
119 if (hasAttr<CUDADeviceAttr>(D, IgnoreImplicitHDAttr)) {
120 if (hasAttr<CUDAHostAttr>(D, IgnoreImplicitHDAttr))
121 return CFT_HostDevice;
122 return CFT_Device;
123 } else if (hasAttr<CUDAHostAttr>(D, IgnoreImplicitHDAttr)) {
124 return CFT_Host;
125 } else if (D->isImplicit() && !IgnoreImplicitHDAttr) {
126 // Some implicit declarations (like intrinsic functions) are not marked.
127 // Set the most lenient target on them for maximal flexibility.
128 return CFT_HostDevice;
129 }
130
131 return CFT_Host;
132}
133
134// * CUDA Call preference table
135//
136// F - from,
137// T - to
138// Ph - preference in host mode
139// Pd - preference in device mode
140// H - handled in (x)
141// Preferences: N:native, SS:same side, HD:host-device, WS:wrong side, --:never.
142//
143// | F | T | Ph | Pd | H |
144// |----+----+-----+-----+-----+
145// | d | d | N | N | (c) |
146// | d | g | -- | -- | (a) |
147// | d | h | -- | -- | (e) |
148// | d | hd | HD | HD | (b) |
149// | g | d | N | N | (c) |
150// | g | g | -- | -- | (a) |
151// | g | h | -- | -- | (e) |
152// | g | hd | HD | HD | (b) |
153// | h | d | -- | -- | (e) |
154// | h | g | N | N | (c) |
155// | h | h | N | N | (c) |
156// | h | hd | HD | HD | (b) |
157// | hd | d | WS | SS | (d) |
158// | hd | g | SS | -- |(d/a)|
159// | hd | h | SS | WS | (d) |
160// | hd | hd | HD | HD | (b) |
161
162Sema::CUDAFunctionPreference
163Sema::IdentifyCUDAPreference(const FunctionDecl *Caller,
164 const FunctionDecl *Callee) {
165 assert(Callee && "Callee must be valid.")(static_cast <bool> (Callee && "Callee must be valid."
) ? void (0) : __assert_fail ("Callee && \"Callee must be valid.\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaCUDA.cpp"
, 165, __extension__ __PRETTY_FUNCTION__))
;
166 CUDAFunctionTarget CallerTarget = IdentifyCUDATarget(Caller);
167 CUDAFunctionTarget CalleeTarget = IdentifyCUDATarget(Callee);
168
169 // If one of the targets is invalid, the check always fails, no matter what
170 // the other target is.
171 if (CallerTarget == CFT_InvalidTarget || CalleeTarget == CFT_InvalidTarget)
172 return CFP_Never;
173
174 // (a) Can't call global from some contexts until we support CUDA's
175 // dynamic parallelism.
176 if (CalleeTarget == CFT_Global &&
177 (CallerTarget == CFT_Global || CallerTarget == CFT_Device))
178 return CFP_Never;
179
180 // (b) Calling HostDevice is OK for everyone.
181 if (CalleeTarget == CFT_HostDevice)
182 return CFP_HostDevice;
183
184 // (c) Best case scenarios
185 if (CalleeTarget == CallerTarget ||
186 (CallerTarget == CFT_Host && CalleeTarget == CFT_Global) ||
187 (CallerTarget == CFT_Global && CalleeTarget == CFT_Device))
188 return CFP_Native;
189
190 // (d) HostDevice behavior depends on compilation mode.
191 if (CallerTarget == CFT_HostDevice) {
192 // It's OK to call a compilation-mode matching function from an HD one.
193 if ((getLangOpts().CUDAIsDevice && CalleeTarget == CFT_Device) ||
194 (!getLangOpts().CUDAIsDevice &&
195 (CalleeTarget == CFT_Host || CalleeTarget == CFT_Global)))
196 return CFP_SameSide;
197
198 // Calls from HD to non-mode-matching functions (i.e., to host functions
199 // when compiling in device mode or to device functions when compiling in
200 // host mode) are allowed at the sema level, but eventually rejected if
201 // they're ever codegened. TODO: Reject said calls earlier.
202 return CFP_WrongSide;
203 }
204
205 // (e) Calling across device/host boundary is not something you should do.
206 if ((CallerTarget == CFT_Host && CalleeTarget == CFT_Device) ||
207 (CallerTarget == CFT_Device && CalleeTarget == CFT_Host) ||
208 (CallerTarget == CFT_Global && CalleeTarget == CFT_Host))
209 return CFP_Never;
210
211 llvm_unreachable("All cases should've been handled by now.")::llvm::llvm_unreachable_internal("All cases should've been handled by now."
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaCUDA.cpp"
, 211)
;
212}
213
214void Sema::EraseUnwantedCUDAMatches(
215 const FunctionDecl *Caller,
216 SmallVectorImpl<std::pair<DeclAccessPair, FunctionDecl *>> &Matches) {
217 if (Matches.size() <= 1)
218 return;
219
220 using Pair = std::pair<DeclAccessPair, FunctionDecl*>;
221
222 // Gets the CUDA function preference for a call from Caller to Match.
223 auto GetCFP = [&](const Pair &Match) {
224 return IdentifyCUDAPreference(Caller, Match.second);
225 };
226
227 // Find the best call preference among the functions in Matches.
228 CUDAFunctionPreference BestCFP = GetCFP(*std::max_element(
229 Matches.begin(), Matches.end(),
230 [&](const Pair &M1, const Pair &M2) { return GetCFP(M1) < GetCFP(M2); }));
231
232 // Erase all functions with lower priority.
233 llvm::erase_if(Matches,
234 [&](const Pair &Match) { return GetCFP(Match) < BestCFP; });
235}
236
237/// When an implicitly-declared special member has to invoke more than one
238/// base/field special member, conflicts may occur in the targets of these
239/// members. For example, if one base's member __host__ and another's is
240/// __device__, it's a conflict.
241/// This function figures out if the given targets \param Target1 and
242/// \param Target2 conflict, and if they do not it fills in
243/// \param ResolvedTarget with a target that resolves for both calls.
244/// \return true if there's a conflict, false otherwise.
245static bool
246resolveCalleeCUDATargetConflict(Sema::CUDAFunctionTarget Target1,
247 Sema::CUDAFunctionTarget Target2,
248 Sema::CUDAFunctionTarget *ResolvedTarget) {
249 // Only free functions and static member functions may be global.
250 assert(Target1 != Sema::CFT_Global)(static_cast <bool> (Target1 != Sema::CFT_Global) ? void
(0) : __assert_fail ("Target1 != Sema::CFT_Global", "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaCUDA.cpp"
, 250, __extension__ __PRETTY_FUNCTION__))
;
251 assert(Target2 != Sema::CFT_Global)(static_cast <bool> (Target2 != Sema::CFT_Global) ? void
(0) : __assert_fail ("Target2 != Sema::CFT_Global", "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaCUDA.cpp"
, 251, __extension__ __PRETTY_FUNCTION__))
;
252
253 if (Target1 == Sema::CFT_HostDevice) {
254 *ResolvedTarget = Target2;
255 } else if (Target2 == Sema::CFT_HostDevice) {
256 *ResolvedTarget = Target1;
257 } else if (Target1 != Target2) {
258 return true;
259 } else {
260 *ResolvedTarget = Target1;
261 }
262
263 return false;
264}
265
266bool Sema::inferCUDATargetForImplicitSpecialMember(CXXRecordDecl *ClassDecl,
267 CXXSpecialMember CSM,
268 CXXMethodDecl *MemberDecl,
269 bool ConstRHS,
270 bool Diagnose) {
271 llvm::Optional<CUDAFunctionTarget> InferredTarget;
272
273 // We're going to invoke special member lookup; mark that these special
274 // members are called from this one, and not from its caller.
275 ContextRAII MethodContext(*this, MemberDecl);
276
277 // Look for special members in base classes that should be invoked from here.
278 // Infer the target of this member base on the ones it should call.
279 // Skip direct and indirect virtual bases for abstract classes.
280 llvm::SmallVector<const CXXBaseSpecifier *, 16> Bases;
281 for (const auto &B : ClassDecl->bases()) {
282 if (!B.isVirtual()) {
283 Bases.push_back(&B);
284 }
285 }
286
287 if (!ClassDecl->isAbstract()) {
288 for (const auto &VB : ClassDecl->vbases()) {
289 Bases.push_back(&VB);
290 }
291 }
292
293 for (const auto *B : Bases) {
294 const RecordType *BaseType = B->getType()->getAs<RecordType>();
295 if (!BaseType) {
296 continue;
297 }
298
299 CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseType->getDecl());
300 Sema::SpecialMemberOverloadResult SMOR =
301 LookupSpecialMember(BaseClassDecl, CSM,
302 /* ConstArg */ ConstRHS,
303 /* VolatileArg */ false,
304 /* RValueThis */ false,
305 /* ConstThis */ false,
306 /* VolatileThis */ false);
307
308 if (!SMOR.getMethod())
309 continue;
310
311 CUDAFunctionTarget BaseMethodTarget = IdentifyCUDATarget(SMOR.getMethod());
312 if (!InferredTarget.hasValue()) {
313 InferredTarget = BaseMethodTarget;
314 } else {
315 bool ResolutionError = resolveCalleeCUDATargetConflict(
316 InferredTarget.getValue(), BaseMethodTarget,
317 InferredTarget.getPointer());
318 if (ResolutionError) {
319 if (Diagnose) {
320 Diag(ClassDecl->getLocation(),
321 diag::note_implicit_member_target_infer_collision)
322 << (unsigned)CSM << InferredTarget.getValue() << BaseMethodTarget;
323 }
324 MemberDecl->addAttr(CUDAInvalidTargetAttr::CreateImplicit(Context));
325 return true;
326 }
327 }
328 }
329
330 // Same as for bases, but now for special members of fields.
331 for (const auto *F : ClassDecl->fields()) {
332 if (F->isInvalidDecl()) {
333 continue;
334 }
335
336 const RecordType *FieldType =
337 Context.getBaseElementType(F->getType())->getAs<RecordType>();
338 if (!FieldType) {
339 continue;
340 }
341
342 CXXRecordDecl *FieldRecDecl = cast<CXXRecordDecl>(FieldType->getDecl());
343 Sema::SpecialMemberOverloadResult SMOR =
344 LookupSpecialMember(FieldRecDecl, CSM,
345 /* ConstArg */ ConstRHS && !F->isMutable(),
346 /* VolatileArg */ false,
347 /* RValueThis */ false,
348 /* ConstThis */ false,
349 /* VolatileThis */ false);
350
351 if (!SMOR.getMethod())
352 continue;
353
354 CUDAFunctionTarget FieldMethodTarget =
355 IdentifyCUDATarget(SMOR.getMethod());
356 if (!InferredTarget.hasValue()) {
357 InferredTarget = FieldMethodTarget;
358 } else {
359 bool ResolutionError = resolveCalleeCUDATargetConflict(
360 InferredTarget.getValue(), FieldMethodTarget,
361 InferredTarget.getPointer());
362 if (ResolutionError) {
363 if (Diagnose) {
364 Diag(ClassDecl->getLocation(),
365 diag::note_implicit_member_target_infer_collision)
366 << (unsigned)CSM << InferredTarget.getValue()
367 << FieldMethodTarget;
368 }
369 MemberDecl->addAttr(CUDAInvalidTargetAttr::CreateImplicit(Context));
370 return true;
371 }
372 }
373 }
374
375 if (InferredTarget.hasValue()) {
376 if (InferredTarget.getValue() == CFT_Device) {
377 MemberDecl->addAttr(CUDADeviceAttr::CreateImplicit(Context));
378 } else if (InferredTarget.getValue() == CFT_Host) {
379 MemberDecl->addAttr(CUDAHostAttr::CreateImplicit(Context));
380 } else {
381 MemberDecl->addAttr(CUDADeviceAttr::CreateImplicit(Context));
382 MemberDecl->addAttr(CUDAHostAttr::CreateImplicit(Context));
383 }
384 } else {
385 // If no target was inferred, mark this member as __host__ __device__;
386 // it's the least restrictive option that can be invoked from any target.
387 MemberDecl->addAttr(CUDADeviceAttr::CreateImplicit(Context));
388 MemberDecl->addAttr(CUDAHostAttr::CreateImplicit(Context));
389 }
390
391 return false;
392}
393
394bool Sema::isEmptyCudaConstructor(SourceLocation Loc, CXXConstructorDecl *CD) {
395 if (!CD->isDefined() && CD->isTemplateInstantiation())
396 InstantiateFunctionDefinition(Loc, CD->getFirstDecl());
397
398 // (E.2.3.1, CUDA 7.5) A constructor for a class type is considered
399 // empty at a point in the translation unit, if it is either a
400 // trivial constructor
401 if (CD->isTrivial())
402 return true;
403
404 // ... or it satisfies all of the following conditions:
405 // The constructor function has been defined.
406 // The constructor function has no parameters,
407 // and the function body is an empty compound statement.
408 if (!(CD->hasTrivialBody() && CD->getNumParams() == 0))
409 return false;
410
411 // Its class has no virtual functions and no virtual base classes.
412 if (CD->getParent()->isDynamicClass())
413 return false;
414
415 // The only form of initializer allowed is an empty constructor.
416 // This will recursively check all base classes and member initializers
417 if (!llvm::all_of(CD->inits(), [&](const CXXCtorInitializer *CI) {
418 if (const CXXConstructExpr *CE =
419 dyn_cast<CXXConstructExpr>(CI->getInit()))
420 return isEmptyCudaConstructor(Loc, CE->getConstructor());
421 return false;
422 }))
423 return false;
424
425 return true;
426}
427
428bool Sema::isEmptyCudaDestructor(SourceLocation Loc, CXXDestructorDecl *DD) {
429 // No destructor -> no problem.
430 if (!DD)
431 return true;
432
433 if (!DD->isDefined() && DD->isTemplateInstantiation())
434 InstantiateFunctionDefinition(Loc, DD->getFirstDecl());
435
436 // (E.2.3.1, CUDA 7.5) A destructor for a class type is considered
437 // empty at a point in the translation unit, if it is either a
438 // trivial constructor
439 if (DD->isTrivial())
440 return true;
441
442 // ... or it satisfies all of the following conditions:
443 // The destructor function has been defined.
444 // and the function body is an empty compound statement.
445 if (!DD->hasTrivialBody())
446 return false;
447
448 const CXXRecordDecl *ClassDecl = DD->getParent();
449
450 // Its class has no virtual functions and no virtual base classes.
451 if (ClassDecl->isDynamicClass())
452 return false;
453
454 // Only empty destructors are allowed. This will recursively check
455 // destructors for all base classes...
456 if (!llvm::all_of(ClassDecl->bases(), [&](const CXXBaseSpecifier &BS) {
457 if (CXXRecordDecl *RD = BS.getType()->getAsCXXRecordDecl())
458 return isEmptyCudaDestructor(Loc, RD->getDestructor());
459 return true;
460 }))
461 return false;
462
463 // ... and member fields.
464 if (!llvm::all_of(ClassDecl->fields(), [&](const FieldDecl *Field) {
465 if (CXXRecordDecl *RD = Field->getType()
466 ->getBaseElementTypeUnsafe()
467 ->getAsCXXRecordDecl())
468 return isEmptyCudaDestructor(Loc, RD->getDestructor());
469 return true;
470 }))
471 return false;
472
473 return true;
474}
475
476void Sema::checkAllowedCUDAInitializer(VarDecl *VD) {
477 if (VD->isInvalidDecl() || !VD->hasInit() || !VD->hasGlobalStorage())
478 return;
479 const Expr *Init = VD->getInit();
480 if (VD->hasAttr<CUDADeviceAttr>() || VD->hasAttr<CUDAConstantAttr>() ||
481 VD->hasAttr<CUDASharedAttr>()) {
482 assert(!VD->isStaticLocal() || VD->hasAttr<CUDASharedAttr>())(static_cast <bool> (!VD->isStaticLocal() || VD->
hasAttr<CUDASharedAttr>()) ? void (0) : __assert_fail (
"!VD->isStaticLocal() || VD->hasAttr<CUDASharedAttr>()"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaCUDA.cpp"
, 482, __extension__ __PRETTY_FUNCTION__))
;
483 bool AllowedInit = false;
484 if (const CXXConstructExpr *CE = dyn_cast<CXXConstructExpr>(Init))
485 AllowedInit =
486 isEmptyCudaConstructor(VD->getLocation(), CE->getConstructor());
487 // We'll allow constant initializers even if it's a non-empty
488 // constructor according to CUDA rules. This deviates from NVCC,
489 // but allows us to handle things like constexpr constructors.
490 if (!AllowedInit &&
491 (VD->hasAttr<CUDADeviceAttr>() || VD->hasAttr<CUDAConstantAttr>()))
492 AllowedInit = VD->getInit()->isConstantInitializer(
493 Context, VD->getType()->isReferenceType());
494
495 // Also make sure that destructor, if there is one, is empty.
496 if (AllowedInit)
497 if (CXXRecordDecl *RD = VD->getType()->getAsCXXRecordDecl())
498 AllowedInit =
499 isEmptyCudaDestructor(VD->getLocation(), RD->getDestructor());
500
501 if (!AllowedInit) {
502 Diag(VD->getLocation(), VD->hasAttr<CUDASharedAttr>()
503 ? diag::err_shared_var_init
504 : diag::err_dynamic_var_init)
505 << Init->getSourceRange();
506 VD->setInvalidDecl();
507 }
508 } else {
509 // This is a host-side global variable. Check that the initializer is
510 // callable from the host side.
511 const FunctionDecl *InitFn = nullptr;
512 if (const CXXConstructExpr *CE = dyn_cast<CXXConstructExpr>(Init)) {
513 InitFn = CE->getConstructor();
514 } else if (const CallExpr *CE = dyn_cast<CallExpr>(Init)) {
515 InitFn = CE->getDirectCallee();
516 }
517 if (InitFn) {
518 CUDAFunctionTarget InitFnTarget = IdentifyCUDATarget(InitFn);
519 if (InitFnTarget != CFT_Host && InitFnTarget != CFT_HostDevice) {
520 Diag(VD->getLocation(), diag::err_ref_bad_target_global_initializer)
521 << InitFnTarget << InitFn;
522 Diag(InitFn->getLocation(), diag::note_previous_decl) << InitFn;
523 VD->setInvalidDecl();
524 }
525 }
526 }
527}
528
529// With -fcuda-host-device-constexpr, an unattributed constexpr function is
530// treated as implicitly __host__ __device__, unless:
531// * it is a variadic function (device-side variadic functions are not
532// allowed), or
533// * a __device__ function with this signature was already declared, in which
534// case in which case we output an error, unless the __device__ decl is in a
535// system header, in which case we leave the constexpr function unattributed.
536//
537// In addition, all function decls are treated as __host__ __device__ when
538// ForceCUDAHostDeviceDepth > 0 (corresponding to code within a
539// #pragma clang force_cuda_host_device_begin/end
540// pair).
541void Sema::maybeAddCUDAHostDeviceAttrs(FunctionDecl *NewD,
542 const LookupResult &Previous) {
543 assert(getLangOpts().CUDA && "Should only be called during CUDA compilation")(static_cast <bool> (getLangOpts().CUDA && "Should only be called during CUDA compilation"
) ? void (0) : __assert_fail ("getLangOpts().CUDA && \"Should only be called during CUDA compilation\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaCUDA.cpp"
, 543, __extension__ __PRETTY_FUNCTION__))
;
544
545 if (ForceCUDAHostDeviceDepth > 0) {
1
Assuming the condition is true
2
Taking true branch
546 if (!NewD->hasAttr<CUDAHostAttr>())
3
Taking true branch
547 NewD->addAttr(CUDAHostAttr::CreateImplicit(Context));
4
Calling 'CUDAHostAttr::CreateImplicit'
548 if (!NewD->hasAttr<CUDADeviceAttr>())
549 NewD->addAttr(CUDADeviceAttr::CreateImplicit(Context));
550 return;
551 }
552
553 if (!getLangOpts().CUDAHostDeviceConstexpr || !NewD->isConstexpr() ||
554 NewD->isVariadic() || NewD->hasAttr<CUDAHostAttr>() ||
555 NewD->hasAttr<CUDADeviceAttr>() || NewD->hasAttr<CUDAGlobalAttr>())
556 return;
557
558 // Is D a __device__ function with the same signature as NewD, ignoring CUDA
559 // attributes?
560 auto IsMatchingDeviceFn = [&](NamedDecl *D) {
561 if (UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(D))
562 D = Using->getTargetDecl();
563 FunctionDecl *OldD = D->getAsFunction();
564 return OldD && OldD->hasAttr<CUDADeviceAttr>() &&
565 !OldD->hasAttr<CUDAHostAttr>() &&
566 !IsOverload(NewD, OldD, /* UseMemberUsingDeclRules = */ false,
567 /* ConsiderCudaAttrs = */ false);
568 };
569 auto It = llvm::find_if(Previous, IsMatchingDeviceFn);
570 if (It != Previous.end()) {
571 // We found a __device__ function with the same name and signature as NewD
572 // (ignoring CUDA attrs). This is an error unless that function is defined
573 // in a system header, in which case we simply return without making NewD
574 // host+device.
575 NamedDecl *Match = *It;
576 if (!getSourceManager().isInSystemHeader(Match->getLocation())) {
577 Diag(NewD->getLocation(),
578 diag::err_cuda_unattributed_constexpr_cannot_overload_device)
579 << NewD;
580 Diag(Match->getLocation(),
581 diag::note_cuda_conflicting_device_function_declared_here);
582 }
583 return;
584 }
585
586 NewD->addAttr(CUDAHostAttr::CreateImplicit(Context));
587 NewD->addAttr(CUDADeviceAttr::CreateImplicit(Context));
588}
589
590// In CUDA, there are some constructs which may appear in semantically-valid
591// code, but trigger errors if we ever generate code for the function in which
592// they appear. Essentially every construct you're not allowed to use on the
593// device falls into this category, because you are allowed to use these
594// constructs in a __host__ __device__ function, but only if that function is
595// never codegen'ed on the device.
596//
597// To handle semantic checking for these constructs, we keep track of the set of
598// functions we know will be emitted, either because we could tell a priori that
599// they would be emitted, or because they were transitively called by a
600// known-emitted function.
601//
602// We also keep a partial call graph of which not-known-emitted functions call
603// which other not-known-emitted functions.
604//
605// When we see something which is illegal if the current function is emitted
606// (usually by way of CUDADiagIfDeviceCode, CUDADiagIfHostCode, or
607// CheckCUDACall), we first check if the current function is known-emitted. If
608// so, we immediately output the diagnostic.
609//
610// Otherwise, we "defer" the diagnostic. It sits in Sema::CUDADeferredDiags
611// until we discover that the function is known-emitted, at which point we take
612// it out of this map and emit the diagnostic.
613
614Sema::CUDADiagBuilder::CUDADiagBuilder(Kind K, SourceLocation Loc,
615 unsigned DiagID, FunctionDecl *Fn,
616 Sema &S)
617 : S(S), Loc(Loc), DiagID(DiagID), Fn(Fn),
618 ShowCallStack(K == K_ImmediateWithCallStack || K == K_Deferred) {
619 switch (K) {
620 case K_Nop:
621 break;
622 case K_Immediate:
623 case K_ImmediateWithCallStack:
624 ImmediateDiag.emplace(S.Diag(Loc, DiagID));
625 break;
626 case K_Deferred:
627 assert(Fn && "Must have a function to attach the deferred diag to.")(static_cast <bool> (Fn && "Must have a function to attach the deferred diag to."
) ? void (0) : __assert_fail ("Fn && \"Must have a function to attach the deferred diag to.\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaCUDA.cpp"
, 627, __extension__ __PRETTY_FUNCTION__))
;
628 PartialDiag.emplace(S.PDiag(DiagID));
629 break;
630 }
631}
632
633// Print notes showing how we can reach FD starting from an a priori
634// known-callable function.
635static void EmitCallStackNotes(Sema &S, FunctionDecl *FD) {
636 auto FnIt = S.CUDAKnownEmittedFns.find(FD);
637 while (FnIt != S.CUDAKnownEmittedFns.end()) {
638 DiagnosticBuilder Builder(
639 S.Diags.Report(FnIt->second.Loc, diag::note_called_by));
640 Builder << FnIt->second.FD;
641 Builder.setForceEmit();
642
643 FnIt = S.CUDAKnownEmittedFns.find(FnIt->second.FD);
644 }
645}
646
647Sema::CUDADiagBuilder::~CUDADiagBuilder() {
648 if (ImmediateDiag) {
649 // Emit our diagnostic and, if it was a warning or error, output a callstack
650 // if Fn isn't a priori known-emitted.
651 bool IsWarningOrError = S.getDiagnostics().getDiagnosticLevel(
652 DiagID, Loc) >= DiagnosticsEngine::Warning;
653 ImmediateDiag.reset(); // Emit the immediate diag.
654 if (IsWarningOrError && ShowCallStack)
655 EmitCallStackNotes(S, Fn);
656 } else if (PartialDiag) {
657 assert(ShowCallStack && "Must always show call stack for deferred diags.")(static_cast <bool> (ShowCallStack && "Must always show call stack for deferred diags."
) ? void (0) : __assert_fail ("ShowCallStack && \"Must always show call stack for deferred diags.\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaCUDA.cpp"
, 657, __extension__ __PRETTY_FUNCTION__))
;
658 S.CUDADeferredDiags[Fn].push_back({Loc, std::move(*PartialDiag)});
659 }
660}
661
662// Do we know that we will eventually codegen the given function?
663static bool IsKnownEmitted(Sema &S, FunctionDecl *FD) {
664 // Templates are emitted when they're instantiated.
665 if (FD->isDependentContext())
666 return false;
667
668 // When compiling for device, host functions are never emitted. Similarly,
669 // when compiling for host, device and global functions are never emitted.
670 // (Technically, we do emit a host-side stub for global functions, but this
671 // doesn't count for our purposes here.)
672 Sema::CUDAFunctionTarget T = S.IdentifyCUDATarget(FD);
673 if (S.getLangOpts().CUDAIsDevice && T == Sema::CFT_Host)
674 return false;
675 if (!S.getLangOpts().CUDAIsDevice &&
676 (T == Sema::CFT_Device || T == Sema::CFT_Global))
677 return false;
678
679 // Check whether this function is externally visible -- if so, it's
680 // known-emitted.
681 //
682 // We have to check the GVA linkage of the function's *definition* -- if we
683 // only have a declaration, we don't know whether or not the function will be
684 // emitted, because (say) the definition could include "inline".
685 FunctionDecl *Def = FD->getDefinition();
686
687 if (Def &&
688 !isDiscardableGVALinkage(S.getASTContext().GetGVALinkageForFunction(Def)))
689 return true;
690
691 // Otherwise, the function is known-emitted if it's in our set of
692 // known-emitted functions.
693 return S.CUDAKnownEmittedFns.count(FD) > 0;
694}
695
696Sema::CUDADiagBuilder Sema::CUDADiagIfDeviceCode(SourceLocation Loc,
697 unsigned DiagID) {
698 assert(getLangOpts().CUDA && "Should only be called during CUDA compilation")(static_cast <bool> (getLangOpts().CUDA && "Should only be called during CUDA compilation"
) ? void (0) : __assert_fail ("getLangOpts().CUDA && \"Should only be called during CUDA compilation\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaCUDA.cpp"
, 698, __extension__ __PRETTY_FUNCTION__))
;
699 CUDADiagBuilder::Kind DiagKind = [&] {
700 switch (CurrentCUDATarget()) {
701 case CFT_Global:
702 case CFT_Device:
703 return CUDADiagBuilder::K_Immediate;
704 case CFT_HostDevice:
705 // An HD function counts as host code if we're compiling for host, and
706 // device code if we're compiling for device. Defer any errors in device
707 // mode until the function is known-emitted.
708 if (getLangOpts().CUDAIsDevice) {
709 return IsKnownEmitted(*this, dyn_cast<FunctionDecl>(CurContext))
710 ? CUDADiagBuilder::K_ImmediateWithCallStack
711 : CUDADiagBuilder::K_Deferred;
712 }
713 return CUDADiagBuilder::K_Nop;
714
715 default:
716 return CUDADiagBuilder::K_Nop;
717 }
718 }();
719 return CUDADiagBuilder(DiagKind, Loc, DiagID,
720 dyn_cast<FunctionDecl>(CurContext), *this);
721}
722
723Sema::CUDADiagBuilder Sema::CUDADiagIfHostCode(SourceLocation Loc,
724 unsigned DiagID) {
725 assert(getLangOpts().CUDA && "Should only be called during CUDA compilation")(static_cast <bool> (getLangOpts().CUDA && "Should only be called during CUDA compilation"
) ? void (0) : __assert_fail ("getLangOpts().CUDA && \"Should only be called during CUDA compilation\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaCUDA.cpp"
, 725, __extension__ __PRETTY_FUNCTION__))
;
726 CUDADiagBuilder::Kind DiagKind = [&] {
727 switch (CurrentCUDATarget()) {
728 case CFT_Host:
729 return CUDADiagBuilder::K_Immediate;
730 case CFT_HostDevice:
731 // An HD function counts as host code if we're compiling for host, and
732 // device code if we're compiling for device. Defer any errors in device
733 // mode until the function is known-emitted.
734 if (getLangOpts().CUDAIsDevice)
735 return CUDADiagBuilder::K_Nop;
736
737 return IsKnownEmitted(*this, dyn_cast<FunctionDecl>(CurContext))
738 ? CUDADiagBuilder::K_ImmediateWithCallStack
739 : CUDADiagBuilder::K_Deferred;
740 default:
741 return CUDADiagBuilder::K_Nop;
742 }
743 }();
744 return CUDADiagBuilder(DiagKind, Loc, DiagID,
745 dyn_cast<FunctionDecl>(CurContext), *this);
746}
747
748// Emit any deferred diagnostics for FD and erase them from the map in which
749// they're stored.
750static void EmitDeferredDiags(Sema &S, FunctionDecl *FD) {
751 auto It = S.CUDADeferredDiags.find(FD);
752 if (It == S.CUDADeferredDiags.end())
753 return;
754 bool HasWarningOrError = false;
755 for (PartialDiagnosticAt &PDAt : It->second) {
756 const SourceLocation &Loc = PDAt.first;
757 const PartialDiagnostic &PD = PDAt.second;
758 HasWarningOrError |= S.getDiagnostics().getDiagnosticLevel(
759 PD.getDiagID(), Loc) >= DiagnosticsEngine::Warning;
760 DiagnosticBuilder Builder(S.Diags.Report(Loc, PD.getDiagID()));
761 Builder.setForceEmit();
762 PD.Emit(Builder);
763 }
764 S.CUDADeferredDiags.erase(It);
765
766 // FIXME: Should this be called after every warning/error emitted in the loop
767 // above, instead of just once per function? That would be consistent with
768 // how we handle immediate errors, but it also seems like a bit much.
769 if (HasWarningOrError)
770 EmitCallStackNotes(S, FD);
771}
772
773// Indicate that this function (and thus everything it transtively calls) will
774// be codegen'ed, and emit any deferred diagnostics on this function and its
775// (transitive) callees.
776static void MarkKnownEmitted(Sema &S, FunctionDecl *OrigCaller,
777 FunctionDecl *OrigCallee, SourceLocation OrigLoc) {
778 // Nothing to do if we already know that FD is emitted.
779 if (IsKnownEmitted(S, OrigCallee)) {
780 assert(!S.CUDACallGraph.count(OrigCallee))(static_cast <bool> (!S.CUDACallGraph.count(OrigCallee)
) ? void (0) : __assert_fail ("!S.CUDACallGraph.count(OrigCallee)"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaCUDA.cpp"
, 780, __extension__ __PRETTY_FUNCTION__))
;
781 return;
782 }
783
784 // We've just discovered that OrigCallee is known-emitted. Walk our call
785 // graph to see what else we can now discover also must be emitted.
786
787 struct CallInfo {
788 FunctionDecl *Caller;
789 FunctionDecl *Callee;
790 SourceLocation Loc;
791 };
792 llvm::SmallVector<CallInfo, 4> Worklist = {{OrigCaller, OrigCallee, OrigLoc}};
793 llvm::SmallSet<CanonicalDeclPtr<FunctionDecl>, 4> Seen;
794 Seen.insert(OrigCallee);
795 while (!Worklist.empty()) {
796 CallInfo C = Worklist.pop_back_val();
797 assert(!IsKnownEmitted(S, C.Callee) &&(static_cast <bool> (!IsKnownEmitted(S, C.Callee) &&
"Worklist should not contain known-emitted functions.") ? void
(0) : __assert_fail ("!IsKnownEmitted(S, C.Callee) && \"Worklist should not contain known-emitted functions.\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaCUDA.cpp"
, 798, __extension__ __PRETTY_FUNCTION__))
798 "Worklist should not contain known-emitted functions.")(static_cast <bool> (!IsKnownEmitted(S, C.Callee) &&
"Worklist should not contain known-emitted functions.") ? void
(0) : __assert_fail ("!IsKnownEmitted(S, C.Callee) && \"Worklist should not contain known-emitted functions.\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaCUDA.cpp"
, 798, __extension__ __PRETTY_FUNCTION__))
;
799 S.CUDAKnownEmittedFns[C.Callee] = {C.Caller, C.Loc};
800 EmitDeferredDiags(S, C.Callee);
801
802 // If this is a template instantiation, explore its callgraph as well:
803 // Non-dependent calls are part of the template's callgraph, while dependent
804 // calls are part of to the instantiation's call graph.
805 if (auto *Templ = C.Callee->getPrimaryTemplate()) {
806 FunctionDecl *TemplFD = Templ->getAsFunction();
807 if (!Seen.count(TemplFD) && !S.CUDAKnownEmittedFns.count(TemplFD)) {
808 Seen.insert(TemplFD);
809 Worklist.push_back(
810 {/* Caller = */ C.Caller, /* Callee = */ TemplFD, C.Loc});
811 }
812 }
813
814 // Add all functions called by Callee to our worklist.
815 auto CGIt = S.CUDACallGraph.find(C.Callee);
816 if (CGIt == S.CUDACallGraph.end())
817 continue;
818
819 for (std::pair<CanonicalDeclPtr<FunctionDecl>, SourceLocation> FDLoc :
820 CGIt->second) {
821 FunctionDecl *NewCallee = FDLoc.first;
822 SourceLocation CallLoc = FDLoc.second;
823 if (Seen.count(NewCallee) || IsKnownEmitted(S, NewCallee))
824 continue;
825 Seen.insert(NewCallee);
826 Worklist.push_back(
827 {/* Caller = */ C.Callee, /* Callee = */ NewCallee, CallLoc});
828 }
829
830 // C.Callee is now known-emitted, so we no longer need to maintain its list
831 // of callees in CUDACallGraph.
832 S.CUDACallGraph.erase(CGIt);
833 }
834}
835
836bool Sema::CheckCUDACall(SourceLocation Loc, FunctionDecl *Callee) {
837 assert(getLangOpts().CUDA && "Should only be called during CUDA compilation")(static_cast <bool> (getLangOpts().CUDA && "Should only be called during CUDA compilation"
) ? void (0) : __assert_fail ("getLangOpts().CUDA && \"Should only be called during CUDA compilation\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaCUDA.cpp"
, 837, __extension__ __PRETTY_FUNCTION__))
;
838 assert(Callee && "Callee may not be null.")(static_cast <bool> (Callee && "Callee may not be null."
) ? void (0) : __assert_fail ("Callee && \"Callee may not be null.\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaCUDA.cpp"
, 838, __extension__ __PRETTY_FUNCTION__))
;
839 // FIXME: Is bailing out early correct here? Should we instead assume that
840 // the caller is a global initializer?
841 FunctionDecl *Caller = dyn_cast<FunctionDecl>(CurContext);
842 if (!Caller)
843 return true;
844
845 // If the caller is known-emitted, mark the callee as known-emitted.
846 // Otherwise, mark the call in our call graph so we can traverse it later.
847 bool CallerKnownEmitted = IsKnownEmitted(*this, Caller);
848 if (CallerKnownEmitted) {
849 // Host-side references to a __global__ function refer to the stub, so the
850 // function itself is never emitted and therefore should not be marked.
851 if (getLangOpts().CUDAIsDevice || IdentifyCUDATarget(Callee) != CFT_Global)
852 MarkKnownEmitted(*this, Caller, Callee, Loc);
853 } else {
854 // If we have
855 // host fn calls kernel fn calls host+device,
856 // the HD function does not get instantiated on the host. We model this by
857 // omitting at the call to the kernel from the callgraph. This ensures
858 // that, when compiling for host, only HD functions actually called from the
859 // host get marked as known-emitted.
860 if (getLangOpts().CUDAIsDevice || IdentifyCUDATarget(Callee) != CFT_Global)
861 CUDACallGraph[Caller].insert({Callee, Loc});
862 }
863
864 CUDADiagBuilder::Kind DiagKind = [&] {
865 switch (IdentifyCUDAPreference(Caller, Callee)) {
866 case CFP_Never:
867 return CUDADiagBuilder::K_Immediate;
868 case CFP_WrongSide:
869 assert(Caller && "WrongSide calls require a non-null caller")(static_cast <bool> (Caller && "WrongSide calls require a non-null caller"
) ? void (0) : __assert_fail ("Caller && \"WrongSide calls require a non-null caller\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaCUDA.cpp"
, 869, __extension__ __PRETTY_FUNCTION__))
;
870 // If we know the caller will be emitted, we know this wrong-side call
871 // will be emitted, so it's an immediate error. Otherwise, defer the
872 // error until we know the caller is emitted.
873 return CallerKnownEmitted ? CUDADiagBuilder::K_ImmediateWithCallStack
874 : CUDADiagBuilder::K_Deferred;
875 default:
876 return CUDADiagBuilder::K_Nop;
877 }
878 }();
879
880 if (DiagKind == CUDADiagBuilder::K_Nop)
881 return true;
882
883 // Avoid emitting this error twice for the same location. Using a hashtable
884 // like this is unfortunate, but because we must continue parsing as normal
885 // after encountering a deferred error, it's otherwise very tricky for us to
886 // ensure that we only emit this deferred error once.
887 if (!LocsWithCUDACallDiags.insert({Caller, Loc}).second)
888 return true;
889
890 CUDADiagBuilder(DiagKind, Loc, diag::err_ref_bad_target, Caller, *this)
891 << IdentifyCUDATarget(Callee) << Callee << IdentifyCUDATarget(Caller);
892 CUDADiagBuilder(DiagKind, Callee->getLocation(), diag::note_previous_decl,
893 Caller, *this)
894 << Callee;
895 return DiagKind != CUDADiagBuilder::K_Immediate &&
896 DiagKind != CUDADiagBuilder::K_ImmediateWithCallStack;
897}
898
899void Sema::CUDASetLambdaAttrs(CXXMethodDecl *Method) {
900 assert(getLangOpts().CUDA && "Should only be called during CUDA compilation")(static_cast <bool> (getLangOpts().CUDA && "Should only be called during CUDA compilation"
) ? void (0) : __assert_fail ("getLangOpts().CUDA && \"Should only be called during CUDA compilation\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaCUDA.cpp"
, 900, __extension__ __PRETTY_FUNCTION__))
;
901 if (Method->hasAttr<CUDAHostAttr>() || Method->hasAttr<CUDADeviceAttr>())
902 return;
903 FunctionDecl *CurFn = dyn_cast<FunctionDecl>(CurContext);
904 if (!CurFn)
905 return;
906 CUDAFunctionTarget Target = IdentifyCUDATarget(CurFn);
907 if (Target == CFT_Global || Target == CFT_Device) {
908 Method->addAttr(CUDADeviceAttr::CreateImplicit(Context));
909 } else if (Target == CFT_HostDevice) {
910 Method->addAttr(CUDADeviceAttr::CreateImplicit(Context));
911 Method->addAttr(CUDAHostAttr::CreateImplicit(Context));
912 }
913}
914
915void Sema::checkCUDATargetOverload(FunctionDecl *NewFD,
916 const LookupResult &Previous) {
917 assert(getLangOpts().CUDA && "Should only be called during CUDA compilation")(static_cast <bool> (getLangOpts().CUDA && "Should only be called during CUDA compilation"
) ? void (0) : __assert_fail ("getLangOpts().CUDA && \"Should only be called during CUDA compilation\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaCUDA.cpp"
, 917, __extension__ __PRETTY_FUNCTION__))
;
918 CUDAFunctionTarget NewTarget = IdentifyCUDATarget(NewFD);
919 for (NamedDecl *OldND : Previous) {
920 FunctionDecl *OldFD = OldND->getAsFunction();
921 if (!OldFD)
922 continue;
923
924 CUDAFunctionTarget OldTarget = IdentifyCUDATarget(OldFD);
925 // Don't allow HD and global functions to overload other functions with the
926 // same signature. We allow overloading based on CUDA attributes so that
927 // functions can have different implementations on the host and device, but
928 // HD/global functions "exist" in some sense on both the host and device, so
929 // should have the same implementation on both sides.
930 if (NewTarget != OldTarget &&
931 ((NewTarget == CFT_HostDevice) || (OldTarget == CFT_HostDevice) ||
932 (NewTarget == CFT_Global) || (OldTarget == CFT_Global)) &&
933 !IsOverload(NewFD, OldFD, /* UseMemberUsingDeclRules = */ false,
934 /* ConsiderCudaAttrs = */ false)) {
935 Diag(NewFD->getLocation(), diag::err_cuda_ovl_target)
936 << NewTarget << NewFD->getDeclName() << OldTarget << OldFD;
937 Diag(OldFD->getLocation(), diag::note_previous_declaration);
938 NewFD->setInvalidDecl();
939 break;
940 }
941 }
942}
943
944template <typename AttrTy>
945static void copyAttrIfPresent(Sema &S, FunctionDecl *FD,
946 const FunctionDecl &TemplateFD) {
947 if (AttrTy *Attribute = TemplateFD.getAttr<AttrTy>()) {
948 AttrTy *Clone = Attribute->clone(S.Context);
949 Clone->setInherited(true);
950 FD->addAttr(Clone);
951 }
952}
953
954void Sema::inheritCUDATargetAttrs(FunctionDecl *FD,
955 const FunctionTemplateDecl &TD) {
956 const FunctionDecl &TemplateFD = *TD.getTemplatedDecl();
957 copyAttrIfPresent<CUDAGlobalAttr>(*this, FD, TemplateFD);
958 copyAttrIfPresent<CUDAHostAttr>(*this, FD, TemplateFD);
959 copyAttrIfPresent<CUDADeviceAttr>(*this, FD, TemplateFD);
960}

/build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc

1/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
2|* *|
3|* Attribute classes' definitions *|
4|* *|
5|* Automatically generated file, do not edit! *|
6|* *|
7\*===----------------------------------------------------------------------===*/
8
9#ifndef LLVM_CLANG_ATTR_CLASSES_INC
10#define LLVM_CLANG_ATTR_CLASSES_INC
11
12class AMDGPUFlatWorkGroupSizeAttr : public InheritableAttr {
13unsigned min;
14
15unsigned max;
16
17public:
18 static AMDGPUFlatWorkGroupSizeAttr *CreateImplicit(ASTContext &Ctx, unsigned Min, unsigned Max, SourceRange Loc = SourceRange()) {
19 auto *A = new (Ctx) AMDGPUFlatWorkGroupSizeAttr(Loc, Ctx, Min, Max, 0);
20 A->setImplicit(true);
21 return A;
22 }
23
24 AMDGPUFlatWorkGroupSizeAttr(SourceRange R, ASTContext &Ctx
25 , unsigned Min
26 , unsigned Max
27 , unsigned SI
28 )
29 : InheritableAttr(attr::AMDGPUFlatWorkGroupSize, R, SI, false, false)
30 , min(Min)
31 , max(Max)
32 {
33 }
34
35 AMDGPUFlatWorkGroupSizeAttr *clone(ASTContext &C) const;
36 void printPretty(raw_ostream &OS,
37 const PrintingPolicy &Policy) const;
38 const char *getSpelling() const;
39 unsigned getMin() const {
40 return min;
41 }
42
43 unsigned getMax() const {
44 return max;
45 }
46
47
48
49 static bool classof(const Attr *A) { return A->getKind() == attr::AMDGPUFlatWorkGroupSize; }
50};
51
52class AMDGPUNumSGPRAttr : public InheritableAttr {
53unsigned numSGPR;
54
55public:
56 static AMDGPUNumSGPRAttr *CreateImplicit(ASTContext &Ctx, unsigned NumSGPR, SourceRange Loc = SourceRange()) {
57 auto *A = new (Ctx) AMDGPUNumSGPRAttr(Loc, Ctx, NumSGPR, 0);
58 A->setImplicit(true);
59 return A;
60 }
61
62 AMDGPUNumSGPRAttr(SourceRange R, ASTContext &Ctx
63 , unsigned NumSGPR
64 , unsigned SI
65 )
66 : InheritableAttr(attr::AMDGPUNumSGPR, R, SI, false, false)
67 , numSGPR(NumSGPR)
68 {
69 }
70
71 AMDGPUNumSGPRAttr *clone(ASTContext &C) const;
72 void printPretty(raw_ostream &OS,
73 const PrintingPolicy &Policy) const;
74 const char *getSpelling() const;
75 unsigned getNumSGPR() const {
76 return numSGPR;
77 }
78
79
80
81 static bool classof(const Attr *A) { return A->getKind() == attr::AMDGPUNumSGPR; }
82};
83
84class AMDGPUNumVGPRAttr : public InheritableAttr {
85unsigned numVGPR;
86
87public:
88 static AMDGPUNumVGPRAttr *CreateImplicit(ASTContext &Ctx, unsigned NumVGPR, SourceRange Loc = SourceRange()) {
89 auto *A = new (Ctx) AMDGPUNumVGPRAttr(Loc, Ctx, NumVGPR, 0);
90 A->setImplicit(true);
91 return A;
92 }
93
94 AMDGPUNumVGPRAttr(SourceRange R, ASTContext &Ctx
95 , unsigned NumVGPR
96 , unsigned SI
97 )
98 : InheritableAttr(attr::AMDGPUNumVGPR, R, SI, false, false)
99 , numVGPR(NumVGPR)
100 {
101 }
102
103 AMDGPUNumVGPRAttr *clone(ASTContext &C) const;
104 void printPretty(raw_ostream &OS,
105 const PrintingPolicy &Policy) const;
106 const char *getSpelling() const;
107 unsigned getNumVGPR() const {
108 return numVGPR;
109 }
110
111
112
113 static bool classof(const Attr *A) { return A->getKind() == attr::AMDGPUNumVGPR; }
114};
115
116class AMDGPUWavesPerEUAttr : public InheritableAttr {
117unsigned min;
118
119unsigned max;
120
121public:
122 static AMDGPUWavesPerEUAttr *CreateImplicit(ASTContext &Ctx, unsigned Min, unsigned Max, SourceRange Loc = SourceRange()) {
123 auto *A = new (Ctx) AMDGPUWavesPerEUAttr(Loc, Ctx, Min, Max, 0);
124 A->setImplicit(true);
125 return A;
126 }
127
128 AMDGPUWavesPerEUAttr(SourceRange R, ASTContext &Ctx
129 , unsigned Min
130 , unsigned Max
131 , unsigned SI
132 )
133 : InheritableAttr(attr::AMDGPUWavesPerEU, R, SI, false, false)
134 , min(Min)
135 , max(Max)
136 {
137 }
138
139 AMDGPUWavesPerEUAttr(SourceRange R, ASTContext &Ctx
140 , unsigned Min
141 , unsigned SI
142 )
143 : InheritableAttr(attr::AMDGPUWavesPerEU, R, SI, false, false)
144 , min(Min)
145 , max()
146 {
147 }
148
149 AMDGPUWavesPerEUAttr *clone(ASTContext &C) const;
150 void printPretty(raw_ostream &OS,
151 const PrintingPolicy &Policy) const;
152 const char *getSpelling() const;
153 unsigned getMin() const {
154 return min;
155 }
156
157 unsigned getMax() const {
158 return max;
159 }
160
161
162
163 static bool classof(const Attr *A) { return A->getKind() == attr::AMDGPUWavesPerEU; }
164};
165
166class ARMInterruptAttr : public InheritableAttr {
167public:
168 enum InterruptType {
169 IRQ,
170 FIQ,
171 SWI,
172 ABORT,
173 UNDEF,
174 Generic
175 };
176private:
177 InterruptType interrupt;
178
179public:
180 static ARMInterruptAttr *CreateImplicit(ASTContext &Ctx, InterruptType Interrupt, SourceRange Loc = SourceRange()) {
181 auto *A = new (Ctx) ARMInterruptAttr(Loc, Ctx, Interrupt, 0);
182 A->setImplicit(true);
183 return A;
184 }
185
186 ARMInterruptAttr(SourceRange R, ASTContext &Ctx
187 , InterruptType Interrupt
188 , unsigned SI
189 )
190 : InheritableAttr(attr::ARMInterrupt, R, SI, false, false)
191 , interrupt(Interrupt)
192 {
193 }
194
195 ARMInterruptAttr(SourceRange R, ASTContext &Ctx
196 , unsigned SI
197 )
198 : InheritableAttr(attr::ARMInterrupt, R, SI, false, false)
199 , interrupt(InterruptType(0))
200 {
201 }
202
203 ARMInterruptAttr *clone(ASTContext &C) const;
204 void printPretty(raw_ostream &OS,
205 const PrintingPolicy &Policy) const;
206 const char *getSpelling() const;
207 InterruptType getInterrupt() const {
208 return interrupt;
209 }
210
211 static bool ConvertStrToInterruptType(StringRef Val, InterruptType &Out) {
212 Optional<InterruptType> R = llvm::StringSwitch<Optional<InterruptType>>(Val)
213 .Case("IRQ", ARMInterruptAttr::IRQ)
214 .Case("FIQ", ARMInterruptAttr::FIQ)
215 .Case("SWI", ARMInterruptAttr::SWI)
216 .Case("ABORT", ARMInterruptAttr::ABORT)
217 .Case("UNDEF", ARMInterruptAttr::UNDEF)
218 .Case("", ARMInterruptAttr::Generic)
219 .Default(Optional<InterruptType>());
220 if (R) {
221 Out = *R;
222 return true;
223 }
224 return false;
225 }
226
227 static const char *ConvertInterruptTypeToStr(InterruptType Val) {
228 switch(Val) {
229 case ARMInterruptAttr::IRQ: return "IRQ";
230 case ARMInterruptAttr::FIQ: return "FIQ";
231 case ARMInterruptAttr::SWI: return "SWI";
232 case ARMInterruptAttr::ABORT: return "ABORT";
233 case ARMInterruptAttr::UNDEF: return "UNDEF";
234 case ARMInterruptAttr::Generic: return "";
235 }
236 llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 236)
;
237 }
238
239
240 static bool classof(const Attr *A) { return A->getKind() == attr::ARMInterrupt; }
241};
242
243class AVRInterruptAttr : public InheritableAttr {
244public:
245 static AVRInterruptAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
246 auto *A = new (Ctx) AVRInterruptAttr(Loc, Ctx, 0);
247 A->setImplicit(true);
248 return A;
249 }
250
251 AVRInterruptAttr(SourceRange R, ASTContext &Ctx
252 , unsigned SI
253 )
254 : InheritableAttr(attr::AVRInterrupt, R, SI, false, false)
255 {
256 }
257
258 AVRInterruptAttr *clone(ASTContext &C) const;
259 void printPretty(raw_ostream &OS,
260 const PrintingPolicy &Policy) const;
261 const char *getSpelling() const;
262
263
264 static bool classof(const Attr *A) { return A->getKind() == attr::AVRInterrupt; }
265};
266
267class AVRSignalAttr : public InheritableAttr {
268public:
269 static AVRSignalAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
270 auto *A = new (Ctx) AVRSignalAttr(Loc, Ctx, 0);
271 A->setImplicit(true);
272 return A;
273 }
274
275 AVRSignalAttr(SourceRange R, ASTContext &Ctx
276 , unsigned SI
277 )
278 : InheritableAttr(attr::AVRSignal, R, SI, false, false)
279 {
280 }
281
282 AVRSignalAttr *clone(ASTContext &C) const;
283 void printPretty(raw_ostream &OS,
284 const PrintingPolicy &Policy) const;
285 const char *getSpelling() const;
286
287
288 static bool classof(const Attr *A) { return A->getKind() == attr::AVRSignal; }
289};
290
291class AbiTagAttr : public Attr {
292 unsigned tags_Size;
293 StringRef *tags_;
294
295public:
296 static AbiTagAttr *CreateImplicit(ASTContext &Ctx, StringRef *Tags, unsigned TagsSize, SourceRange Loc = SourceRange()) {
297 auto *A = new (Ctx) AbiTagAttr(Loc, Ctx, Tags, TagsSize, 0);
298 A->setImplicit(true);
299 return A;
300 }
301
302 AbiTagAttr(SourceRange R, ASTContext &Ctx
303 , StringRef *Tags, unsigned TagsSize
304 , unsigned SI
305 )
306 : Attr(attr::AbiTag, R, SI, false)
307 , tags_Size(TagsSize), tags_(new (Ctx, 16) StringRef[tags_Size])
308 {
309 for (size_t I = 0, E = tags_Size; I != E;
310 ++I) {
311 StringRef Ref = Tags[I];
312 if (!Ref.empty()) {
313 char *Mem = new (Ctx, 1) char[Ref.size()];
314 std::memcpy(Mem, Ref.data(), Ref.size());
315 tags_[I] = StringRef(Mem, Ref.size());
316 }
317 }
318 }
319
320 AbiTagAttr(SourceRange R, ASTContext &Ctx
321 , unsigned SI
322 )
323 : Attr(attr::AbiTag, R, SI, false)
324 , tags_Size(0), tags_(nullptr)
325 {
326 }
327
328 AbiTagAttr *clone(ASTContext &C) const;
329 void printPretty(raw_ostream &OS,
330 const PrintingPolicy &Policy) const;
331 const char *getSpelling() const;
332 typedef StringRef* tags_iterator;
333 tags_iterator tags_begin() const { return tags_; }
334 tags_iterator tags_end() const { return tags_ + tags_Size; }
335 unsigned tags_size() const { return tags_Size; }
336 llvm::iterator_range<tags_iterator> tags() const { return llvm::make_range(tags_begin(), tags_end()); }
337
338
339
340
341 static bool classof(const Attr *A) { return A->getKind() == attr::AbiTag; }
342};
343
344class AcquireCapabilityAttr : public InheritableAttr {
345 unsigned args_Size;
346 Expr * *args_;
347
348public:
349 enum Spelling {
350 GNU_acquire_capability = 0,
351 CXX11_clang_acquire_capability = 1,
352 GNU_acquire_shared_capability = 2,
353 CXX11_clang_acquire_shared_capability = 3,
354 GNU_exclusive_lock_function = 4,
355 GNU_shared_lock_function = 5
356 };
357
358 static AcquireCapabilityAttr *CreateImplicit(ASTContext &Ctx, Spelling S, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
359 auto *A = new (Ctx) AcquireCapabilityAttr(Loc, Ctx, Args, ArgsSize, S);
360 A->setImplicit(true);
361 return A;
362 }
363
364 AcquireCapabilityAttr(SourceRange R, ASTContext &Ctx
365 , Expr * *Args, unsigned ArgsSize
366 , unsigned SI
367 )
368 : InheritableAttr(attr::AcquireCapability, R, SI, true, true)
369 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
370 {
371 std::copy(Args, Args + args_Size, args_);
372 }
373
374 AcquireCapabilityAttr(SourceRange R, ASTContext &Ctx
375 , unsigned SI
376 )
377 : InheritableAttr(attr::AcquireCapability, R, SI, true, true)
378 , args_Size(0), args_(nullptr)
379 {
380 }
381
382 AcquireCapabilityAttr *clone(ASTContext &C) const;
383 void printPretty(raw_ostream &OS,
384 const PrintingPolicy &Policy) const;
385 const char *getSpelling() const;
386 Spelling getSemanticSpelling() const {
387 switch (SpellingListIndex) {
388 default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 388)
;
389 case 0: return GNU_acquire_capability;
390 case 1: return CXX11_clang_acquire_capability;
391 case 2: return GNU_acquire_shared_capability;
392 case 3: return CXX11_clang_acquire_shared_capability;
393 case 4: return GNU_exclusive_lock_function;
394 case 5: return GNU_shared_lock_function;
395 }
396 }
397 bool isShared() const { return SpellingListIndex == 2 ||
398 SpellingListIndex == 3 ||
399 SpellingListIndex == 5; }
400 typedef Expr ** args_iterator;
401 args_iterator args_begin() const { return args_; }
402 args_iterator args_end() const { return args_ + args_Size; }
403 unsigned args_size() const { return args_Size; }
404 llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
405
406
407
408
409 static bool classof(const Attr *A) { return A->getKind() == attr::AcquireCapability; }
410};
411
412class AcquiredAfterAttr : public InheritableAttr {
413 unsigned args_Size;
414 Expr * *args_;
415
416public:
417 static AcquiredAfterAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
418 auto *A = new (Ctx) AcquiredAfterAttr(Loc, Ctx, Args, ArgsSize, 0);
419 A->setImplicit(true);
420 return A;
421 }
422
423 AcquiredAfterAttr(SourceRange R, ASTContext &Ctx
424 , Expr * *Args, unsigned ArgsSize
425 , unsigned SI
426 )
427 : InheritableAttr(attr::AcquiredAfter, R, SI, true, true)
428 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
429 {
430 std::copy(Args, Args + args_Size, args_);
431 }
432
433 AcquiredAfterAttr(SourceRange R, ASTContext &Ctx
434 , unsigned SI
435 )
436 : InheritableAttr(attr::AcquiredAfter, R, SI, true, true)
437 , args_Size(0), args_(nullptr)
438 {
439 }
440
441 AcquiredAfterAttr *clone(ASTContext &C) const;
442 void printPretty(raw_ostream &OS,
443 const PrintingPolicy &Policy) const;
444 const char *getSpelling() const;
445 typedef Expr ** args_iterator;
446 args_iterator args_begin() const { return args_; }
447 args_iterator args_end() const { return args_ + args_Size; }
448 unsigned args_size() const { return args_Size; }
449 llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
450
451
452
453
454 static bool classof(const Attr *A) { return A->getKind() == attr::AcquiredAfter; }
455};
456
457class AcquiredBeforeAttr : public InheritableAttr {
458 unsigned args_Size;
459 Expr * *args_;
460
461public:
462 static AcquiredBeforeAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
463 auto *A = new (Ctx) AcquiredBeforeAttr(Loc, Ctx, Args, ArgsSize, 0);
464 A->setImplicit(true);
465 return A;
466 }
467
468 AcquiredBeforeAttr(SourceRange R, ASTContext &Ctx
469 , Expr * *Args, unsigned ArgsSize
470 , unsigned SI
471 )
472 : InheritableAttr(attr::AcquiredBefore, R, SI, true, true)
473 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
474 {
475 std::copy(Args, Args + args_Size, args_);
476 }
477
478 AcquiredBeforeAttr(SourceRange R, ASTContext &Ctx
479 , unsigned SI
480 )
481 : InheritableAttr(attr::AcquiredBefore, R, SI, true, true)
482 , args_Size(0), args_(nullptr)
483 {
484 }
485
486 AcquiredBeforeAttr *clone(ASTContext &C) const;
487 void printPretty(raw_ostream &OS,
488 const PrintingPolicy &Policy) const;
489 const char *getSpelling() const;
490 typedef Expr ** args_iterator;
491 args_iterator args_begin() const { return args_; }
492 args_iterator args_end() const { return args_ + args_Size; }
493 unsigned args_size() const { return args_Size; }
494 llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
495
496
497
498
499 static bool classof(const Attr *A) { return A->getKind() == attr::AcquiredBefore; }
500};
501
502class AliasAttr : public Attr {
503unsigned aliaseeLength;
504char *aliasee;
505
506public:
507 static AliasAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Aliasee, SourceRange Loc = SourceRange()) {
508 auto *A = new (Ctx) AliasAttr(Loc, Ctx, Aliasee, 0);
509 A->setImplicit(true);
510 return A;
511 }
512
513 AliasAttr(SourceRange R, ASTContext &Ctx
514 , llvm::StringRef Aliasee
515 , unsigned SI
516 )
517 : Attr(attr::Alias, R, SI, false)
518 , aliaseeLength(Aliasee.size()),aliasee(new (Ctx, 1) char[aliaseeLength])
519 {
520 if (!Aliasee.empty())
521 std::memcpy(aliasee, Aliasee.data(), aliaseeLength);
522 }
523
524 AliasAttr *clone(ASTContext &C) const;
525 void printPretty(raw_ostream &OS,
526 const PrintingPolicy &Policy) const;
527 const char *getSpelling() const;
528 llvm::StringRef getAliasee() const {
529 return llvm::StringRef(aliasee, aliaseeLength);
530 }
531 unsigned getAliaseeLength() const {
532 return aliaseeLength;
533 }
534 void setAliasee(ASTContext &C, llvm::StringRef S) {
535 aliaseeLength = S.size();
536 this->aliasee = new (C, 1) char [aliaseeLength];
537 if (!S.empty())
538 std::memcpy(this->aliasee, S.data(), aliaseeLength);
539 }
540
541
542
543 static bool classof(const Attr *A) { return A->getKind() == attr::Alias; }
544};
545
546class AlignMac68kAttr : public InheritableAttr {
547public:
548 static AlignMac68kAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
549 auto *A = new (Ctx) AlignMac68kAttr(Loc, Ctx, 0);
550 A->setImplicit(true);
551 return A;
552 }
553
554 AlignMac68kAttr(SourceRange R, ASTContext &Ctx
555 , unsigned SI
556 )
557 : InheritableAttr(attr::AlignMac68k, R, SI, false, false)
558 {
559 }
560
561 AlignMac68kAttr *clone(ASTContext &C) const;
562 void printPretty(raw_ostream &OS,
563 const PrintingPolicy &Policy) const;
564 const char *getSpelling() const;
565
566
567 static bool classof(const Attr *A) { return A->getKind() == attr::AlignMac68k; }
568};
569
570class AlignValueAttr : public Attr {
571Expr * alignment;
572
573public:
574 static AlignValueAttr *CreateImplicit(ASTContext &Ctx, Expr * Alignment, SourceRange Loc = SourceRange()) {
575 auto *A = new (Ctx) AlignValueAttr(Loc, Ctx, Alignment, 0);
576 A->setImplicit(true);
577 return A;
578 }
579
580 AlignValueAttr(SourceRange R, ASTContext &Ctx
581 , Expr * Alignment
582 , unsigned SI
583 )
584 : Attr(attr::AlignValue, R, SI, false)
585 , alignment(Alignment)
586 {
587 }
588
589 AlignValueAttr *clone(ASTContext &C) const;
590 void printPretty(raw_ostream &OS,
591 const PrintingPolicy &Policy) const;
592 const char *getSpelling() const;
593 Expr * getAlignment() const {
594 return alignment;
595 }
596
597
598
599 static bool classof(const Attr *A) { return A->getKind() == attr::AlignValue; }
600};
601
602class AlignedAttr : public InheritableAttr {
603bool isalignmentExpr;
604union {
605Expr *alignmentExpr;
606TypeSourceInfo *alignmentType;
607};
608
609public:
610 enum Spelling {
611 GNU_aligned = 0,
612 CXX11_gnu_aligned = 1,
613 Declspec_align = 2,
614 Keyword_alignas = 3,
615 Keyword_Alignas = 4
616 };
617
618 static AlignedAttr *CreateImplicit(ASTContext &Ctx, Spelling S, bool IsAlignmentExpr, void *Alignment, SourceRange Loc = SourceRange()) {
619 auto *A = new (Ctx) AlignedAttr(Loc, Ctx, IsAlignmentExpr, Alignment, S);
620 A->setImplicit(true);
621 return A;
622 }
623
624 AlignedAttr(SourceRange R, ASTContext &Ctx
625 , bool IsAlignmentExpr, void *Alignment
626 , unsigned SI
627 )
628 : InheritableAttr(attr::Aligned, R, SI, false, false)
629 , isalignmentExpr(IsAlignmentExpr)
630 {
631 if (isalignmentExpr)
632 alignmentExpr = reinterpret_cast<Expr *>(Alignment);
633 else
634 alignmentType = reinterpret_cast<TypeSourceInfo *>(Alignment);
635 }
636
637 AlignedAttr(SourceRange R, ASTContext &Ctx
638 , unsigned SI
639 )
640 : InheritableAttr(attr::Aligned, R, SI, false, false)
641 , isalignmentExpr(false)
642 {
643 }
644
645 AlignedAttr *clone(ASTContext &C) const;
646 void printPretty(raw_ostream &OS,
647 const PrintingPolicy &Policy) const;
648 const char *getSpelling() const;
649 Spelling getSemanticSpelling() const {
650 switch (SpellingListIndex) {
651 default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 651)
;
652 case 0: return GNU_aligned;
653 case 1: return CXX11_gnu_aligned;
654 case 2: return Declspec_align;
655 case 3: return Keyword_alignas;
656 case 4: return Keyword_Alignas;
657 }
658 }
659 bool isGNU() const { return SpellingListIndex == 0 ||
660 SpellingListIndex == 1; }
661 bool isC11() const { return SpellingListIndex == 4; }
662 bool isAlignas() const { return SpellingListIndex == 3 ||
663 SpellingListIndex == 4; }
664 bool isDeclspec() const { return SpellingListIndex == 2; }
665 bool isAlignmentDependent() const;
666 unsigned getAlignment(ASTContext &Ctx) const;
667 bool isAlignmentExpr() const {
668 return isalignmentExpr;
669 }
670 Expr *getAlignmentExpr() const {
671 assert(isalignmentExpr)(static_cast <bool> (isalignmentExpr) ? void (0) : __assert_fail
("isalignmentExpr", "/build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 671, __extension__ __PRETTY_FUNCTION__))
;
672 return alignmentExpr;
673 }
674 TypeSourceInfo *getAlignmentType() const {
675 assert(!isalignmentExpr)(static_cast <bool> (!isalignmentExpr) ? void (0) : __assert_fail
("!isalignmentExpr", "/build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 675, __extension__ __PRETTY_FUNCTION__))
;
676 return alignmentType;
677 }
678
679
680
681 static bool classof(const Attr *A) { return A->getKind() == attr::Aligned; }
682};
683
684class AllocAlignAttr : public InheritableAttr {
685ParamIdx paramIndex;
686
687public:
688 static AllocAlignAttr *CreateImplicit(ASTContext &Ctx, ParamIdx ParamIndex, SourceRange Loc = SourceRange()) {
689 auto *A = new (Ctx) AllocAlignAttr(Loc, Ctx, ParamIndex, 0);
690 A->setImplicit(true);
691 return A;
692 }
693
694 AllocAlignAttr(SourceRange R, ASTContext &Ctx
695 , ParamIdx ParamIndex
696 , unsigned SI
697 )
698 : InheritableAttr(attr::AllocAlign, R, SI, false, false)
699 , paramIndex(ParamIndex)
700 {
701 }
702
703 AllocAlignAttr *clone(ASTContext &C) const;
704 void printPretty(raw_ostream &OS,
705 const PrintingPolicy &Policy) const;
706 const char *getSpelling() const;
707 ParamIdx getParamIndex() const {
708 return paramIndex;
709 }
710
711
712
713 static bool classof(const Attr *A) { return A->getKind() == attr::AllocAlign; }
714};
715
716class AllocSizeAttr : public InheritableAttr {
717ParamIdx elemSizeParam;
718
719ParamIdx numElemsParam;
720
721public:
722 static AllocSizeAttr *CreateImplicit(ASTContext &Ctx, ParamIdx ElemSizeParam, ParamIdx NumElemsParam, SourceRange Loc = SourceRange()) {
723 auto *A = new (Ctx) AllocSizeAttr(Loc, Ctx, ElemSizeParam, NumElemsParam, 0);
724 A->setImplicit(true);
725 return A;
726 }
727
728 AllocSizeAttr(SourceRange R, ASTContext &Ctx
729 , ParamIdx ElemSizeParam
730 , ParamIdx NumElemsParam
731 , unsigned SI
732 )
733 : InheritableAttr(attr::AllocSize, R, SI, false, false)
734 , elemSizeParam(ElemSizeParam)
735 , numElemsParam(NumElemsParam)
736 {
737 }
738
739 AllocSizeAttr(SourceRange R, ASTContext &Ctx
740 , ParamIdx ElemSizeParam
741 , unsigned SI
742 )
743 : InheritableAttr(attr::AllocSize, R, SI, false, false)
744 , elemSizeParam(ElemSizeParam)
745 , numElemsParam()
746 {
747 }
748
749 AllocSizeAttr *clone(ASTContext &C) const;
750 void printPretty(raw_ostream &OS,
751 const PrintingPolicy &Policy) const;
752 const char *getSpelling() const;
753 ParamIdx getElemSizeParam() const {
754 return elemSizeParam;
755 }
756
757 ParamIdx getNumElemsParam() const {
758 return numElemsParam;
759 }
760
761
762
763 static bool classof(const Attr *A) { return A->getKind() == attr::AllocSize; }
764};
765
766class AlwaysInlineAttr : public InheritableAttr {
767public:
768 enum Spelling {
769 GNU_always_inline = 0,
770 CXX11_gnu_always_inline = 1,
771 Keyword_forceinline = 2
772 };
773
774 static AlwaysInlineAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) {
775 auto *A = new (Ctx) AlwaysInlineAttr(Loc, Ctx, S);
776 A->setImplicit(true);
777 return A;
778 }
779
780 AlwaysInlineAttr(SourceRange R, ASTContext &Ctx
781 , unsigned SI
782 )
783 : InheritableAttr(attr::AlwaysInline, R, SI, false, false)
784 {
785 }
786
787 AlwaysInlineAttr *clone(ASTContext &C) const;
788 void printPretty(raw_ostream &OS,
789 const PrintingPolicy &Policy) const;
790 const char *getSpelling() const;
791 Spelling getSemanticSpelling() const {
792 switch (SpellingListIndex) {
793 default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 793)
;
794 case 0: return GNU_always_inline;
795 case 1: return CXX11_gnu_always_inline;
796 case 2: return Keyword_forceinline;
797 }
798 }
799
800
801 static bool classof(const Attr *A) { return A->getKind() == attr::AlwaysInline; }
802};
803
804class AnalyzerNoReturnAttr : public InheritableAttr {
805public:
806 static AnalyzerNoReturnAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
807 auto *A = new (Ctx) AnalyzerNoReturnAttr(Loc, Ctx, 0);
808 A->setImplicit(true);
809 return A;
810 }
811
812 AnalyzerNoReturnAttr(SourceRange R, ASTContext &Ctx
813 , unsigned SI
814 )
815 : InheritableAttr(attr::AnalyzerNoReturn, R, SI, false, false)
816 {
817 }
818
819 AnalyzerNoReturnAttr *clone(ASTContext &C) const;
820 void printPretty(raw_ostream &OS,
821 const PrintingPolicy &Policy) const;
822 const char *getSpelling() const;
823
824
825 static bool classof(const Attr *A) { return A->getKind() == attr::AnalyzerNoReturn; }
826};
827
828class AnnotateAttr : public InheritableParamAttr {
829unsigned annotationLength;
830char *annotation;
831
832public:
833 static AnnotateAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Annotation, SourceRange Loc = SourceRange()) {
834 auto *A = new (Ctx) AnnotateAttr(Loc, Ctx, Annotation, 0);
835 A->setImplicit(true);
836 return A;
837 }
838
839 AnnotateAttr(SourceRange R, ASTContext &Ctx
840 , llvm::StringRef Annotation
841 , unsigned SI
842 )
843 : InheritableParamAttr(attr::Annotate, R, SI, false, false)
844 , annotationLength(Annotation.size()),annotation(new (Ctx, 1) char[annotationLength])
845 {
846 if (!Annotation.empty())
847 std::memcpy(annotation, Annotation.data(), annotationLength);
848 }
849
850 AnnotateAttr *clone(ASTContext &C) const;
851 void printPretty(raw_ostream &OS,
852 const PrintingPolicy &Policy) const;
853 const char *getSpelling() const;
854 llvm::StringRef getAnnotation() const {
855 return llvm::StringRef(annotation, annotationLength);
856 }
857 unsigned getAnnotationLength() const {
858 return annotationLength;
859 }
860 void setAnnotation(ASTContext &C, llvm::StringRef S) {
861 annotationLength = S.size();
862 this->annotation = new (C, 1) char [annotationLength];
863 if (!S.empty())
864 std::memcpy(this->annotation, S.data(), annotationLength);
865 }
866
867
868
869 static bool classof(const Attr *A) { return A->getKind() == attr::Annotate; }
870};
871
872class AnyX86InterruptAttr : public InheritableAttr {
873public:
874 static AnyX86InterruptAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
875 auto *A = new (Ctx) AnyX86InterruptAttr(Loc, Ctx, 0);
876 A->setImplicit(true);
877 return A;
878 }
879
880 AnyX86InterruptAttr(SourceRange R, ASTContext &Ctx
881 , unsigned SI
882 )
883 : InheritableAttr(attr::AnyX86Interrupt, R, SI, false, false)
884 {
885 }
886
887 AnyX86InterruptAttr *clone(ASTContext &C) const;
888 void printPretty(raw_ostream &OS,
889 const PrintingPolicy &Policy) const;
890 const char *getSpelling() const;
891
892
893 static bool classof(const Attr *A) { return A->getKind() == attr::AnyX86Interrupt; }
894};
895
896class AnyX86NoCallerSavedRegistersAttr : public InheritableAttr {
897public:
898 static AnyX86NoCallerSavedRegistersAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
899 auto *A = new (Ctx) AnyX86NoCallerSavedRegistersAttr(Loc, Ctx, 0);
900 A->setImplicit(true);
901 return A;
902 }
903
904 AnyX86NoCallerSavedRegistersAttr(SourceRange R, ASTContext &Ctx
905 , unsigned SI
906 )
907 : InheritableAttr(attr::AnyX86NoCallerSavedRegisters, R, SI, false, false)
908 {
909 }
910
911 AnyX86NoCallerSavedRegistersAttr *clone(ASTContext &C) const;
912 void printPretty(raw_ostream &OS,
913 const PrintingPolicy &Policy) const;
914 const char *getSpelling() const;
915
916
917 static bool classof(const Attr *A) { return A->getKind() == attr::AnyX86NoCallerSavedRegisters; }
918};
919
920class AnyX86NoCfCheckAttr : public InheritableAttr {
921public:
922 static AnyX86NoCfCheckAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
923 auto *A = new (Ctx) AnyX86NoCfCheckAttr(Loc, Ctx, 0);
924 A->setImplicit(true);
925 return A;
926 }
927
928 AnyX86NoCfCheckAttr(SourceRange R, ASTContext &Ctx
929 , unsigned SI
930 )
931 : InheritableAttr(attr::AnyX86NoCfCheck, R, SI, false, false)
932 {
933 }
934
935 AnyX86NoCfCheckAttr *clone(ASTContext &C) const;
936 void printPretty(raw_ostream &OS,
937 const PrintingPolicy &Policy) const;
938 const char *getSpelling() const;
939
940
941 static bool classof(const Attr *A) { return A->getKind() == attr::AnyX86NoCfCheck; }
942};
943
944class ArcWeakrefUnavailableAttr : public InheritableAttr {
945public:
946 static ArcWeakrefUnavailableAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
947 auto *A = new (Ctx) ArcWeakrefUnavailableAttr(Loc, Ctx, 0);
948 A->setImplicit(true);
949 return A;
950 }
951
952 ArcWeakrefUnavailableAttr(SourceRange R, ASTContext &Ctx
953 , unsigned SI
954 )
955 : InheritableAttr(attr::ArcWeakrefUnavailable, R, SI, false, false)
956 {
957 }
958
959 ArcWeakrefUnavailableAttr *clone(ASTContext &C) const;
960 void printPretty(raw_ostream &OS,
961 const PrintingPolicy &Policy) const;
962 const char *getSpelling() const;
963
964
965 static bool classof(const Attr *A) { return A->getKind() == attr::ArcWeakrefUnavailable; }
966};
967
968class ArgumentWithTypeTagAttr : public InheritableAttr {
969IdentifierInfo * argumentKind;
970
971ParamIdx argumentIdx;
972
973ParamIdx typeTagIdx;
974
975bool isPointer;
976
977public:
978 enum Spelling {
979 GNU_argument_with_type_tag = 0,
980 CXX11_clang_argument_with_type_tag = 1,
981 C2x_clang_argument_with_type_tag = 2,
982 GNU_pointer_with_type_tag = 3,
983 CXX11_clang_pointer_with_type_tag = 4,
984 C2x_clang_pointer_with_type_tag = 5
985 };
986
987 static ArgumentWithTypeTagAttr *CreateImplicit(ASTContext &Ctx, Spelling S, IdentifierInfo * ArgumentKind, ParamIdx ArgumentIdx, ParamIdx TypeTagIdx, bool IsPointer, SourceRange Loc = SourceRange()) {
988 auto *A = new (Ctx) ArgumentWithTypeTagAttr(Loc, Ctx, ArgumentKind, ArgumentIdx, TypeTagIdx, IsPointer, S);
989 A->setImplicit(true);
990 return A;
991 }
992
993 static ArgumentWithTypeTagAttr *CreateImplicit(ASTContext &Ctx, Spelling S, IdentifierInfo * ArgumentKind, ParamIdx ArgumentIdx, ParamIdx TypeTagIdx, SourceRange Loc = SourceRange()) {
994 auto *A = new (Ctx) ArgumentWithTypeTagAttr(Loc, Ctx, ArgumentKind, ArgumentIdx, TypeTagIdx, S);
995 A->setImplicit(true);
996 return A;
997 }
998
999 ArgumentWithTypeTagAttr(SourceRange R, ASTContext &Ctx
1000 , IdentifierInfo * ArgumentKind
1001 , ParamIdx ArgumentIdx
1002 , ParamIdx TypeTagIdx
1003 , bool IsPointer
1004 , unsigned SI
1005 )
1006 : InheritableAttr(attr::ArgumentWithTypeTag, R, SI, false, false)
1007 , argumentKind(ArgumentKind)
1008 , argumentIdx(ArgumentIdx)
1009 , typeTagIdx(TypeTagIdx)
1010 , isPointer(IsPointer)
1011 {
1012 }
1013
1014 ArgumentWithTypeTagAttr(SourceRange R, ASTContext &Ctx
1015 , IdentifierInfo * ArgumentKind
1016 , ParamIdx ArgumentIdx
1017 , ParamIdx TypeTagIdx
1018 , unsigned SI
1019 )
1020 : InheritableAttr(attr::ArgumentWithTypeTag, R, SI, false, false)
1021 , argumentKind(ArgumentKind)
1022 , argumentIdx(ArgumentIdx)
1023 , typeTagIdx(TypeTagIdx)
1024 , isPointer()
1025 {
1026 }
1027
1028 ArgumentWithTypeTagAttr *clone(ASTContext &C) const;
1029 void printPretty(raw_ostream &OS,
1030 const PrintingPolicy &Policy) const;
1031 const char *getSpelling() const;
1032 Spelling getSemanticSpelling() const {
1033 switch (SpellingListIndex) {
1034 default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 1034)
;
1035 case 0: return GNU_argument_with_type_tag;
1036 case 1: return CXX11_clang_argument_with_type_tag;
1037 case 2: return C2x_clang_argument_with_type_tag;
1038 case 3: return GNU_pointer_with_type_tag;
1039 case 4: return CXX11_clang_pointer_with_type_tag;
1040 case 5: return C2x_clang_pointer_with_type_tag;
1041 }
1042 }
1043 IdentifierInfo * getArgumentKind() const {
1044 return argumentKind;
1045 }
1046
1047 ParamIdx getArgumentIdx() const {
1048 return argumentIdx;
1049 }
1050
1051 ParamIdx getTypeTagIdx() const {
1052 return typeTagIdx;
1053 }
1054
1055 bool getIsPointer() const {
1056 return isPointer;
1057 }
1058
1059
1060
1061 static bool classof(const Attr *A) { return A->getKind() == attr::ArgumentWithTypeTag; }
1062};
1063
1064class ArtificialAttr : public InheritableAttr {
1065public:
1066 static ArtificialAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1067 auto *A = new (Ctx) ArtificialAttr(Loc, Ctx, 0);
1068 A->setImplicit(true);
1069 return A;
1070 }
1071
1072 ArtificialAttr(SourceRange R, ASTContext &Ctx
1073 , unsigned SI
1074 )
1075 : InheritableAttr(attr::Artificial, R, SI, false, false)
1076 {
1077 }
1078
1079 ArtificialAttr *clone(ASTContext &C) const;
1080 void printPretty(raw_ostream &OS,
1081 const PrintingPolicy &Policy) const;
1082 const char *getSpelling() const;
1083
1084
1085 static bool classof(const Attr *A) { return A->getKind() == attr::Artificial; }
1086};
1087
1088class AsmLabelAttr : public InheritableAttr {
1089unsigned labelLength;
1090char *label;
1091
1092public:
1093 static AsmLabelAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Label, SourceRange Loc = SourceRange()) {
1094 auto *A = new (Ctx) AsmLabelAttr(Loc, Ctx, Label, 0);
1095 A->setImplicit(true);
1096 return A;
1097 }
1098
1099 AsmLabelAttr(SourceRange R, ASTContext &Ctx
1100 , llvm::StringRef Label
1101 , unsigned SI
1102 )
1103 : InheritableAttr(attr::AsmLabel, R, SI, false, false)
1104 , labelLength(Label.size()),label(new (Ctx, 1) char[labelLength])
1105 {
1106 if (!Label.empty())
1107 std::memcpy(label, Label.data(), labelLength);
1108 }
1109
1110 AsmLabelAttr *clone(ASTContext &C) const;
1111 void printPretty(raw_ostream &OS,
1112 const PrintingPolicy &Policy) const;
1113 const char *getSpelling() const;
1114 llvm::StringRef getLabel() const {
1115 return llvm::StringRef(label, labelLength);
1116 }
1117 unsigned getLabelLength() const {
1118 return labelLength;
1119 }
1120 void setLabel(ASTContext &C, llvm::StringRef S) {
1121 labelLength = S.size();
1122 this->label = new (C, 1) char [labelLength];
1123 if (!S.empty())
1124 std::memcpy(this->label, S.data(), labelLength);
1125 }
1126
1127
1128
1129 static bool classof(const Attr *A) { return A->getKind() == attr::AsmLabel; }
1130};
1131
1132class AssertCapabilityAttr : public InheritableAttr {
1133 unsigned args_Size;
1134 Expr * *args_;
1135
1136public:
1137 enum Spelling {
1138 GNU_assert_capability = 0,
1139 CXX11_clang_assert_capability = 1,
1140 GNU_assert_shared_capability = 2,
1141 CXX11_clang_assert_shared_capability = 3
1142 };
1143
1144 static AssertCapabilityAttr *CreateImplicit(ASTContext &Ctx, Spelling S, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
1145 auto *A = new (Ctx) AssertCapabilityAttr(Loc, Ctx, Args, ArgsSize, S);
1146 A->setImplicit(true);
1147 return A;
1148 }
1149
1150 AssertCapabilityAttr(SourceRange R, ASTContext &Ctx
1151 , Expr * *Args, unsigned ArgsSize
1152 , unsigned SI
1153 )
1154 : InheritableAttr(attr::AssertCapability, R, SI, true, true)
1155 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
1156 {
1157 std::copy(Args, Args + args_Size, args_);
1158 }
1159
1160 AssertCapabilityAttr(SourceRange R, ASTContext &Ctx
1161 , unsigned SI
1162 )
1163 : InheritableAttr(attr::AssertCapability, R, SI, true, true)
1164 , args_Size(0), args_(nullptr)
1165 {
1166 }
1167
1168 AssertCapabilityAttr *clone(ASTContext &C) const;
1169 void printPretty(raw_ostream &OS,
1170 const PrintingPolicy &Policy) const;
1171 const char *getSpelling() const;
1172 Spelling getSemanticSpelling() const {
1173 switch (SpellingListIndex) {
1174 default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 1174)
;
1175 case 0: return GNU_assert_capability;
1176 case 1: return CXX11_clang_assert_capability;
1177 case 2: return GNU_assert_shared_capability;
1178 case 3: return CXX11_clang_assert_shared_capability;
1179 }
1180 }
1181 bool isShared() const { return SpellingListIndex == 2 ||
1182 SpellingListIndex == 3; }
1183 typedef Expr ** args_iterator;
1184 args_iterator args_begin() const { return args_; }
1185 args_iterator args_end() const { return args_ + args_Size; }
1186 unsigned args_size() const { return args_Size; }
1187 llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
1188
1189
1190
1191
1192 static bool classof(const Attr *A) { return A->getKind() == attr::AssertCapability; }
1193};
1194
1195class AssertExclusiveLockAttr : public InheritableAttr {
1196 unsigned args_Size;
1197 Expr * *args_;
1198
1199public:
1200 static AssertExclusiveLockAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
1201 auto *A = new (Ctx) AssertExclusiveLockAttr(Loc, Ctx, Args, ArgsSize, 0);
1202 A->setImplicit(true);
1203 return A;
1204 }
1205
1206 AssertExclusiveLockAttr(SourceRange R, ASTContext &Ctx
1207 , Expr * *Args, unsigned ArgsSize
1208 , unsigned SI
1209 )
1210 : InheritableAttr(attr::AssertExclusiveLock, R, SI, true, true)
1211 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
1212 {
1213 std::copy(Args, Args + args_Size, args_);
1214 }
1215
1216 AssertExclusiveLockAttr(SourceRange R, ASTContext &Ctx
1217 , unsigned SI
1218 )
1219 : InheritableAttr(attr::AssertExclusiveLock, R, SI, true, true)
1220 , args_Size(0), args_(nullptr)
1221 {
1222 }
1223
1224 AssertExclusiveLockAttr *clone(ASTContext &C) const;
1225 void printPretty(raw_ostream &OS,
1226 const PrintingPolicy &Policy) const;
1227 const char *getSpelling() const;
1228 typedef Expr ** args_iterator;
1229 args_iterator args_begin() const { return args_; }
1230 args_iterator args_end() const { return args_ + args_Size; }
1231 unsigned args_size() const { return args_Size; }
1232 llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
1233
1234
1235
1236
1237 static bool classof(const Attr *A) { return A->getKind() == attr::AssertExclusiveLock; }
1238};
1239
1240class AssertSharedLockAttr : public InheritableAttr {
1241 unsigned args_Size;
1242 Expr * *args_;
1243
1244public:
1245 static AssertSharedLockAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
1246 auto *A = new (Ctx) AssertSharedLockAttr(Loc, Ctx, Args, ArgsSize, 0);
1247 A->setImplicit(true);
1248 return A;
1249 }
1250
1251 AssertSharedLockAttr(SourceRange R, ASTContext &Ctx
1252 , Expr * *Args, unsigned ArgsSize
1253 , unsigned SI
1254 )
1255 : InheritableAttr(attr::AssertSharedLock, R, SI, true, true)
1256 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
1257 {
1258 std::copy(Args, Args + args_Size, args_);
1259 }
1260
1261 AssertSharedLockAttr(SourceRange R, ASTContext &Ctx
1262 , unsigned SI
1263 )
1264 : InheritableAttr(attr::AssertSharedLock, R, SI, true, true)
1265 , args_Size(0), args_(nullptr)
1266 {
1267 }
1268
1269 AssertSharedLockAttr *clone(ASTContext &C) const;
1270 void printPretty(raw_ostream &OS,
1271 const PrintingPolicy &Policy) const;
1272 const char *getSpelling() const;
1273 typedef Expr ** args_iterator;
1274 args_iterator args_begin() const { return args_; }
1275 args_iterator args_end() const { return args_ + args_Size; }
1276 unsigned args_size() const { return args_Size; }
1277 llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
1278
1279
1280
1281
1282 static bool classof(const Attr *A) { return A->getKind() == attr::AssertSharedLock; }
1283};
1284
1285class AssumeAlignedAttr : public InheritableAttr {
1286Expr * alignment;
1287
1288Expr * offset;
1289
1290public:
1291 static AssumeAlignedAttr *CreateImplicit(ASTContext &Ctx, Expr * Alignment, Expr * Offset, SourceRange Loc = SourceRange()) {
1292 auto *A = new (Ctx) AssumeAlignedAttr(Loc, Ctx, Alignment, Offset, 0);
1293 A->setImplicit(true);
1294 return A;
1295 }
1296
1297 AssumeAlignedAttr(SourceRange R, ASTContext &Ctx
1298 , Expr * Alignment
1299 , Expr * Offset
1300 , unsigned SI
1301 )
1302 : InheritableAttr(attr::AssumeAligned, R, SI, false, false)
1303 , alignment(Alignment)
1304 , offset(Offset)
1305 {
1306 }
1307
1308 AssumeAlignedAttr(SourceRange R, ASTContext &Ctx
1309 , Expr * Alignment
1310 , unsigned SI
1311 )
1312 : InheritableAttr(attr::AssumeAligned, R, SI, false, false)
1313 , alignment(Alignment)
1314 , offset()
1315 {
1316 }
1317
1318 AssumeAlignedAttr *clone(ASTContext &C) const;
1319 void printPretty(raw_ostream &OS,
1320 const PrintingPolicy &Policy) const;
1321 const char *getSpelling() const;
1322 Expr * getAlignment() const {
1323 return alignment;
1324 }
1325
1326 Expr * getOffset() const {
1327 return offset;
1328 }
1329
1330
1331
1332 static bool classof(const Attr *A) { return A->getKind() == attr::AssumeAligned; }
1333};
1334
1335class AvailabilityAttr : public InheritableAttr {
1336IdentifierInfo * platform;
1337
1338VersionTuple introduced;
1339
1340
1341VersionTuple deprecated;
1342
1343
1344VersionTuple obsoleted;
1345
1346
1347bool unavailable;
1348
1349unsigned messageLength;
1350char *message;
1351
1352bool strict;
1353
1354unsigned replacementLength;
1355char *replacement;
1356
1357public:
1358 static AvailabilityAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * Platform, VersionTuple Introduced, VersionTuple Deprecated, VersionTuple Obsoleted, bool Unavailable, llvm::StringRef Message, bool Strict, llvm::StringRef Replacement, SourceRange Loc = SourceRange()) {
1359 auto *A = new (Ctx) AvailabilityAttr(Loc, Ctx, Platform, Introduced, Deprecated, Obsoleted, Unavailable, Message, Strict, Replacement, 0);
1360 A->setImplicit(true);
1361 return A;
1362 }
1363
1364 AvailabilityAttr(SourceRange R, ASTContext &Ctx
1365 , IdentifierInfo * Platform
1366 , VersionTuple Introduced
1367 , VersionTuple Deprecated
1368 , VersionTuple Obsoleted
1369 , bool Unavailable
1370 , llvm::StringRef Message
1371 , bool Strict
1372 , llvm::StringRef Replacement
1373 , unsigned SI
1374 )
1375 : InheritableAttr(attr::Availability, R, SI, false, true)
1376 , platform(Platform)
1377 , introduced(Introduced)
1378 , deprecated(Deprecated)
1379 , obsoleted(Obsoleted)
1380 , unavailable(Unavailable)
1381 , messageLength(Message.size()),message(new (Ctx, 1) char[messageLength])
1382 , strict(Strict)
1383 , replacementLength(Replacement.size()),replacement(new (Ctx, 1) char[replacementLength])
1384 {
1385 if (!Message.empty())
1386 std::memcpy(message, Message.data(), messageLength);
1387 if (!Replacement.empty())
1388 std::memcpy(replacement, Replacement.data(), replacementLength);
1389 }
1390
1391 AvailabilityAttr *clone(ASTContext &C) const;
1392 void printPretty(raw_ostream &OS,
1393 const PrintingPolicy &Policy) const;
1394 const char *getSpelling() const;
1395 IdentifierInfo * getPlatform() const {
1396 return platform;
1397 }
1398
1399 VersionTuple getIntroduced() const {
1400 return introduced;
1401 }
1402 void setIntroduced(ASTContext &C, VersionTuple V) {
1403 introduced = V;
1404 }
1405
1406 VersionTuple getDeprecated() const {
1407 return deprecated;
1408 }
1409 void setDeprecated(ASTContext &C, VersionTuple V) {
1410 deprecated = V;
1411 }
1412
1413 VersionTuple getObsoleted() const {
1414 return obsoleted;
1415 }
1416 void setObsoleted(ASTContext &C, VersionTuple V) {
1417 obsoleted = V;
1418 }
1419
1420 bool getUnavailable() const {
1421 return unavailable;
1422 }
1423
1424 llvm::StringRef getMessage() const {
1425 return llvm::StringRef(message, messageLength);
1426 }
1427 unsigned getMessageLength() const {
1428 return messageLength;
1429 }
1430 void setMessage(ASTContext &C, llvm::StringRef S) {
1431 messageLength = S.size();
1432 this->message = new (C, 1) char [messageLength];
1433 if (!S.empty())
1434 std::memcpy(this->message, S.data(), messageLength);
1435 }
1436
1437 bool getStrict() const {
1438 return strict;
1439 }
1440
1441 llvm::StringRef getReplacement() const {
1442 return llvm::StringRef(replacement, replacementLength);
1443 }
1444 unsigned getReplacementLength() const {
1445 return replacementLength;
1446 }
1447 void setReplacement(ASTContext &C, llvm::StringRef S) {
1448 replacementLength = S.size();
1449 this->replacement = new (C, 1) char [replacementLength];
1450 if (!S.empty())
1451 std::memcpy(this->replacement, S.data(), replacementLength);
1452 }
1453
1454static llvm::StringRef getPrettyPlatformName(llvm::StringRef Platform) {
1455 return llvm::StringSwitch<llvm::StringRef>(Platform)
1456 .Case("android", "Android")
1457 .Case("ios", "iOS")
1458 .Case("macos", "macOS")
1459 .Case("tvos", "tvOS")
1460 .Case("watchos", "watchOS")
1461 .Case("ios_app_extension", "iOS (App Extension)")
1462 .Case("macos_app_extension", "macOS (App Extension)")
1463 .Case("tvos_app_extension", "tvOS (App Extension)")
1464 .Case("watchos_app_extension", "watchOS (App Extension)")
1465 .Default(llvm::StringRef());
1466}
1467static llvm::StringRef getPlatformNameSourceSpelling(llvm::StringRef Platform) {
1468 return llvm::StringSwitch<llvm::StringRef>(Platform)
1469 .Case("ios", "iOS")
1470 .Case("macos", "macOS")
1471 .Case("tvos", "tvOS")
1472 .Case("watchos", "watchOS")
1473 .Case("ios_app_extension", "iOSApplicationExtension")
1474 .Case("macos_app_extension", "macOSApplicationExtension")
1475 .Case("tvos_app_extension", "tvOSApplicationExtension")
1476 .Case("watchos_app_extension", "watchOSApplicationExtension")
1477 .Default(Platform);
1478}
1479static llvm::StringRef canonicalizePlatformName(llvm::StringRef Platform) {
1480 return llvm::StringSwitch<llvm::StringRef>(Platform)
1481 .Case("iOS", "ios")
1482 .Case("macOS", "macos")
1483 .Case("tvOS", "tvos")
1484 .Case("watchOS", "watchos")
1485 .Case("iOSApplicationExtension", "ios_app_extension")
1486 .Case("macOSApplicationExtension", "macos_app_extension")
1487 .Case("tvOSApplicationExtension", "tvos_app_extension")
1488 .Case("watchOSApplicationExtension", "watchos_app_extension")
1489 .Default(Platform);
1490}
1491
1492 static bool classof(const Attr *A) { return A->getKind() == attr::Availability; }
1493};
1494
1495class BlocksAttr : public InheritableAttr {
1496public:
1497 enum BlockType {
1498 ByRef
1499 };
1500private:
1501 BlockType type;
1502
1503public:
1504 static BlocksAttr *CreateImplicit(ASTContext &Ctx, BlockType Type, SourceRange Loc = SourceRange()) {
1505 auto *A = new (Ctx) BlocksAttr(Loc, Ctx, Type, 0);
1506 A->setImplicit(true);
1507 return A;
1508 }
1509
1510 BlocksAttr(SourceRange R, ASTContext &Ctx
1511 , BlockType Type
1512 , unsigned SI
1513 )
1514 : InheritableAttr(attr::Blocks, R, SI, false, false)
1515 , type(Type)
1516 {
1517 }
1518
1519 BlocksAttr *clone(ASTContext &C) const;
1520 void printPretty(raw_ostream &OS,
1521 const PrintingPolicy &Policy) const;
1522 const char *getSpelling() const;
1523 BlockType getType() const {
1524 return type;
1525 }
1526
1527 static bool ConvertStrToBlockType(StringRef Val, BlockType &Out) {
1528 Optional<BlockType> R = llvm::StringSwitch<Optional<BlockType>>(Val)
1529 .Case("byref", BlocksAttr::ByRef)
1530 .Default(Optional<BlockType>());
1531 if (R) {
1532 Out = *R;
1533 return true;
1534 }
1535 return false;
1536 }
1537
1538 static const char *ConvertBlockTypeToStr(BlockType Val) {
1539 switch(Val) {
1540 case BlocksAttr::ByRef: return "byref";
1541 }
1542 llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 1542)
;
1543 }
1544
1545
1546 static bool classof(const Attr *A) { return A->getKind() == attr::Blocks; }
1547};
1548
1549class C11NoReturnAttr : public InheritableAttr {
1550public:
1551 static C11NoReturnAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1552 auto *A = new (Ctx) C11NoReturnAttr(Loc, Ctx, 0);
1553 A->setImplicit(true);
1554 return A;
1555 }
1556
1557 C11NoReturnAttr(SourceRange R, ASTContext &Ctx
1558 , unsigned SI
1559 )
1560 : InheritableAttr(attr::C11NoReturn, R, SI, false, false)
1561 {
1562 }
1563
1564 C11NoReturnAttr *clone(ASTContext &C) const;
1565 void printPretty(raw_ostream &OS,
1566 const PrintingPolicy &Policy) const;
1567 const char *getSpelling() const;
1568
1569
1570 static bool classof(const Attr *A) { return A->getKind() == attr::C11NoReturn; }
1571};
1572
1573class CDeclAttr : public InheritableAttr {
1574public:
1575 static CDeclAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1576 auto *A = new (Ctx) CDeclAttr(Loc, Ctx, 0);
1577 A->setImplicit(true);
1578 return A;
1579 }
1580
1581 CDeclAttr(SourceRange R, ASTContext &Ctx
1582 , unsigned SI
1583 )
1584 : InheritableAttr(attr::CDecl, R, SI, false, false)
1585 {
1586 }
1587
1588 CDeclAttr *clone(ASTContext &C) const;
1589 void printPretty(raw_ostream &OS,
1590 const PrintingPolicy &Policy) const;
1591 const char *getSpelling() const;
1592
1593
1594 static bool classof(const Attr *A) { return A->getKind() == attr::CDecl; }
1595};
1596
1597class CFAuditedTransferAttr : public InheritableAttr {
1598public:
1599 static CFAuditedTransferAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1600 auto *A = new (Ctx) CFAuditedTransferAttr(Loc, Ctx, 0);
1601 A->setImplicit(true);
1602 return A;
1603 }
1604
1605 CFAuditedTransferAttr(SourceRange R, ASTContext &Ctx
1606 , unsigned SI
1607 )
1608 : InheritableAttr(attr::CFAuditedTransfer, R, SI, false, false)
1609 {
1610 }
1611
1612 CFAuditedTransferAttr *clone(ASTContext &C) const;
1613 void printPretty(raw_ostream &OS,
1614 const PrintingPolicy &Policy) const;
1615 const char *getSpelling() const;
1616
1617
1618 static bool classof(const Attr *A) { return A->getKind() == attr::CFAuditedTransfer; }
1619};
1620
1621class CFConsumedAttr : public InheritableParamAttr {
1622public:
1623 static CFConsumedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1624 auto *A = new (Ctx) CFConsumedAttr(Loc, Ctx, 0);
1625 A->setImplicit(true);
1626 return A;
1627 }
1628
1629 CFConsumedAttr(SourceRange R, ASTContext &Ctx
1630 , unsigned SI
1631 )
1632 : InheritableParamAttr(attr::CFConsumed, R, SI, false, false)
1633 {
1634 }
1635
1636 CFConsumedAttr *clone(ASTContext &C) const;
1637 void printPretty(raw_ostream &OS,
1638 const PrintingPolicy &Policy) const;
1639 const char *getSpelling() const;
1640
1641
1642 static bool classof(const Attr *A) { return A->getKind() == attr::CFConsumed; }
1643};
1644
1645class CFReturnsNotRetainedAttr : public InheritableAttr {
1646public:
1647 static CFReturnsNotRetainedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1648 auto *A = new (Ctx) CFReturnsNotRetainedAttr(Loc, Ctx, 0);
1649 A->setImplicit(true);
1650 return A;
1651 }
1652
1653 CFReturnsNotRetainedAttr(SourceRange R, ASTContext &Ctx
1654 , unsigned SI
1655 )
1656 : InheritableAttr(attr::CFReturnsNotRetained, R, SI, false, false)
1657 {
1658 }
1659
1660 CFReturnsNotRetainedAttr *clone(ASTContext &C) const;
1661 void printPretty(raw_ostream &OS,
1662 const PrintingPolicy &Policy) const;
1663 const char *getSpelling() const;
1664
1665
1666 static bool classof(const Attr *A) { return A->getKind() == attr::CFReturnsNotRetained; }
1667};
1668
1669class CFReturnsRetainedAttr : public InheritableAttr {
1670public:
1671 static CFReturnsRetainedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1672 auto *A = new (Ctx) CFReturnsRetainedAttr(Loc, Ctx, 0);
1673 A->setImplicit(true);
1674 return A;
1675 }
1676
1677 CFReturnsRetainedAttr(SourceRange R, ASTContext &Ctx
1678 , unsigned SI
1679 )
1680 : InheritableAttr(attr::CFReturnsRetained, R, SI, false, false)
1681 {
1682 }
1683
1684 CFReturnsRetainedAttr *clone(ASTContext &C) const;
1685 void printPretty(raw_ostream &OS,
1686 const PrintingPolicy &Policy) const;
1687 const char *getSpelling() const;
1688
1689
1690 static bool classof(const Attr *A) { return A->getKind() == attr::CFReturnsRetained; }
1691};
1692
1693class CFUnknownTransferAttr : public InheritableAttr {
1694public:
1695 static CFUnknownTransferAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1696 auto *A = new (Ctx) CFUnknownTransferAttr(Loc, Ctx, 0);
1697 A->setImplicit(true);
1698 return A;
1699 }
1700
1701 CFUnknownTransferAttr(SourceRange R, ASTContext &Ctx
1702 , unsigned SI
1703 )
1704 : InheritableAttr(attr::CFUnknownTransfer, R, SI, false, false)
1705 {
1706 }
1707
1708 CFUnknownTransferAttr *clone(ASTContext &C) const;
1709 void printPretty(raw_ostream &OS,
1710 const PrintingPolicy &Policy) const;
1711 const char *getSpelling() const;
1712
1713
1714 static bool classof(const Attr *A) { return A->getKind() == attr::CFUnknownTransfer; }
1715};
1716
1717class CPUDispatchAttr : public InheritableAttr {
1718 unsigned cpus_Size;
1719 IdentifierInfo * *cpus_;
1720
1721public:
1722 static CPUDispatchAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * *Cpus, unsigned CpusSize, SourceRange Loc = SourceRange()) {
1723 auto *A = new (Ctx) CPUDispatchAttr(Loc, Ctx, Cpus, CpusSize, 0);
1724 A->setImplicit(true);
1725 return A;
1726 }
1727
1728 CPUDispatchAttr(SourceRange R, ASTContext &Ctx
1729 , IdentifierInfo * *Cpus, unsigned CpusSize
1730 , unsigned SI
1731 )
1732 : InheritableAttr(attr::CPUDispatch, R, SI, false, false)
1733 , cpus_Size(CpusSize), cpus_(new (Ctx, 16) IdentifierInfo *[cpus_Size])
1734 {
1735 std::copy(Cpus, Cpus + cpus_Size, cpus_);
1736 }
1737
1738 CPUDispatchAttr(SourceRange R, ASTContext &Ctx
1739 , unsigned SI
1740 )
1741 : InheritableAttr(attr::CPUDispatch, R, SI, false, false)
1742 , cpus_Size(0), cpus_(nullptr)
1743 {
1744 }
1745
1746 CPUDispatchAttr *clone(ASTContext &C) const;
1747 void printPretty(raw_ostream &OS,
1748 const PrintingPolicy &Policy) const;
1749 const char *getSpelling() const;
1750 typedef IdentifierInfo ** cpus_iterator;
1751 cpus_iterator cpus_begin() const { return cpus_; }
1752 cpus_iterator cpus_end() const { return cpus_ + cpus_Size; }
1753 unsigned cpus_size() const { return cpus_Size; }
1754 llvm::iterator_range<cpus_iterator> cpus() const { return llvm::make_range(cpus_begin(), cpus_end()); }
1755
1756
1757
1758
1759 static bool classof(const Attr *A) { return A->getKind() == attr::CPUDispatch; }
1760};
1761
1762class CPUSpecificAttr : public InheritableAttr {
1763 unsigned cpus_Size;
1764 IdentifierInfo * *cpus_;
1765
1766public:
1767 static CPUSpecificAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * *Cpus, unsigned CpusSize, SourceRange Loc = SourceRange()) {
1768 auto *A = new (Ctx) CPUSpecificAttr(Loc, Ctx, Cpus, CpusSize, 0);
1769 A->setImplicit(true);
1770 return A;
1771 }
1772
1773 CPUSpecificAttr(SourceRange R, ASTContext &Ctx
1774 , IdentifierInfo * *Cpus, unsigned CpusSize
1775 , unsigned SI
1776 )
1777 : InheritableAttr(attr::CPUSpecific, R, SI, false, false)
1778 , cpus_Size(CpusSize), cpus_(new (Ctx, 16) IdentifierInfo *[cpus_Size])
1779 {
1780 std::copy(Cpus, Cpus + cpus_Size, cpus_);
1781 }
1782
1783 CPUSpecificAttr(SourceRange R, ASTContext &Ctx
1784 , unsigned SI
1785 )
1786 : InheritableAttr(attr::CPUSpecific, R, SI, false, false)
1787 , cpus_Size(0), cpus_(nullptr)
1788 {
1789 }
1790
1791 CPUSpecificAttr *clone(ASTContext &C) const;
1792 void printPretty(raw_ostream &OS,
1793 const PrintingPolicy &Policy) const;
1794 const char *getSpelling() const;
1795 typedef IdentifierInfo ** cpus_iterator;
1796 cpus_iterator cpus_begin() const { return cpus_; }
1797 cpus_iterator cpus_end() const { return cpus_ + cpus_Size; }
1798 unsigned cpus_size() const { return cpus_Size; }
1799 llvm::iterator_range<cpus_iterator> cpus() const { return llvm::make_range(cpus_begin(), cpus_end()); }
1800
1801
1802
1803 unsigned ActiveArgIndex = 0;
1804
1805 IdentifierInfo *getCurCPUName() const {
1806 return *(cpus_begin() + ActiveArgIndex);
1807 }
1808
1809
1810 static bool classof(const Attr *A) { return A->getKind() == attr::CPUSpecific; }
1811};
1812
1813class CUDAConstantAttr : public InheritableAttr {
1814public:
1815 static CUDAConstantAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1816 auto *A = new (Ctx) CUDAConstantAttr(Loc, Ctx, 0);
1817 A->setImplicit(true);
1818 return A;
1819 }
1820
1821 CUDAConstantAttr(SourceRange R, ASTContext &Ctx
1822 , unsigned SI
1823 )
1824 : InheritableAttr(attr::CUDAConstant, R, SI, false, false)
1825 {
1826 }
1827
1828 CUDAConstantAttr *clone(ASTContext &C) const;
1829 void printPretty(raw_ostream &OS,
1830 const PrintingPolicy &Policy) const;
1831 const char *getSpelling() const;
1832
1833
1834 static bool classof(const Attr *A) { return A->getKind() == attr::CUDAConstant; }
1835};
1836
1837class CUDADeviceAttr : public InheritableAttr {
1838public:
1839 static CUDADeviceAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1840 auto *A = new (Ctx) CUDADeviceAttr(Loc, Ctx, 0);
1841 A->setImplicit(true);
1842 return A;
1843 }
1844
1845 CUDADeviceAttr(SourceRange R, ASTContext &Ctx
1846 , unsigned SI
1847 )
1848 : InheritableAttr(attr::CUDADevice, R, SI, false, false)
1849 {
1850 }
1851
1852 CUDADeviceAttr *clone(ASTContext &C) const;
1853 void printPretty(raw_ostream &OS,
1854 const PrintingPolicy &Policy) const;
1855 const char *getSpelling() const;
1856
1857
1858 static bool classof(const Attr *A) { return A->getKind() == attr::CUDADevice; }
1859};
1860
1861class CUDAGlobalAttr : public InheritableAttr {
1862public:
1863 static CUDAGlobalAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1864 auto *A = new (Ctx) CUDAGlobalAttr(Loc, Ctx, 0);
1865 A->setImplicit(true);
1866 return A;
1867 }
1868
1869 CUDAGlobalAttr(SourceRange R, ASTContext &Ctx
1870 , unsigned SI
1871 )
1872 : InheritableAttr(attr::CUDAGlobal, R, SI, false, false)
1873 {
1874 }
1875
1876 CUDAGlobalAttr *clone(ASTContext &C) const;
1877 void printPretty(raw_ostream &OS,
1878 const PrintingPolicy &Policy) const;
1879 const char *getSpelling() const;
1880
1881
1882 static bool classof(const Attr *A) { return A->getKind() == attr::CUDAGlobal; }
1883};
1884
1885class CUDAHostAttr : public InheritableAttr {
1886public:
1887 static CUDAHostAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1888 auto *A = new (Ctx) CUDAHostAttr(Loc, Ctx, 0);
5
'A' initialized to a null pointer value
1889 A->setImplicit(true);
6
Called C++ object pointer is null
1890 return A;
1891 }
1892
1893 CUDAHostAttr(SourceRange R, ASTContext &Ctx
1894 , unsigned SI
1895 )
1896 : InheritableAttr(attr::CUDAHost, R, SI, false, false)
1897 {
1898 }
1899
1900 CUDAHostAttr *clone(ASTContext &C) const;
1901 void printPretty(raw_ostream &OS,
1902 const PrintingPolicy &Policy) const;
1903 const char *getSpelling() const;
1904
1905
1906 static bool classof(const Attr *A) { return A->getKind() == attr::CUDAHost; }
1907};
1908
1909class CUDAInvalidTargetAttr : public InheritableAttr {
1910public:
1911 static CUDAInvalidTargetAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1912 auto *A = new (Ctx) CUDAInvalidTargetAttr(Loc, Ctx, 0);
1913 A->setImplicit(true);
1914 return A;
1915 }
1916
1917 CUDAInvalidTargetAttr(SourceRange R, ASTContext &Ctx
1918 , unsigned SI
1919 )
1920 : InheritableAttr(attr::CUDAInvalidTarget, R, SI, false, false)
1921 {
1922 }
1923
1924 CUDAInvalidTargetAttr *clone(ASTContext &C) const;
1925 void printPretty(raw_ostream &OS,
1926 const PrintingPolicy &Policy) const;
1927 const char *getSpelling() const;
1928
1929
1930 static bool classof(const Attr *A) { return A->getKind() == attr::CUDAInvalidTarget; }
1931};
1932
1933class CUDALaunchBoundsAttr : public InheritableAttr {
1934Expr * maxThreads;
1935
1936Expr * minBlocks;
1937
1938public:
1939 static CUDALaunchBoundsAttr *CreateImplicit(ASTContext &Ctx, Expr * MaxThreads, Expr * MinBlocks, SourceRange Loc = SourceRange()) {
1940 auto *A = new (Ctx) CUDALaunchBoundsAttr(Loc, Ctx, MaxThreads, MinBlocks, 0);
1941 A->setImplicit(true);
1942 return A;
1943 }
1944
1945 CUDALaunchBoundsAttr(SourceRange R, ASTContext &Ctx
1946 , Expr * MaxThreads
1947 , Expr * MinBlocks
1948 , unsigned SI
1949 )
1950 : InheritableAttr(attr::CUDALaunchBounds, R, SI, false, false)
1951 , maxThreads(MaxThreads)
1952 , minBlocks(MinBlocks)
1953 {
1954 }
1955
1956 CUDALaunchBoundsAttr(SourceRange R, ASTContext &Ctx
1957 , Expr * MaxThreads
1958 , unsigned SI
1959 )
1960 : InheritableAttr(attr::CUDALaunchBounds, R, SI, false, false)
1961 , maxThreads(MaxThreads)
1962 , minBlocks()
1963 {
1964 }
1965
1966 CUDALaunchBoundsAttr *clone(ASTContext &C) const;
1967 void printPretty(raw_ostream &OS,
1968 const PrintingPolicy &Policy) const;
1969 const char *getSpelling() const;
1970 Expr * getMaxThreads() const {
1971 return maxThreads;
1972 }
1973
1974 Expr * getMinBlocks() const {
1975 return minBlocks;
1976 }
1977
1978
1979
1980 static bool classof(const Attr *A) { return A->getKind() == attr::CUDALaunchBounds; }
1981};
1982
1983class CUDASharedAttr : public InheritableAttr {
1984public:
1985 static CUDASharedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1986 auto *A = new (Ctx) CUDASharedAttr(Loc, Ctx, 0);
1987 A->setImplicit(true);
1988 return A;
1989 }
1990
1991 CUDASharedAttr(SourceRange R, ASTContext &Ctx
1992 , unsigned SI
1993 )
1994 : InheritableAttr(attr::CUDAShared, R, SI, false, false)
1995 {
1996 }
1997
1998 CUDASharedAttr *clone(ASTContext &C) const;
1999 void printPretty(raw_ostream &OS,
2000 const PrintingPolicy &Policy) const;
2001 const char *getSpelling() const;
2002
2003
2004 static bool classof(const Attr *A) { return A->getKind() == attr::CUDAShared; }
2005};
2006
2007class CXX11NoReturnAttr : public InheritableAttr {
2008public:
2009 static CXX11NoReturnAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
2010 auto *A = new (Ctx) CXX11NoReturnAttr(Loc, Ctx, 0);
2011 A->setImplicit(true);
2012 return A;
2013 }
2014
2015 CXX11NoReturnAttr(SourceRange R, ASTContext &Ctx
2016 , unsigned SI
2017 )
2018 : InheritableAttr(attr::CXX11NoReturn, R, SI, false, false)
2019 {
2020 }
2021
2022 CXX11NoReturnAttr *clone(ASTContext &C) const;
2023 void printPretty(raw_ostream &OS,
2024 const PrintingPolicy &Policy) const;
2025 const char *getSpelling() const;
2026
2027
2028 static bool classof(const Attr *A) { return A->getKind() == attr::CXX11NoReturn; }
2029};
2030
2031class CallableWhenAttr : public InheritableAttr {
2032public:
2033 enum ConsumedState {
2034 Unknown,
2035 Consumed,
2036 Unconsumed
2037 };
2038private:
2039 unsigned callableStates_Size;
2040 ConsumedState *callableStates_;
2041
2042public:
2043 static CallableWhenAttr *CreateImplicit(ASTContext &Ctx, ConsumedState *CallableStates, unsigned CallableStatesSize, SourceRange Loc = SourceRange()) {
2044 auto *A = new (Ctx) CallableWhenAttr(Loc, Ctx, CallableStates, CallableStatesSize, 0);
2045 A->setImplicit(true);
2046 return A;
2047 }
2048
2049 CallableWhenAttr(SourceRange R, ASTContext &Ctx
2050 , ConsumedState *CallableStates, unsigned CallableStatesSize
2051 , unsigned SI
2052 )
2053 : InheritableAttr(attr::CallableWhen, R, SI, false, false)
2054 , callableStates_Size(CallableStatesSize), callableStates_(new (Ctx, 16) ConsumedState[callableStates_Size])
2055 {
2056 std::copy(CallableStates, CallableStates + callableStates_Size, callableStates_);
2057 }
2058
2059 CallableWhenAttr(SourceRange R, ASTContext &Ctx
2060 , unsigned SI
2061 )
2062 : InheritableAttr(attr::CallableWhen, R, SI, false, false)
2063 , callableStates_Size(0), callableStates_(nullptr)
2064 {
2065 }
2066
2067 CallableWhenAttr *clone(ASTContext &C) const;
2068 void printPretty(raw_ostream &OS,
2069 const PrintingPolicy &Policy) const;
2070 const char *getSpelling() const;
2071 typedef ConsumedState* callableStates_iterator;
2072 callableStates_iterator callableStates_begin() const { return callableStates_; }
2073 callableStates_iterator callableStates_end() const { return callableStates_ + callableStates_Size; }
2074 unsigned callableStates_size() const { return callableStates_Size; }
2075 llvm::iterator_range<callableStates_iterator> callableStates() const { return llvm::make_range(callableStates_begin(), callableStates_end()); }
2076
2077
2078 static bool ConvertStrToConsumedState(StringRef Val, ConsumedState &Out) {
2079 Optional<ConsumedState> R = llvm::StringSwitch<Optional<ConsumedState>>(Val)
2080 .Case("unknown", CallableWhenAttr::Unknown)
2081 .Case("consumed", CallableWhenAttr::Consumed)
2082 .Case("unconsumed", CallableWhenAttr::Unconsumed)
2083 .Default(Optional<ConsumedState>());
2084 if (R) {
2085 Out = *R;
2086 return true;
2087 }
2088 return false;
2089 }
2090
2091 static const char *ConvertConsumedStateToStr(ConsumedState Val) {
2092 switch(Val) {
2093 case CallableWhenAttr::Unknown: return "unknown";
2094 case CallableWhenAttr::Consumed: return "consumed";
2095 case CallableWhenAttr::Unconsumed: return "unconsumed";
2096 }
2097 llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 2097)
;
2098 }
2099
2100
2101 static bool classof(const Attr *A) { return A->getKind() == attr::CallableWhen; }
2102};
2103
2104class CapabilityAttr : public InheritableAttr {
2105unsigned nameLength;
2106char *name;
2107
2108public:
2109 enum Spelling {
2110 GNU_capability = 0,
2111 CXX11_clang_capability = 1,
2112 GNU_shared_capability = 2,
2113 CXX11_clang_shared_capability = 3
2114 };
2115
2116 static CapabilityAttr *CreateImplicit(ASTContext &Ctx, Spelling S, llvm::StringRef Name, SourceRange Loc = SourceRange()) {
2117 auto *A = new (Ctx) CapabilityAttr(Loc, Ctx, Name, S);
2118 A->setImplicit(true);
2119 return A;
2120 }
2121
2122 CapabilityAttr(SourceRange R, ASTContext &Ctx
2123 , llvm::StringRef Name
2124 , unsigned SI
2125 )
2126 : InheritableAttr(attr::Capability, R, SI, false, false)
2127 , nameLength(Name.size()),name(new (Ctx, 1) char[nameLength])
2128 {
2129 if (!Name.empty())
2130 std::memcpy(name, Name.data(), nameLength);
2131 }
2132
2133 CapabilityAttr *clone(ASTContext &C) const;
2134 void printPretty(raw_ostream &OS,
2135 const PrintingPolicy &Policy) const;
2136 const char *getSpelling() const;
2137 Spelling getSemanticSpelling() const {
2138 switch (SpellingListIndex) {
2139 default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 2139)
;
2140 case 0: return GNU_capability;
2141 case 1: return CXX11_clang_capability;
2142 case 2: return GNU_shared_capability;
2143 case 3: return CXX11_clang_shared_capability;
2144 }
2145 }
2146 bool isShared() const { return SpellingListIndex == 2 ||
2147 SpellingListIndex == 3; }
2148 llvm::StringRef getName() const {
2149 return llvm::StringRef(name, nameLength);
2150 }
2151 unsigned getNameLength() const {
2152 return nameLength;
2153 }
2154 void setName(ASTContext &C, llvm::StringRef S) {
2155 nameLength = S.size();
2156 this->name = new (C, 1) char [nameLength];
2157 if (!S.empty())
2158 std::memcpy(this->name, S.data(), nameLength);
2159 }
2160
2161
2162 bool isMutex() const { return getName().equals_lower("mutex"); }
2163 bool isRole() const { return getName().equals_lower("role"); }
2164
2165
2166 static bool classof(const Attr *A) { return A->getKind() == attr::Capability; }
2167};
2168
2169class CapturedRecordAttr : public InheritableAttr {
2170public:
2171 static CapturedRecordAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
2172 auto *A = new (Ctx) CapturedRecordAttr(Loc, Ctx, 0);
2173 A->setImplicit(true);
2174 return A;
2175 }
2176
2177 CapturedRecordAttr(SourceRange R, ASTContext &Ctx
2178 , unsigned SI
2179 )
2180 : InheritableAttr(attr::CapturedRecord, R, SI, false, false)
2181 {
2182 }
2183
2184 CapturedRecordAttr *clone(ASTContext &C) const;
2185 void printPretty(raw_ostream &OS,
2186 const PrintingPolicy &Policy) const;
2187 const char *getSpelling() const;
2188
2189
2190 static bool classof(const Attr *A) { return A->getKind() == attr::CapturedRecord; }
2191};
2192
2193class CarriesDependencyAttr : public InheritableParamAttr {
2194public:
2195 static CarriesDependencyAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
2196 auto *A = new (Ctx) CarriesDependencyAttr(Loc, Ctx, 0);
2197 A->setImplicit(true);
2198 return A;
2199 }
2200
2201 CarriesDependencyAttr(SourceRange R, ASTContext &Ctx
2202 , unsigned SI
2203 )
2204 : InheritableParamAttr(attr::CarriesDependency, R, SI, false, false)
2205 {
2206 }
2207
2208 CarriesDependencyAttr *clone(ASTContext &C) const;
2209 void printPretty(raw_ostream &OS,
2210 const PrintingPolicy &Policy) const;
2211 const char *getSpelling() const;
2212
2213
2214 static bool classof(const Attr *A) { return A->getKind() == attr::CarriesDependency; }
2215};
2216
2217class CleanupAttr : public InheritableAttr {
2218FunctionDecl * functionDecl;
2219
2220public:
2221 static CleanupAttr *CreateImplicit(ASTContext &Ctx, FunctionDecl * FunctionDecl, SourceRange Loc = SourceRange()) {
2222 auto *A = new (Ctx) CleanupAttr(Loc, Ctx, FunctionDecl, 0);
2223 A->setImplicit(true);
2224 return A;
2225 }
2226
2227 CleanupAttr(SourceRange R, ASTContext &Ctx
2228 , FunctionDecl * FunctionDecl
2229 , unsigned SI
2230 )
2231 : InheritableAttr(attr::Cleanup, R, SI, false, false)
2232 , functionDecl(FunctionDecl)
2233 {
2234 }
2235
2236 CleanupAttr *clone(ASTContext &C) const;
2237 void printPretty(raw_ostream &OS,
2238 const PrintingPolicy &Policy) const;
2239 const char *getSpelling() const;
2240 FunctionDecl * getFunctionDecl() const {
2241 return functionDecl;
2242 }
2243
2244
2245
2246 static bool classof(const Attr *A) { return A->getKind() == attr::Cleanup; }
2247};
2248
2249class CodeSegAttr : public InheritableAttr {
2250unsigned nameLength;
2251char *name;
2252
2253public:
2254 static CodeSegAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, SourceRange Loc = SourceRange()) {
2255 auto *A = new (Ctx) CodeSegAttr(Loc, Ctx, Name, 0);
2256 A->setImplicit(true);
2257 return A;
2258 }
2259
2260 CodeSegAttr(SourceRange R, ASTContext &Ctx
2261 , llvm::StringRef Name
2262 , unsigned SI
2263 )
2264 : InheritableAttr(attr::CodeSeg, R, SI, false, false)
2265 , nameLength(Name.size()),name(new (Ctx, 1) char[nameLength])
2266 {
2267 if (!Name.empty())
2268 std::memcpy(name, Name.data(), nameLength);
2269 }
2270
2271 CodeSegAttr *clone(ASTContext &C) const;
2272 void printPretty(raw_ostream &OS,
2273 const PrintingPolicy &Policy) const;
2274 const char *getSpelling() const;
2275 llvm::StringRef getName() const {
2276 return llvm::StringRef(name, nameLength);
2277 }
2278 unsigned getNameLength() const {
2279 return nameLength;
2280 }
2281 void setName(ASTContext &C, llvm::StringRef S) {
2282 nameLength = S.size();
2283 this->name = new (C, 1) char [nameLength];
2284 if (!S.empty())
2285 std::memcpy(this->name, S.data(), nameLength);
2286 }
2287
2288
2289
2290 static bool classof(const Attr *A) { return A->getKind() == attr::CodeSeg; }
2291};
2292
2293class ColdAttr : public InheritableAttr {
2294public:
2295 static ColdAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
2296 auto *A = new (Ctx) ColdAttr(Loc, Ctx, 0);
2297 A->setImplicit(true);
2298 return A;
2299 }
2300
2301 ColdAttr(SourceRange R, ASTContext &Ctx
2302 , unsigned SI
2303 )
2304 : InheritableAttr(attr::Cold, R, SI, false, false)
2305 {
2306 }
2307
2308 ColdAttr *clone(ASTContext &C) const;
2309 void printPretty(raw_ostream &OS,
2310 const PrintingPolicy &Policy) const;
2311 const char *getSpelling() const;
2312
2313
2314 static bool classof(const Attr *A) { return A->getKind() == attr::Cold; }
2315};
2316
2317class CommonAttr : public InheritableAttr {
2318public:
2319 static CommonAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
2320 auto *A = new (Ctx) CommonAttr(Loc, Ctx, 0);
2321 A->setImplicit(true);
2322 return A;
2323 }
2324
2325 CommonAttr(SourceRange R, ASTContext &Ctx
2326 , unsigned SI
2327 )
2328 : InheritableAttr(attr::Common, R, SI, false, false)
2329 {
2330 }
2331
2332 CommonAttr *clone(ASTContext &C) const;
2333 void printPretty(raw_ostream &OS,
2334 const PrintingPolicy &Policy) const;
2335 const char *getSpelling() const;
2336
2337
2338 static bool classof(const Attr *A) { return A->getKind() == attr::Common; }
2339};
2340
2341class ConstAttr : public InheritableAttr {
2342public:
2343 static ConstAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
2344 auto *A = new (Ctx) ConstAttr(Loc, Ctx, 0);
2345 A->setImplicit(true);
2346 return A;
2347 }
2348
2349 ConstAttr(SourceRange R, ASTContext &Ctx
2350 , unsigned SI
2351 )
2352 : InheritableAttr(attr::Const, R, SI, false, false)
2353 {
2354 }
2355
2356 ConstAttr *clone(ASTContext &C) const;
2357 void printPretty(raw_ostream &OS,
2358 const PrintingPolicy &Policy) const;
2359 const char *getSpelling() const;
2360
2361
2362 static bool classof(const Attr *A) { return A->getKind() == attr::Const; }
2363};
2364
2365class ConstructorAttr : public InheritableAttr {
2366int priority;
2367
2368public:
2369 static ConstructorAttr *CreateImplicit(ASTContext &Ctx, int Priority, SourceRange Loc = SourceRange()) {
2370 auto *A = new (Ctx) ConstructorAttr(Loc, Ctx, Priority, 0);
2371 A->setImplicit(true);
2372 return A;
2373 }
2374
2375 ConstructorAttr(SourceRange R, ASTContext &Ctx
2376 , int Priority
2377 , unsigned SI
2378 )
2379 : InheritableAttr(attr::Constructor, R, SI, false, false)
2380 , priority(Priority)
2381 {
2382 }
2383
2384 ConstructorAttr(SourceRange R, ASTContext &Ctx
2385 , unsigned SI
2386 )
2387 : InheritableAttr(attr::Constructor, R, SI, false, false)
2388 , priority()
2389 {
2390 }
2391
2392 ConstructorAttr *clone(ASTContext &C) const;
2393 void printPretty(raw_ostream &OS,
2394 const PrintingPolicy &Policy) const;
2395 const char *getSpelling() const;
2396 int getPriority() const {
2397 return priority;
2398 }
2399
2400 static const int DefaultPriority = 65535;
2401
2402
2403
2404 static bool classof(const Attr *A) { return A->getKind() == attr::Constructor; }
2405};
2406
2407class ConsumableAttr : public InheritableAttr {
2408public:
2409 enum ConsumedState {
2410 Unknown,
2411 Consumed,
2412 Unconsumed
2413 };
2414private:
2415 ConsumedState defaultState;
2416
2417public:
2418 static ConsumableAttr *CreateImplicit(ASTContext &Ctx, ConsumedState DefaultState, SourceRange Loc = SourceRange()) {
2419 auto *A = new (Ctx) ConsumableAttr(Loc, Ctx, DefaultState, 0);
2420 A->setImplicit(true);
2421 return A;
2422 }
2423
2424 ConsumableAttr(SourceRange R, ASTContext &Ctx
2425 , ConsumedState DefaultState
2426 , unsigned SI
2427 )
2428 : InheritableAttr(attr::Consumable, R, SI, false, false)
2429 , defaultState(DefaultState)
2430 {
2431 }
2432
2433 ConsumableAttr *clone(ASTContext &C) const;
2434 void printPretty(raw_ostream &OS,
2435 const PrintingPolicy &Policy) const;
2436 const char *getSpelling() const;
2437 ConsumedState getDefaultState() const {
2438 return defaultState;
2439 }
2440
2441 static bool ConvertStrToConsumedState(StringRef Val, ConsumedState &Out) {
2442 Optional<ConsumedState> R = llvm::StringSwitch<Optional<ConsumedState>>(Val)
2443 .Case("unknown", ConsumableAttr::Unknown)
2444 .Case("consumed", ConsumableAttr::Consumed)
2445 .Case("unconsumed", ConsumableAttr::Unconsumed)
2446 .Default(Optional<ConsumedState>());
2447 if (R) {
2448 Out = *R;
2449 return true;
2450 }
2451 return false;
2452 }
2453
2454 static const char *ConvertConsumedStateToStr(ConsumedState Val) {
2455 switch(Val) {
2456 case ConsumableAttr::Unknown: return "unknown";
2457 case ConsumableAttr::Consumed: return "consumed";
2458 case ConsumableAttr::Unconsumed: return "unconsumed";
2459 }
2460 llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 2460)
;
2461 }
2462
2463
2464 static bool classof(const Attr *A) { return A->getKind() == attr::Consumable; }
2465};
2466
2467class ConsumableAutoCastAttr : public InheritableAttr {
2468public:
2469 static ConsumableAutoCastAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
2470 auto *A = new (Ctx) ConsumableAutoCastAttr(Loc, Ctx, 0);
2471 A->setImplicit(true);
2472 return A;
2473 }
2474
2475 ConsumableAutoCastAttr(SourceRange R, ASTContext &Ctx
2476 , unsigned SI
2477 )
2478 : InheritableAttr(attr::ConsumableAutoCast, R, SI, false, false)
2479 {
2480 }
2481
2482 ConsumableAutoCastAttr *clone(ASTContext &C) const;
2483 void printPretty(raw_ostream &OS,
2484 const PrintingPolicy &Policy) const;
2485 const char *getSpelling() const;
2486
2487
2488 static bool classof(const Attr *A) { return A->getKind() == attr::ConsumableAutoCast; }
2489};
2490
2491class ConsumableSetOnReadAttr : public InheritableAttr {
2492public:
2493 static ConsumableSetOnReadAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
2494 auto *A = new (Ctx) ConsumableSetOnReadAttr(Loc, Ctx, 0);
2495 A->setImplicit(true);
2496 return A;
2497 }
2498
2499 ConsumableSetOnReadAttr(SourceRange R, ASTContext &Ctx
2500 , unsigned SI
2501 )
2502 : InheritableAttr(attr::ConsumableSetOnRead, R, SI, false, false)
2503 {
2504 }
2505
2506 ConsumableSetOnReadAttr *clone(ASTContext &C) const;
2507 void printPretty(raw_ostream &OS,
2508 const PrintingPolicy &Policy) const;
2509 const char *getSpelling() const;
2510
2511
2512 static bool classof(const Attr *A) { return A->getKind() == attr::ConsumableSetOnRead; }
2513};
2514
2515class ConvergentAttr : public InheritableAttr {
2516public:
2517 static ConvergentAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
2518 auto *A = new (Ctx) ConvergentAttr(Loc, Ctx, 0);
2519 A->setImplicit(true);
2520 return A;
2521 }
2522
2523 ConvergentAttr(SourceRange R, ASTContext &Ctx
2524 , unsigned SI
2525 )
2526 : InheritableAttr(attr::Convergent, R, SI, false, false)
2527 {
2528 }
2529
2530 ConvergentAttr *clone(ASTContext &C) const;
2531 void printPretty(raw_ostream &OS,
2532 const PrintingPolicy &Policy) const;
2533 const char *getSpelling() const;
2534
2535
2536 static bool classof(const Attr *A) { return A->getKind() == attr::Convergent; }
2537};
2538
2539class DLLExportAttr : public InheritableAttr {
2540public:
2541 static DLLExportAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
2542 auto *A = new (Ctx) DLLExportAttr(Loc, Ctx, 0);
2543 A->setImplicit(true);
2544 return A;
2545 }
2546
2547 DLLExportAttr(SourceRange R, ASTContext &Ctx
2548 , unsigned SI
2549 )
2550 : InheritableAttr(attr::DLLExport, R, SI, false, false)
2551 {
2552 }
2553
2554 DLLExportAttr *clone(ASTContext &C) const;
2555 void printPretty(raw_ostream &OS,
2556 const PrintingPolicy &Policy) const;
2557 const char *getSpelling() const;
2558
2559
2560 static bool classof(const Attr *A) { return A->getKind() == attr::DLLExport; }
2561};
2562
2563class DLLImportAttr : public InheritableAttr {
2564public:
2565 static DLLImportAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
2566 auto *A = new (Ctx) DLLImportAttr(Loc, Ctx, 0);
2567 A->setImplicit(true);
2568 return A;
2569 }
2570
2571 DLLImportAttr(SourceRange R, ASTContext &Ctx
2572 , unsigned SI
2573 )
2574 : InheritableAttr(attr::DLLImport, R, SI, false, false)
2575 {
2576 }
2577
2578 DLLImportAttr *clone(ASTContext &C) const;
2579 void printPretty(raw_ostream &OS,
2580 const PrintingPolicy &Policy) const;
2581 const char *getSpelling() const;
2582
2583private:
2584 bool PropagatedToBaseTemplate = false;
2585
2586public:
2587 void setPropagatedToBaseTemplate() { PropagatedToBaseTemplate = true; }
2588 bool wasPropagatedToBaseTemplate() { return PropagatedToBaseTemplate; }
2589
2590
2591 static bool classof(const Attr *A) { return A->getKind() == attr::DLLImport; }
2592};
2593
2594class DeprecatedAttr : public InheritableAttr {
2595unsigned messageLength;
2596char *message;
2597
2598unsigned replacementLength;
2599char *replacement;
2600
2601public:
2602 static DeprecatedAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Message, llvm::StringRef Replacement, SourceRange Loc = SourceRange()) {
2603 auto *A = new (Ctx) DeprecatedAttr(Loc, Ctx, Message, Replacement, 0);
2604 A->setImplicit(true);
2605 return A;
2606 }
2607
2608 DeprecatedAttr(SourceRange R, ASTContext &Ctx
2609 , llvm::StringRef Message
2610 , llvm::StringRef Replacement
2611 , unsigned SI
2612 )
2613 : InheritableAttr(attr::Deprecated, R, SI, false, false)
2614 , messageLength(Message.size()),message(new (Ctx, 1) char[messageLength])
2615 , replacementLength(Replacement.size()),replacement(new (Ctx, 1) char[replacementLength])
2616 {
2617 if (!Message.empty())
2618 std::memcpy(message, Message.data(), messageLength);
2619 if (!Replacement.empty())
2620 std::memcpy(replacement, Replacement.data(), replacementLength);
2621 }
2622
2623 DeprecatedAttr(SourceRange R, ASTContext &Ctx
2624 , unsigned SI
2625 )
2626 : InheritableAttr(attr::Deprecated, R, SI, false, false)
2627 , messageLength(0),message(nullptr)
2628 , replacementLength(0),replacement(nullptr)
2629 {
2630 }
2631
2632 DeprecatedAttr *clone(ASTContext &C) const;
2633 void printPretty(raw_ostream &OS,
2634 const PrintingPolicy &Policy) const;
2635 const char *getSpelling() const;
2636 llvm::StringRef getMessage() const {
2637 return llvm::StringRef(message, messageLength);
2638 }
2639 unsigned getMessageLength() const {
2640 return messageLength;
2641 }
2642 void setMessage(ASTContext &C, llvm::StringRef S) {
2643 messageLength = S.size();
2644 this->message = new (C, 1) char [messageLength];
2645 if (!S.empty())
2646 std::memcpy(this->message, S.data(), messageLength);
2647 }
2648
2649 llvm::StringRef getReplacement() const {
2650 return llvm::StringRef(replacement, replacementLength);
2651 }
2652 unsigned getReplacementLength() const {
2653 return replacementLength;
2654 }
2655 void setReplacement(ASTContext &C, llvm::StringRef S) {
2656 replacementLength = S.size();
2657 this->replacement = new (C, 1) char [replacementLength];
2658 if (!S.empty())
2659 std::memcpy(this->replacement, S.data(), replacementLength);
2660 }
2661
2662
2663
2664 static bool classof(const Attr *A) { return A->getKind() == attr::Deprecated; }
2665};
2666
2667class DestructorAttr : public InheritableAttr {
2668int priority;
2669
2670public:
2671 static DestructorAttr *CreateImplicit(ASTContext &Ctx, int Priority, SourceRange Loc = SourceRange()) {
2672 auto *A = new (Ctx) DestructorAttr(Loc, Ctx, Priority, 0);
2673 A->setImplicit(true);
2674 return A;
2675 }
2676
2677 DestructorAttr(SourceRange R, ASTContext &Ctx
2678 , int Priority
2679 , unsigned SI
2680 )
2681 : InheritableAttr(attr::Destructor, R, SI, false, false)
2682 , priority(Priority)
2683 {
2684 }
2685
2686 DestructorAttr(SourceRange R, ASTContext &Ctx
2687 , unsigned SI
2688 )
2689 : InheritableAttr(attr::Destructor, R, SI, false, false)
2690 , priority()
2691 {
2692 }
2693
2694 DestructorAttr *clone(ASTContext &C) const;
2695 void printPretty(raw_ostream &OS,
2696 const PrintingPolicy &Policy) const;
2697 const char *getSpelling() const;
2698 int getPriority() const {
2699 return priority;
2700 }
2701
2702 static const int DefaultPriority = 65535;
2703
2704
2705
2706 static bool classof(const Attr *A) { return A->getKind() == attr::Destructor; }
2707};
2708
2709class DiagnoseIfAttr : public InheritableAttr {
2710Expr * cond;
2711
2712unsigned messageLength;
2713char *message;
2714
2715public:
2716 enum DiagnosticType {
2717 DT_Error,
2718 DT_Warning
2719 };
2720private:
2721 DiagnosticType diagnosticType;
2722
2723bool argDependent;
2724
2725NamedDecl * parent;
2726
2727public:
2728 static DiagnoseIfAttr *CreateImplicit(ASTContext &Ctx, Expr * Cond, llvm::StringRef Message, DiagnosticType DiagnosticType, bool ArgDependent, NamedDecl * Parent, SourceRange Loc = SourceRange()) {
2729 auto *A = new (Ctx) DiagnoseIfAttr(Loc, Ctx, Cond, Message, DiagnosticType, ArgDependent, Parent, 0);
2730 A->setImplicit(true);
2731 return A;
2732 }
2733
2734 static DiagnoseIfAttr *CreateImplicit(ASTContext &Ctx, Expr * Cond, llvm::StringRef Message, DiagnosticType DiagnosticType, SourceRange Loc = SourceRange()) {
2735 auto *A = new (Ctx) DiagnoseIfAttr(Loc, Ctx, Cond, Message, DiagnosticType, 0);
2736 A->setImplicit(true);
2737 return A;
2738 }
2739
2740 DiagnoseIfAttr(SourceRange R, ASTContext &Ctx
2741 , Expr * Cond
2742 , llvm::StringRef Message
2743 , DiagnosticType DiagnosticType
2744 , bool ArgDependent
2745 , NamedDecl * Parent
2746 , unsigned SI
2747 )
2748 : InheritableAttr(attr::DiagnoseIf, R, SI, true, true)
2749 , cond(Cond)
2750 , messageLength(Message.size()),message(new (Ctx, 1) char[messageLength])
2751 , diagnosticType(DiagnosticType)
2752 , argDependent(ArgDependent)
2753 , parent(Parent)
2754 {
2755 if (!Message.empty())
2756 std::memcpy(message, Message.data(), messageLength);
2757 }
2758
2759 DiagnoseIfAttr(SourceRange R, ASTContext &Ctx
2760 , Expr * Cond
2761 , llvm::StringRef Message
2762 , DiagnosticType DiagnosticType
2763 , unsigned SI
2764 )
2765 : InheritableAttr(attr::DiagnoseIf, R, SI, true, true)
2766 , cond(Cond)
2767 , messageLength(Message.size()),message(new (Ctx, 1) char[messageLength])
2768 , diagnosticType(DiagnosticType)
2769 , argDependent()
2770 , parent()
2771 {
2772 if (!Message.empty())
2773 std::memcpy(message, Message.data(), messageLength);
2774 }
2775
2776 DiagnoseIfAttr *clone(ASTContext &C) const;
2777 void printPretty(raw_ostream &OS,
2778 const PrintingPolicy &Policy) const;
2779 const char *getSpelling() const;
2780 Expr * getCond() const {
2781 return cond;
2782 }
2783
2784 llvm::StringRef getMessage() const {
2785 return llvm::StringRef(message, messageLength);
2786 }
2787 unsigned getMessageLength() const {
2788 return messageLength;
2789 }
2790 void setMessage(ASTContext &C, llvm::StringRef S) {
2791 messageLength = S.size();
2792 this->message = new (C, 1) char [messageLength];
2793 if (!S.empty())
2794 std::memcpy(this->message, S.data(), messageLength);
2795 }
2796
2797 DiagnosticType getDiagnosticType() const {
2798 return diagnosticType;
2799 }
2800
2801 static bool ConvertStrToDiagnosticType(StringRef Val, DiagnosticType &Out) {
2802 Optional<DiagnosticType> R = llvm::StringSwitch<Optional<DiagnosticType>>(Val)
2803 .Case("error", DiagnoseIfAttr::DT_Error)
2804 .Case("warning", DiagnoseIfAttr::DT_Warning)
2805 .Default(Optional<DiagnosticType>());
2806 if (R) {
2807 Out = *R;
2808 return true;
2809 }
2810 return false;
2811 }
2812
2813 static const char *ConvertDiagnosticTypeToStr(DiagnosticType Val) {
2814 switch(Val) {
2815 case DiagnoseIfAttr::DT_Error: return "error";
2816 case DiagnoseIfAttr::DT_Warning: return "warning";
2817 }
2818 llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 2818)
;
2819 }
2820 bool getArgDependent() const {
2821 return argDependent;
2822 }
2823
2824 NamedDecl * getParent() const {
2825 return parent;
2826 }
2827
2828
2829 bool isError() const { return diagnosticType == DT_Error; }
2830 bool isWarning() const { return diagnosticType == DT_Warning; }
2831
2832
2833 static bool classof(const Attr *A) { return A->getKind() == attr::DiagnoseIf; }
2834};
2835
2836class DisableTailCallsAttr : public InheritableAttr {
2837public:
2838 static DisableTailCallsAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
2839 auto *A = new (Ctx) DisableTailCallsAttr(Loc, Ctx, 0);
2840 A->setImplicit(true);
2841 return A;
2842 }
2843
2844 DisableTailCallsAttr(SourceRange R, ASTContext &Ctx
2845 , unsigned SI
2846 )
2847 : InheritableAttr(attr::DisableTailCalls, R, SI, false, false)
2848 {
2849 }
2850
2851 DisableTailCallsAttr *clone(ASTContext &C) const;
2852 void printPretty(raw_ostream &OS,
2853 const PrintingPolicy &Policy) const;
2854 const char *getSpelling() const;
2855
2856
2857 static bool classof(const Attr *A) { return A->getKind() == attr::DisableTailCalls; }
2858};
2859
2860class EmptyBasesAttr : public InheritableAttr {
2861public:
2862 static EmptyBasesAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
2863 auto *A = new (Ctx) EmptyBasesAttr(Loc, Ctx, 0);
2864 A->setImplicit(true);
2865 return A;
2866 }
2867
2868 EmptyBasesAttr(SourceRange R, ASTContext &Ctx
2869 , unsigned SI
2870 )
2871 : InheritableAttr(attr::EmptyBases, R, SI, false, false)
2872 {
2873 }
2874
2875 EmptyBasesAttr *clone(ASTContext &C) const;
2876 void printPretty(raw_ostream &OS,
2877 const PrintingPolicy &Policy) const;
2878 const char *getSpelling() const;
2879
2880
2881 static bool classof(const Attr *A) { return A->getKind() == attr::EmptyBases; }
2882};
2883
2884class EnableIfAttr : public InheritableAttr {
2885Expr * cond;
2886
2887unsigned messageLength;
2888char *message;
2889
2890public:
2891 static EnableIfAttr *CreateImplicit(ASTContext &Ctx, Expr * Cond, llvm::StringRef Message, SourceRange Loc = SourceRange()) {
2892 auto *A = new (Ctx) EnableIfAttr(Loc, Ctx, Cond, Message, 0);
2893 A->setImplicit(true);
2894 return A;
2895 }
2896
2897 EnableIfAttr(SourceRange R, ASTContext &Ctx
2898 , Expr * Cond
2899 , llvm::StringRef Message
2900 , unsigned SI
2901 )
2902 : InheritableAttr(attr::EnableIf, R, SI, false, false)
2903 , cond(Cond)
2904 , messageLength(Message.size()),message(new (Ctx, 1) char[messageLength])
2905 {
2906 if (!Message.empty())
2907 std::memcpy(message, Message.data(), messageLength);
2908 }
2909
2910 EnableIfAttr *clone(ASTContext &C) const;
2911 void printPretty(raw_ostream &OS,
2912 const PrintingPolicy &Policy) const;
2913 const char *getSpelling() const;
2914 Expr * getCond() const {
2915 return cond;
2916 }
2917
2918 llvm::StringRef getMessage() const {
2919 return llvm::StringRef(message, messageLength);
2920 }
2921 unsigned getMessageLength() const {
2922 return messageLength;
2923 }
2924 void setMessage(ASTContext &C, llvm::StringRef S) {
2925 messageLength = S.size();
2926 this->message = new (C, 1) char [messageLength];
2927 if (!S.empty())
2928 std::memcpy(this->message, S.data(), messageLength);
2929 }
2930
2931
2932
2933 static bool classof(const Attr *A) { return A->getKind() == attr::EnableIf; }
2934};
2935
2936class EnumExtensibilityAttr : public InheritableAttr {
2937public:
2938 enum Kind {
2939 Closed,
2940 Open
2941 };
2942private:
2943 Kind extensibility;
2944
2945public:
2946 static EnumExtensibilityAttr *CreateImplicit(ASTContext &Ctx, Kind Extensibility, SourceRange Loc = SourceRange()) {
2947 auto *A = new (Ctx) EnumExtensibilityAttr(Loc, Ctx, Extensibility, 0);
2948 A->setImplicit(true);
2949 return A;
2950 }
2951
2952 EnumExtensibilityAttr(SourceRange R, ASTContext &Ctx
2953 , Kind Extensibility
2954 , unsigned SI
2955 )
2956 : InheritableAttr(attr::EnumExtensibility, R, SI, false, false)
2957 , extensibility(Extensibility)
2958 {
2959 }
2960
2961 EnumExtensibilityAttr *clone(ASTContext &C) const;
2962 void printPretty(raw_ostream &OS,
2963 const PrintingPolicy &Policy) const;
2964 const char *getSpelling() const;
2965 Kind getExtensibility() const {
2966 return extensibility;
2967 }
2968
2969 static bool ConvertStrToKind(StringRef Val, Kind &Out) {
2970 Optional<Kind> R = llvm::StringSwitch<Optional<Kind>>(Val)
2971 .Case("closed", EnumExtensibilityAttr::Closed)
2972 .Case("open", EnumExtensibilityAttr::Open)
2973 .Default(Optional<Kind>());
2974 if (R) {
2975 Out = *R;
2976 return true;
2977 }
2978 return false;
2979 }
2980
2981 static const char *ConvertKindToStr(Kind Val) {
2982 switch(Val) {
2983 case EnumExtensibilityAttr::Closed: return "closed";
2984 case EnumExtensibilityAttr::Open: return "open";
2985 }
2986 llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 2986)
;
2987 }
2988
2989
2990 static bool classof(const Attr *A) { return A->getKind() == attr::EnumExtensibility; }
2991};
2992
2993class ExclusiveTrylockFunctionAttr : public InheritableAttr {
2994Expr * successValue;
2995
2996 unsigned args_Size;
2997 Expr * *args_;
2998
2999public:
3000 static ExclusiveTrylockFunctionAttr *CreateImplicit(ASTContext &Ctx, Expr * SuccessValue, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
3001 auto *A = new (Ctx) ExclusiveTrylockFunctionAttr(Loc, Ctx, SuccessValue, Args, ArgsSize, 0);
3002 A->setImplicit(true);
3003 return A;
3004 }
3005
3006 ExclusiveTrylockFunctionAttr(SourceRange R, ASTContext &Ctx
3007 , Expr * SuccessValue
3008 , Expr * *Args, unsigned ArgsSize
3009 , unsigned SI
3010 )
3011 : InheritableAttr(attr::ExclusiveTrylockFunction, R, SI, true, true)
3012 , successValue(SuccessValue)
3013 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
3014 {
3015 std::copy(Args, Args + args_Size, args_);
3016 }
3017
3018 ExclusiveTrylockFunctionAttr(SourceRange R, ASTContext &Ctx
3019 , Expr * SuccessValue
3020 , unsigned SI
3021 )
3022 : InheritableAttr(attr::ExclusiveTrylockFunction, R, SI, true, true)
3023 , successValue(SuccessValue)
3024 , args_Size(0), args_(nullptr)
3025 {
3026 }
3027
3028 ExclusiveTrylockFunctionAttr *clone(ASTContext &C) const;
3029 void printPretty(raw_ostream &OS,
3030 const PrintingPolicy &Policy) const;
3031 const char *getSpelling() const;
3032 Expr * getSuccessValue() const {
3033 return successValue;
3034 }
3035
3036 typedef Expr ** args_iterator;
3037 args_iterator args_begin() const { return args_; }
3038 args_iterator args_end() const { return args_ + args_Size; }
3039 unsigned args_size() const { return args_Size; }
3040 llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
3041
3042
3043
3044
3045 static bool classof(const Attr *A) { return A->getKind() == attr::ExclusiveTrylockFunction; }
3046};
3047
3048class ExternalSourceSymbolAttr : public InheritableAttr {
3049unsigned languageLength;
3050char *language;
3051
3052unsigned definedInLength;
3053char *definedIn;
3054
3055bool generatedDeclaration;
3056
3057public:
3058 static ExternalSourceSymbolAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Language, llvm::StringRef DefinedIn, bool GeneratedDeclaration, SourceRange Loc = SourceRange()) {
3059 auto *A = new (Ctx) ExternalSourceSymbolAttr(Loc, Ctx, Language, DefinedIn, GeneratedDeclaration, 0);
3060 A->setImplicit(true);
3061 return A;
3062 }
3063
3064 ExternalSourceSymbolAttr(SourceRange R, ASTContext &Ctx
3065 , llvm::StringRef Language
3066 , llvm::StringRef DefinedIn
3067 , bool GeneratedDeclaration
3068 , unsigned SI
3069 )
3070 : InheritableAttr(attr::ExternalSourceSymbol, R, SI, false, false)
3071 , languageLength(Language.size()),language(new (Ctx, 1) char[languageLength])
3072 , definedInLength(DefinedIn.size()),definedIn(new (Ctx, 1) char[definedInLength])
3073 , generatedDeclaration(GeneratedDeclaration)
3074 {
3075 if (!Language.empty())
3076 std::memcpy(language, Language.data(), languageLength);
3077 if (!DefinedIn.empty())
3078 std::memcpy(definedIn, DefinedIn.data(), definedInLength);
3079 }
3080
3081 ExternalSourceSymbolAttr(SourceRange R, ASTContext &Ctx
3082 , unsigned SI
3083 )
3084 : InheritableAttr(attr::ExternalSourceSymbol, R, SI, false, false)
3085 , languageLength(0),language(nullptr)
3086 , definedInLength(0),definedIn(nullptr)
3087 , generatedDeclaration()
3088 {
3089 }
3090
3091 ExternalSourceSymbolAttr *clone(ASTContext &C) const;
3092 void printPretty(raw_ostream &OS,
3093 const PrintingPolicy &Policy) const;
3094 const char *getSpelling() const;
3095 llvm::StringRef getLanguage() const {
3096 return llvm::StringRef(language, languageLength);
3097 }
3098 unsigned getLanguageLength() const {
3099 return languageLength;
3100 }
3101 void setLanguage(ASTContext &C, llvm::StringRef S) {
3102 languageLength = S.size();
3103 this->language = new (C, 1) char [languageLength];
3104 if (!S.empty())
3105 std::memcpy(this->language, S.data(), languageLength);
3106 }
3107
3108 llvm::StringRef getDefinedIn() const {
3109 return llvm::StringRef(definedIn, definedInLength);
3110 }
3111 unsigned getDefinedInLength() const {
3112 return definedInLength;
3113 }
3114 void setDefinedIn(ASTContext &C, llvm::StringRef S) {
3115 definedInLength = S.size();
3116 this->definedIn = new (C, 1) char [definedInLength];
3117 if (!S.empty())
3118 std::memcpy(this->definedIn, S.data(), definedInLength);
3119 }
3120
3121 bool getGeneratedDeclaration() const {
3122 return generatedDeclaration;
3123 }
3124
3125
3126
3127 static bool classof(const Attr *A) { return A->getKind() == attr::ExternalSourceSymbol; }
3128};
3129
3130class FallThroughAttr : public StmtAttr {
3131public:
3132 static FallThroughAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3133 auto *A = new (Ctx) FallThroughAttr(Loc, Ctx, 0);
3134 A->setImplicit(true);
3135 return A;
3136 }
3137
3138 FallThroughAttr(SourceRange R, ASTContext &Ctx
3139 , unsigned SI
3140 )
3141 : StmtAttr(attr::FallThrough, R, SI, false)
3142 {
3143 }
3144
3145 FallThroughAttr *clone(ASTContext &C) const;
3146 void printPretty(raw_ostream &OS,
3147 const PrintingPolicy &Policy) const;
3148 const char *getSpelling() const;
3149
3150
3151 static bool classof(const Attr *A) { return A->getKind() == attr::FallThrough; }
3152};
3153
3154class FastCallAttr : public InheritableAttr {
3155public:
3156 static FastCallAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3157 auto *A = new (Ctx) FastCallAttr(Loc, Ctx, 0);
3158 A->setImplicit(true);
3159 return A;
3160 }
3161
3162 FastCallAttr(SourceRange R, ASTContext &Ctx
3163 , unsigned SI
3164 )
3165 : InheritableAttr(attr::FastCall, R, SI, false, false)
3166 {
3167 }
3168
3169 FastCallAttr *clone(ASTContext &C) const;
3170 void printPretty(raw_ostream &OS,
3171 const PrintingPolicy &Policy) const;
3172 const char *getSpelling() const;
3173
3174
3175 static bool classof(const Attr *A) { return A->getKind() == attr::FastCall; }
3176};
3177
3178class FinalAttr : public InheritableAttr {
3179public:
3180 enum Spelling {
3181 Keyword_final = 0,
3182 Keyword_sealed = 1
3183 };
3184
3185 static FinalAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) {
3186 auto *A = new (Ctx) FinalAttr(Loc, Ctx, S);
3187 A->setImplicit(true);
3188 return A;
3189 }
3190
3191 FinalAttr(SourceRange R, ASTContext &Ctx
3192 , unsigned SI
3193 )
3194 : InheritableAttr(attr::Final, R, SI, false, false)
3195 {
3196 }
3197
3198 FinalAttr *clone(ASTContext &C) const;
3199 void printPretty(raw_ostream &OS,
3200 const PrintingPolicy &Policy) const;
3201 const char *getSpelling() const;
3202 Spelling getSemanticSpelling() const {
3203 switch (SpellingListIndex) {
3204 default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 3204)
;
3205 case 0: return Keyword_final;
3206 case 1: return Keyword_sealed;
3207 }
3208 }
3209 bool isSpelledAsSealed() const { return SpellingListIndex == 1; }
3210
3211
3212 static bool classof(const Attr *A) { return A->getKind() == attr::Final; }
3213};
3214
3215class FlagEnumAttr : public InheritableAttr {
3216public:
3217 static FlagEnumAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3218 auto *A = new (Ctx) FlagEnumAttr(Loc, Ctx, 0);
3219 A->setImplicit(true);
3220 return A;
3221 }
3222
3223 FlagEnumAttr(SourceRange R, ASTContext &Ctx
3224 , unsigned SI
3225 )
3226 : InheritableAttr(attr::FlagEnum, R, SI, false, false)
3227 {
3228 }
3229
3230 FlagEnumAttr *clone(ASTContext &C) const;
3231 void printPretty(raw_ostream &OS,
3232 const PrintingPolicy &Policy) const;
3233 const char *getSpelling() const;
3234
3235
3236 static bool classof(const Attr *A) { return A->getKind() == attr::FlagEnum; }
3237};
3238
3239class FlattenAttr : public InheritableAttr {
3240public:
3241 static FlattenAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3242 auto *A = new (Ctx) FlattenAttr(Loc, Ctx, 0);
3243 A->setImplicit(true);
3244 return A;
3245 }
3246
3247 FlattenAttr(SourceRange R, ASTContext &Ctx
3248 , unsigned SI
3249 )
3250 : InheritableAttr(attr::Flatten, R, SI, false, false)
3251 {
3252 }
3253
3254 FlattenAttr *clone(ASTContext &C) const;
3255 void printPretty(raw_ostream &OS,
3256 const PrintingPolicy &Policy) const;
3257 const char *getSpelling() const;
3258
3259
3260 static bool classof(const Attr *A) { return A->getKind() == attr::Flatten; }
3261};
3262
3263class FormatAttr : public InheritableAttr {
3264IdentifierInfo * type;
3265
3266int formatIdx;
3267
3268int firstArg;
3269
3270public:
3271 static FormatAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * Type, int FormatIdx, int FirstArg, SourceRange Loc = SourceRange()) {
3272 auto *A = new (Ctx) FormatAttr(Loc, Ctx, Type, FormatIdx, FirstArg, 0);
3273 A->setImplicit(true);
3274 return A;
3275 }
3276
3277 FormatAttr(SourceRange R, ASTContext &Ctx
3278 , IdentifierInfo * Type
3279 , int FormatIdx
3280 , int FirstArg
3281 , unsigned SI
3282 )
3283 : InheritableAttr(attr::Format, R, SI, false, false)
3284 , type(Type)
3285 , formatIdx(FormatIdx)
3286 , firstArg(FirstArg)
3287 {
3288 }
3289
3290 FormatAttr *clone(ASTContext &C) const;
3291 void printPretty(raw_ostream &OS,
3292 const PrintingPolicy &Policy) const;
3293 const char *getSpelling() const;
3294 IdentifierInfo * getType() const {
3295 return type;
3296 }
3297
3298 int getFormatIdx() const {
3299 return formatIdx;
3300 }
3301
3302 int getFirstArg() const {
3303 return firstArg;
3304 }
3305
3306
3307
3308 static bool classof(const Attr *A) { return A->getKind() == attr::Format; }
3309};
3310
3311class FormatArgAttr : public InheritableAttr {
3312ParamIdx formatIdx;
3313
3314public:
3315 static FormatArgAttr *CreateImplicit(ASTContext &Ctx, ParamIdx FormatIdx, SourceRange Loc = SourceRange()) {
3316 auto *A = new (Ctx) FormatArgAttr(Loc, Ctx, FormatIdx, 0);
3317 A->setImplicit(true);
3318 return A;
3319 }
3320
3321 FormatArgAttr(SourceRange R, ASTContext &Ctx
3322 , ParamIdx FormatIdx
3323 , unsigned SI
3324 )
3325 : InheritableAttr(attr::FormatArg, R, SI, false, false)
3326 , formatIdx(FormatIdx)
3327 {
3328 }
3329
3330 FormatArgAttr *clone(ASTContext &C) const;
3331 void printPretty(raw_ostream &OS,
3332 const PrintingPolicy &Policy) const;
3333 const char *getSpelling() const;
3334 ParamIdx getFormatIdx() const {
3335 return formatIdx;
3336 }
3337
3338
3339
3340 static bool classof(const Attr *A) { return A->getKind() == attr::FormatArg; }
3341};
3342
3343class GNUInlineAttr : public InheritableAttr {
3344public:
3345 static GNUInlineAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3346 auto *A = new (Ctx) GNUInlineAttr(Loc, Ctx, 0);
3347 A->setImplicit(true);
3348 return A;
3349 }
3350
3351 GNUInlineAttr(SourceRange R, ASTContext &Ctx
3352 , unsigned SI
3353 )
3354 : InheritableAttr(attr::GNUInline, R, SI, false, false)
3355 {
3356 }
3357
3358 GNUInlineAttr *clone(ASTContext &C) const;
3359 void printPretty(raw_ostream &OS,
3360 const PrintingPolicy &Policy) const;
3361 const char *getSpelling() const;
3362
3363
3364 static bool classof(const Attr *A) { return A->getKind() == attr::GNUInline; }
3365};
3366
3367class GuardedByAttr : public InheritableAttr {
3368Expr * arg;
3369
3370public:
3371 static GuardedByAttr *CreateImplicit(ASTContext &Ctx, Expr * Arg, SourceRange Loc = SourceRange()) {
3372 auto *A = new (Ctx) GuardedByAttr(Loc, Ctx, Arg, 0);
3373 A->setImplicit(true);
3374 return A;
3375 }
3376
3377 GuardedByAttr(SourceRange R, ASTContext &Ctx
3378 , Expr * Arg
3379 , unsigned SI
3380 )
3381 : InheritableAttr(attr::GuardedBy, R, SI, true, true)
3382 , arg(Arg)
3383 {
3384 }
3385
3386 GuardedByAttr *clone(ASTContext &C) const;
3387 void printPretty(raw_ostream &OS,
3388 const PrintingPolicy &Policy) const;
3389 const char *getSpelling() const;
3390 Expr * getArg() const {
3391 return arg;
3392 }
3393
3394
3395
3396 static bool classof(const Attr *A) { return A->getKind() == attr::GuardedBy; }
3397};
3398
3399class GuardedVarAttr : public InheritableAttr {
3400public:
3401 static GuardedVarAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3402 auto *A = new (Ctx) GuardedVarAttr(Loc, Ctx, 0);
3403 A->setImplicit(true);
3404 return A;
3405 }
3406
3407 GuardedVarAttr(SourceRange R, ASTContext &Ctx
3408 , unsigned SI
3409 )
3410 : InheritableAttr(attr::GuardedVar, R, SI, false, false)
3411 {
3412 }
3413
3414 GuardedVarAttr *clone(ASTContext &C) const;
3415 void printPretty(raw_ostream &OS,
3416 const PrintingPolicy &Policy) const;
3417 const char *getSpelling() const;
3418
3419
3420 static bool classof(const Attr *A) { return A->getKind() == attr::GuardedVar; }
3421};
3422
3423class HotAttr : public InheritableAttr {
3424public:
3425 static HotAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3426 auto *A = new (Ctx) HotAttr(Loc, Ctx, 0);
3427 A->setImplicit(true);
3428 return A;
3429 }
3430
3431 HotAttr(SourceRange R, ASTContext &Ctx
3432 , unsigned SI
3433 )
3434 : InheritableAttr(attr::Hot, R, SI, false, false)
3435 {
3436 }
3437
3438 HotAttr *clone(ASTContext &C) const;
3439 void printPretty(raw_ostream &OS,
3440 const PrintingPolicy &Policy) const;
3441 const char *getSpelling() const;
3442
3443
3444 static bool classof(const Attr *A) { return A->getKind() == attr::Hot; }
3445};
3446
3447class IBActionAttr : public InheritableAttr {
3448public:
3449 static IBActionAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3450 auto *A = new (Ctx) IBActionAttr(Loc, Ctx, 0);
3451 A->setImplicit(true);
3452 return A;
3453 }
3454
3455 IBActionAttr(SourceRange R, ASTContext &Ctx
3456 , unsigned SI
3457 )
3458 : InheritableAttr(attr::IBAction, R, SI, false, false)
3459 {
3460 }
3461
3462 IBActionAttr *clone(ASTContext &C) const;
3463 void printPretty(raw_ostream &OS,
3464 const PrintingPolicy &Policy) const;
3465 const char *getSpelling() const;
3466
3467
3468 static bool classof(const Attr *A) { return A->getKind() == attr::IBAction; }
3469};
3470
3471class IBOutletAttr : public InheritableAttr {
3472public:
3473 static IBOutletAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3474 auto *A = new (Ctx) IBOutletAttr(Loc, Ctx, 0);
3475 A->setImplicit(true);
3476 return A;
3477 }
3478
3479 IBOutletAttr(SourceRange R, ASTContext &Ctx
3480 , unsigned SI
3481 )
3482 : InheritableAttr(attr::IBOutlet, R, SI, false, false)
3483 {
3484 }
3485
3486 IBOutletAttr *clone(ASTContext &C) const;
3487 void printPretty(raw_ostream &OS,
3488 const PrintingPolicy &Policy) const;
3489 const char *getSpelling() const;
3490
3491
3492 static bool classof(const Attr *A) { return A->getKind() == attr::IBOutlet; }
3493};
3494
3495class IBOutletCollectionAttr : public InheritableAttr {
3496TypeSourceInfo * interface_;
3497
3498public:
3499 static IBOutletCollectionAttr *CreateImplicit(ASTContext &Ctx, TypeSourceInfo * Interface, SourceRange Loc = SourceRange()) {
3500 auto *A = new (Ctx) IBOutletCollectionAttr(Loc, Ctx, Interface, 0);
3501 A->setImplicit(true);
3502 return A;
3503 }
3504
3505 IBOutletCollectionAttr(SourceRange R, ASTContext &Ctx
3506 , TypeSourceInfo * Interface
3507 , unsigned SI
3508 )
3509 : InheritableAttr(attr::IBOutletCollection, R, SI, false, false)
3510 , interface_(Interface)
3511 {
3512 }
3513
3514 IBOutletCollectionAttr(SourceRange R, ASTContext &Ctx
3515 , unsigned SI
3516 )
3517 : InheritableAttr(attr::IBOutletCollection, R, SI, false, false)
3518 , interface_()
3519 {
3520 }
3521
3522 IBOutletCollectionAttr *clone(ASTContext &C) const;
3523 void printPretty(raw_ostream &OS,
3524 const PrintingPolicy &Policy) const;
3525 const char *getSpelling() const;
3526 QualType getInterface() const {
3527 return interface_->getType();
3528 } TypeSourceInfo * getInterfaceLoc() const {
3529 return interface_;
3530 }
3531
3532
3533
3534 static bool classof(const Attr *A) { return A->getKind() == attr::IBOutletCollection; }
3535};
3536
3537class IFuncAttr : public Attr {
3538unsigned resolverLength;
3539char *resolver;
3540
3541public:
3542 static IFuncAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Resolver, SourceRange Loc = SourceRange()) {
3543 auto *A = new (Ctx) IFuncAttr(Loc, Ctx, Resolver, 0);
3544 A->setImplicit(true);
3545 return A;
3546 }
3547
3548 IFuncAttr(SourceRange R, ASTContext &Ctx
3549 , llvm::StringRef Resolver
3550 , unsigned SI
3551 )
3552 : Attr(attr::IFunc, R, SI, false)
3553 , resolverLength(Resolver.size()),resolver(new (Ctx, 1) char[resolverLength])
3554 {
3555 if (!Resolver.empty())
3556 std::memcpy(resolver, Resolver.data(), resolverLength);
3557 }
3558
3559 IFuncAttr *clone(ASTContext &C) const;
3560 void printPretty(raw_ostream &OS,
3561 const PrintingPolicy &Policy) const;
3562 const char *getSpelling() const;
3563 llvm::StringRef getResolver() const {
3564 return llvm::StringRef(resolver, resolverLength);
3565 }
3566 unsigned getResolverLength() const {
3567 return resolverLength;
3568 }
3569 void setResolver(ASTContext &C, llvm::StringRef S) {
3570 resolverLength = S.size();
3571 this->resolver = new (C, 1) char [resolverLength];
3572 if (!S.empty())
3573 std::memcpy(this->resolver, S.data(), resolverLength);
3574 }
3575
3576
3577
3578 static bool classof(const Attr *A) { return A->getKind() == attr::IFunc; }
3579};
3580
3581class InitPriorityAttr : public InheritableAttr {
3582unsigned priority;
3583
3584public:
3585 static InitPriorityAttr *CreateImplicit(ASTContext &Ctx, unsigned Priority, SourceRange Loc = SourceRange()) {
3586 auto *A = new (Ctx) InitPriorityAttr(Loc, Ctx, Priority, 0);
3587 A->setImplicit(true);
3588 return A;
3589 }
3590
3591 InitPriorityAttr(SourceRange R, ASTContext &Ctx
3592 , unsigned Priority
3593 , unsigned SI
3594 )
3595 : InheritableAttr(attr::InitPriority, R, SI, false, false)
3596 , priority(Priority)
3597 {
3598 }
3599
3600 InitPriorityAttr *clone(ASTContext &C) const;
3601 void printPretty(raw_ostream &OS,
3602 const PrintingPolicy &Policy) const;
3603 const char *getSpelling() const;
3604 unsigned getPriority() const {
3605 return priority;
3606 }
3607
3608
3609
3610 static bool classof(const Attr *A) { return A->getKind() == attr::InitPriority; }
3611};
3612
3613class InitSegAttr : public Attr {
3614unsigned sectionLength;
3615char *section;
3616
3617public:
3618 static InitSegAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Section, SourceRange Loc = SourceRange()) {
3619 auto *A = new (Ctx) InitSegAttr(Loc, Ctx, Section, 0);
3620 A->setImplicit(true);
3621 return A;
3622 }
3623
3624 InitSegAttr(SourceRange R, ASTContext &Ctx
3625 , llvm::StringRef Section
3626 , unsigned SI
3627 )
3628 : Attr(attr::InitSeg, R, SI, false)
3629 , sectionLength(Section.size()),section(new (Ctx, 1) char[sectionLength])
3630 {
3631 if (!Section.empty())
3632 std::memcpy(section, Section.data(), sectionLength);
3633 }
3634
3635 InitSegAttr *clone(ASTContext &C) const;
3636 void printPretty(raw_ostream &OS,
3637 const PrintingPolicy &Policy) const;
3638 const char *getSpelling() const;
3639 llvm::StringRef getSection() const {
3640 return llvm::StringRef(section, sectionLength);
3641 }
3642 unsigned getSectionLength() const {
3643 return sectionLength;
3644 }
3645 void setSection(ASTContext &C, llvm::StringRef S) {
3646 sectionLength = S.size();
3647 this->section = new (C, 1) char [sectionLength];
3648 if (!S.empty())
3649 std::memcpy(this->section, S.data(), sectionLength);
3650 }
3651
3652
3653 void printPrettyPragma(raw_ostream &OS, const PrintingPolicy &Policy) const {
3654 OS << " (" << getSection() << ')';
3655 }
3656
3657
3658 static bool classof(const Attr *A) { return A->getKind() == attr::InitSeg; }
3659};
3660
3661class IntelOclBiccAttr : public InheritableAttr {
3662public:
3663 static IntelOclBiccAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3664 auto *A = new (Ctx) IntelOclBiccAttr(Loc, Ctx, 0);
3665 A->setImplicit(true);
3666 return A;
3667 }
3668
3669 IntelOclBiccAttr(SourceRange R, ASTContext &Ctx
3670 , unsigned SI
3671 )
3672 : InheritableAttr(attr::IntelOclBicc, R, SI, false, false)
3673 {
3674 }
3675
3676 IntelOclBiccAttr *clone(ASTContext &C) const;
3677 void printPretty(raw_ostream &OS,
3678 const PrintingPolicy &Policy) const;
3679 const char *getSpelling() const;
3680
3681
3682 static bool classof(const Attr *A) { return A->getKind() == attr::IntelOclBicc; }
3683};
3684
3685class InternalLinkageAttr : public InheritableAttr {
3686public:
3687 static InternalLinkageAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3688 auto *A = new (Ctx) InternalLinkageAttr(Loc, Ctx, 0);
3689 A->setImplicit(true);
3690 return A;
3691 }
3692
3693 InternalLinkageAttr(SourceRange R, ASTContext &Ctx
3694 , unsigned SI
3695 )
3696 : InheritableAttr(attr::InternalLinkage, R, SI, false, false)
3697 {
3698 }
3699
3700 InternalLinkageAttr *clone(ASTContext &C) const;
3701 void printPretty(raw_ostream &OS,
3702 const PrintingPolicy &Policy) const;
3703 const char *getSpelling() const;
3704
3705
3706 static bool classof(const Attr *A) { return A->getKind() == attr::InternalLinkage; }
3707};
3708
3709class LTOVisibilityPublicAttr : public InheritableAttr {
3710public:
3711 static LTOVisibilityPublicAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
3712 auto *A = new (Ctx) LTOVisibilityPublicAttr(Loc, Ctx, 0);
3713 A->setImplicit(true);
3714 return A;
3715 }
3716
3717 LTOVisibilityPublicAttr(SourceRange R, ASTContext &Ctx
3718 , unsigned SI
3719 )
3720 : InheritableAttr(attr::LTOVisibilityPublic, R, SI, false, false)
3721 {
3722 }
3723
3724 LTOVisibilityPublicAttr *clone(ASTContext &C) const;
3725 void printPretty(raw_ostream &OS,
3726 const PrintingPolicy &Policy) const;
3727 const char *getSpelling() const;
3728
3729
3730 static bool classof(const Attr *A) { return A->getKind() == attr::LTOVisibilityPublic; }
3731};
3732
3733class LayoutVersionAttr : public InheritableAttr {
3734unsigned version;
3735
3736public:
3737 static LayoutVersionAttr *CreateImplicit(ASTContext &Ctx, unsigned Version, SourceRange Loc = SourceRange()) {
3738 auto *A = new (Ctx) LayoutVersionAttr(Loc, Ctx, Version, 0);
3739 A->setImplicit(true);
3740 return A;
3741 }
3742
3743 LayoutVersionAttr(SourceRange R, ASTContext &Ctx
3744 , unsigned Version
3745 , unsigned SI
3746 )
3747 : InheritableAttr(attr::LayoutVersion, R, SI, false, false)
3748 , version(Version)
3749 {
3750 }
3751
3752 LayoutVersionAttr *clone(ASTContext &C) const;
3753 void printPretty(raw_ostream &OS,
3754 const PrintingPolicy &Policy) const;
3755 const char *getSpelling() const;
3756 unsigned getVersion() const {
3757 return version;
3758 }
3759
3760
3761
3762 static bool classof(const Attr *A) { return A->getKind() == attr::LayoutVersion; }
3763};
3764
3765class LockReturnedAttr : public InheritableAttr {
3766Expr * arg;
3767
3768public:
3769 static LockReturnedAttr *CreateImplicit(ASTContext &Ctx, Expr * Arg, SourceRange Loc = SourceRange()) {
3770 auto *A = new (Ctx) LockReturnedAttr(Loc, Ctx, Arg, 0);
3771 A->setImplicit(true);
3772 return A;
3773 }
3774
3775 LockReturnedAttr(SourceRange R, ASTContext &Ctx
3776 , Expr * Arg
3777 , unsigned SI
3778 )
3779 : InheritableAttr(attr::LockReturned, R, SI, true, false)
3780 , arg(Arg)
3781 {
3782 }
3783
3784 LockReturnedAttr *clone(ASTContext &C) const;
3785 void printPretty(raw_ostream &OS,
3786 const PrintingPolicy &Policy) const;
3787 const char *getSpelling() const;
3788 Expr * getArg() const {
3789 return arg;
3790 }
3791
3792
3793
3794 static bool classof(const Attr *A) { return A->getKind() == attr::LockReturned; }
3795};
3796
3797class LocksExcludedAttr : public InheritableAttr {
3798 unsigned args_Size;
3799 Expr * *args_;
3800
3801public:
3802 static LocksExcludedAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
3803 auto *A = new (Ctx) LocksExcludedAttr(Loc, Ctx, Args, ArgsSize, 0);
3804 A->setImplicit(true);
3805 return A;
3806 }
3807
3808 LocksExcludedAttr(SourceRange R, ASTContext &Ctx
3809 , Expr * *Args, unsigned ArgsSize
3810 , unsigned SI
3811 )
3812 : InheritableAttr(attr::LocksExcluded, R, SI, true, true)
3813 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
3814 {
3815 std::copy(Args, Args + args_Size, args_);
3816 }
3817
3818 LocksExcludedAttr(SourceRange R, ASTContext &Ctx
3819 , unsigned SI
3820 )
3821 : InheritableAttr(attr::LocksExcluded, R, SI, true, true)
3822 , args_Size(0), args_(nullptr)
3823 {
3824 }
3825
3826 LocksExcludedAttr *clone(ASTContext &C) const;
3827 void printPretty(raw_ostream &OS,
3828 const PrintingPolicy &Policy) const;
3829 const char *getSpelling() const;
3830 typedef Expr ** args_iterator;
3831 args_iterator args_begin() const { return args_; }
3832 args_iterator args_end() const { return args_ + args_Size; }
3833 unsigned args_size() const { return args_Size; }
3834 llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
3835
3836
3837
3838
3839 static bool classof(const Attr *A) { return A->getKind() == attr::LocksExcluded; }
3840};
3841
3842class LoopHintAttr : public Attr {
3843public:
3844 enum OptionType {
3845 Vectorize,
3846 VectorizeWidth,
3847 Interleave,
3848 InterleaveCount,
3849 Unroll,
3850 UnrollCount,
3851 Distribute
3852 };
3853private:
3854 OptionType option;
3855
3856public:
3857 enum LoopHintState {
3858 Enable,
3859 Disable,
3860 Numeric,
3861 AssumeSafety,
3862 Full
3863 };
3864private:
3865 LoopHintState state;
3866
3867Expr * value;
3868
3869public:
3870 enum Spelling {
3871 Pragma_clang_loop = 0,
3872 Pragma_unroll = 1,
3873 Pragma_nounroll = 2
3874 };
3875
3876 static LoopHintAttr *CreateImplicit(ASTContext &Ctx, Spelling S, OptionType Option, LoopHintState State, Expr * Value, SourceRange Loc = SourceRange()) {
3877 auto *A = new (Ctx) LoopHintAttr(Loc, Ctx, Option, State, Value, S);
3878 A->setImplicit(true);
3879 return A;
3880 }
3881
3882 LoopHintAttr(SourceRange R, ASTContext &Ctx
3883 , OptionType Option
3884 , LoopHintState State
3885 , Expr * Value
3886 , unsigned SI
3887 )
3888 : Attr(attr::LoopHint, R, SI, false)
3889 , option(Option)
3890 , state(State)
3891 , value(Value)
3892 {
3893 }
3894
3895 LoopHintAttr *clone(ASTContext &C) const;
3896 void printPretty(raw_ostream &OS,
3897 const PrintingPolicy &Policy) const;
3898 const char *getSpelling() const;
3899 Spelling getSemanticSpelling() const {
3900 switch (SpellingListIndex) {
3901 default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 3901)
;
3902 case 0: return Pragma_clang_loop;
3903 case 1: return Pragma_unroll;
3904 case 2: return Pragma_nounroll;
3905 }
3906 }
3907 OptionType getOption() const {
3908 return option;
3909 }
3910
3911 static bool ConvertStrToOptionType(StringRef Val, OptionType &Out) {
3912 Optional<OptionType> R = llvm::StringSwitch<Optional<OptionType>>(Val)
3913 .Case("vectorize", LoopHintAttr::Vectorize)
3914 .Case("vectorize_width", LoopHintAttr::VectorizeWidth)
3915 .Case("interleave", LoopHintAttr::Interleave)
3916 .Case("interleave_count", LoopHintAttr::InterleaveCount)
3917 .Case("unroll", LoopHintAttr::Unroll)
3918 .Case("unroll_count", LoopHintAttr::UnrollCount)
3919 .Case("distribute", LoopHintAttr::Distribute)
3920 .Default(Optional<OptionType>());
3921 if (R) {
3922 Out = *R;
3923 return true;
3924 }
3925 return false;
3926 }
3927
3928 static const char *ConvertOptionTypeToStr(OptionType Val) {
3929 switch(Val) {
3930 case LoopHintAttr::Vectorize: return "vectorize";
3931 case LoopHintAttr::VectorizeWidth: return "vectorize_width";
3932 case LoopHintAttr::Interleave: return "interleave";
3933 case LoopHintAttr::InterleaveCount: return "interleave_count";
3934 case LoopHintAttr::Unroll: return "unroll";
3935 case LoopHintAttr::UnrollCount: return "unroll_count";
3936 case LoopHintAttr::Distribute: return "distribute";
3937 }
3938 llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 3938)
;
3939 }
3940 LoopHintState getState() const {
3941 return state;
3942 }
3943
3944 static bool ConvertStrToLoopHintState(StringRef Val, LoopHintState &Out) {
3945 Optional<LoopHintState> R = llvm::StringSwitch<Optional<LoopHintState>>(Val)
3946 .Case("enable", LoopHintAttr::Enable)
3947 .Case("disable", LoopHintAttr::Disable)
3948 .Case("numeric", LoopHintAttr::Numeric)
3949 .Case("assume_safety", LoopHintAttr::AssumeSafety)
3950 .Case("full", LoopHintAttr::Full)
3951 .Default(Optional<LoopHintState>());
3952 if (R) {
3953 Out = *R;
3954 return true;
3955 }
3956 return false;
3957 }
3958
3959 static const char *ConvertLoopHintStateToStr(LoopHintState Val) {
3960 switch(Val) {
3961 case LoopHintAttr::Enable: return "enable";
3962 case LoopHintAttr::Disable: return "disable";
3963 case LoopHintAttr::Numeric: return "numeric";
3964 case LoopHintAttr::AssumeSafety: return "assume_safety";
3965 case LoopHintAttr::Full: return "full";
3966 }
3967 llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 3967)
;
3968 }
3969 Expr * getValue() const {
3970 return value;
3971 }
3972
3973
3974 static const char *getOptionName(int Option) {
3975 switch(Option) {
3976 case Vectorize: return "vectorize";
3977 case VectorizeWidth: return "vectorize_width";
3978 case Interleave: return "interleave";
3979 case InterleaveCount: return "interleave_count";
3980 case Unroll: return "unroll";
3981 case UnrollCount: return "unroll_count";
3982 case Distribute: return "distribute";
3983 }
3984 llvm_unreachable("Unhandled LoopHint option.")::llvm::llvm_unreachable_internal("Unhandled LoopHint option."
, "/build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 3984)
;
3985 }
3986
3987 void printPrettyPragma(raw_ostream &OS, const PrintingPolicy &Policy) const {
3988 unsigned SpellingIndex = getSpellingListIndex();
3989 // For "#pragma unroll" and "#pragma nounroll" the string "unroll" or
3990 // "nounroll" is already emitted as the pragma name.
3991 if (SpellingIndex == Pragma_nounroll)
3992 return;
3993 else if (SpellingIndex == Pragma_unroll) {
3994 OS << ' ' << getValueString(Policy);
3995 return;
3996 }
3997
3998 assert(SpellingIndex == Pragma_clang_loop && "Unexpected spelling")(static_cast <bool> (SpellingIndex == Pragma_clang_loop
&& "Unexpected spelling") ? void (0) : __assert_fail
("SpellingIndex == Pragma_clang_loop && \"Unexpected spelling\""
, "/build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 3998, __extension__ __PRETTY_FUNCTION__))
;
3999 OS << ' ' << getOptionName(option) << getValueString(Policy);
4000 }
4001
4002 // Return a string containing the loop hint argument including the
4003 // enclosing parentheses.
4004 std::string getValueString(const PrintingPolicy &Policy) const {
4005 std::string ValueName;
4006 llvm::raw_string_ostream OS(ValueName);
4007 OS << "(";
4008 if (state == Numeric)
4009 value->printPretty(OS, nullptr, Policy);
4010 else if (state == Enable)
4011 OS << "enable";
4012 else if (state == Full)
4013 OS << "full";
4014 else if (state == AssumeSafety)
4015 OS << "assume_safety";
4016 else
4017 OS << "disable";
4018 OS << ")";
4019 return OS.str();
4020 }
4021
4022 // Return a string suitable for identifying this attribute in diagnostics.
4023 std::string getDiagnosticName(const PrintingPolicy &Policy) const {
4024 unsigned SpellingIndex = getSpellingListIndex();
4025 if (SpellingIndex == Pragma_nounroll)
4026 return "#pragma nounroll";
4027 else if (SpellingIndex == Pragma_unroll)
4028 return "#pragma unroll" + (option == UnrollCount ? getValueString(Policy) : "");
4029
4030 assert(SpellingIndex == Pragma_clang_loop && "Unexpected spelling")(static_cast <bool> (SpellingIndex == Pragma_clang_loop
&& "Unexpected spelling") ? void (0) : __assert_fail
("SpellingIndex == Pragma_clang_loop && \"Unexpected spelling\""
, "/build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 4030, __extension__ __PRETTY_FUNCTION__))
;
4031 return getOptionName(option) + getValueString(Policy);
4032 }
4033
4034
4035 static bool classof(const Attr *A) { return A->getKind() == attr::LoopHint; }
4036};
4037
4038class MSABIAttr : public InheritableAttr {
4039public:
4040 static MSABIAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4041 auto *A = new (Ctx) MSABIAttr(Loc, Ctx, 0);
4042 A->setImplicit(true);
4043 return A;
4044 }
4045
4046 MSABIAttr(SourceRange R, ASTContext &Ctx
4047 , unsigned SI
4048 )
4049 : InheritableAttr(attr::MSABI, R, SI, false, false)
4050 {
4051 }
4052
4053 MSABIAttr *clone(ASTContext &C) const;
4054 void printPretty(raw_ostream &OS,
4055 const PrintingPolicy &Policy) const;
4056 const char *getSpelling() const;
4057
4058
4059 static bool classof(const Attr *A) { return A->getKind() == attr::MSABI; }
4060};
4061
4062class MSInheritanceAttr : public InheritableAttr {
4063bool bestCase;
4064
4065public:
4066 enum Spelling {
4067 Keyword_single_inheritance = 0,
4068 Keyword_multiple_inheritance = 1,
4069 Keyword_virtual_inheritance = 2,
4070 Keyword_unspecified_inheritance = 3
4071 };
4072
4073 static MSInheritanceAttr *CreateImplicit(ASTContext &Ctx, Spelling S, bool BestCase, SourceRange Loc = SourceRange()) {
4074 auto *A = new (Ctx) MSInheritanceAttr(Loc, Ctx, BestCase, S);
4075 A->setImplicit(true);
4076 return A;
4077 }
4078
4079 static MSInheritanceAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) {
4080 auto *A = new (Ctx) MSInheritanceAttr(Loc, Ctx, S);
4081 A->setImplicit(true);
4082 return A;
4083 }
4084
4085 MSInheritanceAttr(SourceRange R, ASTContext &Ctx
4086 , bool BestCase
4087 , unsigned SI
4088 )
4089 : InheritableAttr(attr::MSInheritance, R, SI, false, false)
4090 , bestCase(BestCase)
4091 {
4092 }
4093
4094 MSInheritanceAttr(SourceRange R, ASTContext &Ctx
4095 , unsigned SI
4096 )
4097 : InheritableAttr(attr::MSInheritance, R, SI, false, false)
4098 , bestCase()
4099 {
4100 }
4101
4102 MSInheritanceAttr *clone(ASTContext &C) const;
4103 void printPretty(raw_ostream &OS,
4104 const PrintingPolicy &Policy) const;
4105 const char *getSpelling() const;
4106 Spelling getSemanticSpelling() const {
4107 switch (SpellingListIndex) {
4108 default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 4108)
;
4109 case 0: return Keyword_single_inheritance;
4110 case 1: return Keyword_multiple_inheritance;
4111 case 2: return Keyword_virtual_inheritance;
4112 case 3: return Keyword_unspecified_inheritance;
4113 }
4114 }
4115 bool getBestCase() const {
4116 return bestCase;
4117 }
4118
4119 static const bool DefaultBestCase = true;
4120
4121
4122 static bool hasVBPtrOffsetField(Spelling Inheritance) {
4123 return Inheritance == Keyword_unspecified_inheritance;
4124 }
4125
4126 // Only member pointers to functions need a this adjustment, since it can be
4127 // combined with the field offset for data pointers.
4128 static bool hasNVOffsetField(bool IsMemberFunction, Spelling Inheritance) {
4129 return IsMemberFunction && Inheritance >= Keyword_multiple_inheritance;
4130 }
4131
4132 static bool hasVBTableOffsetField(Spelling Inheritance) {
4133 return Inheritance >= Keyword_virtual_inheritance;
4134 }
4135
4136 static bool hasOnlyOneField(bool IsMemberFunction,
4137 Spelling Inheritance) {
4138 if (IsMemberFunction)
4139 return Inheritance <= Keyword_single_inheritance;
4140 return Inheritance <= Keyword_multiple_inheritance;
4141 }
4142
4143
4144 static bool classof(const Attr *A) { return A->getKind() == attr::MSInheritance; }
4145};
4146
4147class MSNoVTableAttr : public InheritableAttr {
4148public:
4149 static MSNoVTableAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4150 auto *A = new (Ctx) MSNoVTableAttr(Loc, Ctx, 0);
4151 A->setImplicit(true);
4152 return A;
4153 }
4154
4155 MSNoVTableAttr(SourceRange R, ASTContext &Ctx
4156 , unsigned SI
4157 )
4158 : InheritableAttr(attr::MSNoVTable, R, SI, false, false)
4159 {
4160 }
4161
4162 MSNoVTableAttr *clone(ASTContext &C) const;
4163 void printPretty(raw_ostream &OS,
4164 const PrintingPolicy &Policy) const;
4165 const char *getSpelling() const;
4166
4167
4168 static bool classof(const Attr *A) { return A->getKind() == attr::MSNoVTable; }
4169};
4170
4171class MSP430InterruptAttr : public InheritableAttr {
4172unsigned number;
4173
4174public:
4175 static MSP430InterruptAttr *CreateImplicit(ASTContext &Ctx, unsigned Number, SourceRange Loc = SourceRange()) {
4176 auto *A = new (Ctx) MSP430InterruptAttr(Loc, Ctx, Number, 0);
4177 A->setImplicit(true);
4178 return A;
4179 }
4180
4181 MSP430InterruptAttr(SourceRange R, ASTContext &Ctx
4182 , unsigned Number
4183 , unsigned SI
4184 )
4185 : InheritableAttr(attr::MSP430Interrupt, R, SI, false, false)
4186 , number(Number)
4187 {
4188 }
4189
4190 MSP430InterruptAttr *clone(ASTContext &C) const;
4191 void printPretty(raw_ostream &OS,
4192 const PrintingPolicy &Policy) const;
4193 const char *getSpelling() const;
4194 unsigned getNumber() const {
4195 return number;
4196 }
4197
4198
4199
4200 static bool classof(const Attr *A) { return A->getKind() == attr::MSP430Interrupt; }
4201};
4202
4203class MSStructAttr : public InheritableAttr {
4204public:
4205 static MSStructAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4206 auto *A = new (Ctx) MSStructAttr(Loc, Ctx, 0);
4207 A->setImplicit(true);
4208 return A;
4209 }
4210
4211 MSStructAttr(SourceRange R, ASTContext &Ctx
4212 , unsigned SI
4213 )
4214 : InheritableAttr(attr::MSStruct, R, SI, false, false)
4215 {
4216 }
4217
4218 MSStructAttr *clone(ASTContext &C) const;
4219 void printPretty(raw_ostream &OS,
4220 const PrintingPolicy &Policy) const;
4221 const char *getSpelling() const;
4222
4223
4224 static bool classof(const Attr *A) { return A->getKind() == attr::MSStruct; }
4225};
4226
4227class MSVtorDispAttr : public InheritableAttr {
4228unsigned vdm;
4229
4230public:
4231 static MSVtorDispAttr *CreateImplicit(ASTContext &Ctx, unsigned Vdm, SourceRange Loc = SourceRange()) {
4232 auto *A = new (Ctx) MSVtorDispAttr(Loc, Ctx, Vdm, 0);
4233 A->setImplicit(true);
4234 return A;
4235 }
4236
4237 MSVtorDispAttr(SourceRange R, ASTContext &Ctx
4238 , unsigned Vdm
4239 , unsigned SI
4240 )
4241 : InheritableAttr(attr::MSVtorDisp, R, SI, false, false)
4242 , vdm(Vdm)
4243 {
4244 }
4245
4246 MSVtorDispAttr *clone(ASTContext &C) const;
4247 void printPretty(raw_ostream &OS,
4248 const PrintingPolicy &Policy) const;
4249 const char *getSpelling() const;
4250 unsigned getVdm() const {
4251 return vdm;
4252 }
4253
4254
4255 enum Mode {
4256 Never,
4257 ForVBaseOverride,
4258 ForVFTable
4259 };
4260
4261 Mode getVtorDispMode() const { return Mode(vdm); }
4262
4263
4264 static bool classof(const Attr *A) { return A->getKind() == attr::MSVtorDisp; }
4265};
4266
4267class MaxFieldAlignmentAttr : public InheritableAttr {
4268unsigned alignment;
4269
4270public:
4271 static MaxFieldAlignmentAttr *CreateImplicit(ASTContext &Ctx, unsigned Alignment, SourceRange Loc = SourceRange()) {
4272 auto *A = new (Ctx) MaxFieldAlignmentAttr(Loc, Ctx, Alignment, 0);
4273 A->setImplicit(true);
4274 return A;
4275 }
4276
4277 MaxFieldAlignmentAttr(SourceRange R, ASTContext &Ctx
4278 , unsigned Alignment
4279 , unsigned SI
4280 )
4281 : InheritableAttr(attr::MaxFieldAlignment, R, SI, false, false)
4282 , alignment(Alignment)
4283 {
4284 }
4285
4286 MaxFieldAlignmentAttr *clone(ASTContext &C) const;
4287 void printPretty(raw_ostream &OS,
4288 const PrintingPolicy &Policy) const;
4289 const char *getSpelling() const;
4290 unsigned getAlignment() const {
4291 return alignment;
4292 }
4293
4294
4295
4296 static bool classof(const Attr *A) { return A->getKind() == attr::MaxFieldAlignment; }
4297};
4298
4299class MayAliasAttr : public InheritableAttr {
4300public:
4301 static MayAliasAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4302 auto *A = new (Ctx) MayAliasAttr(Loc, Ctx, 0);
4303 A->setImplicit(true);
4304 return A;
4305 }
4306
4307 MayAliasAttr(SourceRange R, ASTContext &Ctx
4308 , unsigned SI
4309 )
4310 : InheritableAttr(attr::MayAlias, R, SI, false, false)
4311 {
4312 }
4313
4314 MayAliasAttr *clone(ASTContext &C) const;
4315 void printPretty(raw_ostream &OS,
4316 const PrintingPolicy &Policy) const;
4317 const char *getSpelling() const;
4318
4319
4320 static bool classof(const Attr *A) { return A->getKind() == attr::MayAlias; }
4321};
4322
4323class MicroMipsAttr : public InheritableAttr {
4324public:
4325 static MicroMipsAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4326 auto *A = new (Ctx) MicroMipsAttr(Loc, Ctx, 0);
4327 A->setImplicit(true);
4328 return A;
4329 }
4330
4331 MicroMipsAttr(SourceRange R, ASTContext &Ctx
4332 , unsigned SI
4333 )
4334 : InheritableAttr(attr::MicroMips, R, SI, false, false)
4335 {
4336 }
4337
4338 MicroMipsAttr *clone(ASTContext &C) const;
4339 void printPretty(raw_ostream &OS,
4340 const PrintingPolicy &Policy) const;
4341 const char *getSpelling() const;
4342
4343
4344 static bool classof(const Attr *A) { return A->getKind() == attr::MicroMips; }
4345};
4346
4347class MinSizeAttr : public InheritableAttr {
4348public:
4349 static MinSizeAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4350 auto *A = new (Ctx) MinSizeAttr(Loc, Ctx, 0);
4351 A->setImplicit(true);
4352 return A;
4353 }
4354
4355 MinSizeAttr(SourceRange R, ASTContext &Ctx
4356 , unsigned SI
4357 )
4358 : InheritableAttr(attr::MinSize, R, SI, false, false)
4359 {
4360 }
4361
4362 MinSizeAttr *clone(ASTContext &C) const;
4363 void printPretty(raw_ostream &OS,
4364 const PrintingPolicy &Policy) const;
4365 const char *getSpelling() const;
4366
4367
4368 static bool classof(const Attr *A) { return A->getKind() == attr::MinSize; }
4369};
4370
4371class MinVectorWidthAttr : public InheritableAttr {
4372unsigned vectorWidth;
4373
4374public:
4375 static MinVectorWidthAttr *CreateImplicit(ASTContext &Ctx, unsigned VectorWidth, SourceRange Loc = SourceRange()) {
4376 auto *A = new (Ctx) MinVectorWidthAttr(Loc, Ctx, VectorWidth, 0);
4377 A->setImplicit(true);
4378 return A;
4379 }
4380
4381 MinVectorWidthAttr(SourceRange R, ASTContext &Ctx
4382 , unsigned VectorWidth
4383 , unsigned SI
4384 )
4385 : InheritableAttr(attr::MinVectorWidth, R, SI, false, false)
4386 , vectorWidth(VectorWidth)
4387 {
4388 }
4389
4390 MinVectorWidthAttr *clone(ASTContext &C) const;
4391 void printPretty(raw_ostream &OS,
4392 const PrintingPolicy &Policy) const;
4393 const char *getSpelling() const;
4394 unsigned getVectorWidth() const {
4395 return vectorWidth;
4396 }
4397
4398
4399
4400 static bool classof(const Attr *A) { return A->getKind() == attr::MinVectorWidth; }
4401};
4402
4403class Mips16Attr : public InheritableAttr {
4404public:
4405 static Mips16Attr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4406 auto *A = new (Ctx) Mips16Attr(Loc, Ctx, 0);
4407 A->setImplicit(true);
4408 return A;
4409 }
4410
4411 Mips16Attr(SourceRange R, ASTContext &Ctx
4412 , unsigned SI
4413 )
4414 : InheritableAttr(attr::Mips16, R, SI, false, false)
4415 {
4416 }
4417
4418 Mips16Attr *clone(ASTContext &C) const;
4419 void printPretty(raw_ostream &OS,
4420 const PrintingPolicy &Policy) const;
4421 const char *getSpelling() const;
4422
4423
4424 static bool classof(const Attr *A) { return A->getKind() == attr::Mips16; }
4425};
4426
4427class MipsInterruptAttr : public InheritableAttr {
4428public:
4429 enum InterruptType {
4430 sw0,
4431 sw1,
4432 hw0,
4433 hw1,
4434 hw2,
4435 hw3,
4436 hw4,
4437 hw5,
4438 eic
4439 };
4440private:
4441 InterruptType interrupt;
4442
4443public:
4444 static MipsInterruptAttr *CreateImplicit(ASTContext &Ctx, InterruptType Interrupt, SourceRange Loc = SourceRange()) {
4445 auto *A = new (Ctx) MipsInterruptAttr(Loc, Ctx, Interrupt, 0);
4446 A->setImplicit(true);
4447 return A;
4448 }
4449
4450 MipsInterruptAttr(SourceRange R, ASTContext &Ctx
4451 , InterruptType Interrupt
4452 , unsigned SI
4453 )
4454 : InheritableAttr(attr::MipsInterrupt, R, SI, false, false)
4455 , interrupt(Interrupt)
4456 {
4457 }
4458
4459 MipsInterruptAttr *clone(ASTContext &C) const;
4460 void printPretty(raw_ostream &OS,
4461 const PrintingPolicy &Policy) const;
4462 const char *getSpelling() const;
4463 InterruptType getInterrupt() const {
4464 return interrupt;
4465 }
4466
4467 static bool ConvertStrToInterruptType(StringRef Val, InterruptType &Out) {
4468 Optional<InterruptType> R = llvm::StringSwitch<Optional<InterruptType>>(Val)
4469 .Case("vector=sw0", MipsInterruptAttr::sw0)
4470 .Case("vector=sw1", MipsInterruptAttr::sw1)
4471 .Case("vector=hw0", MipsInterruptAttr::hw0)
4472 .Case("vector=hw1", MipsInterruptAttr::hw1)
4473 .Case("vector=hw2", MipsInterruptAttr::hw2)
4474 .Case("vector=hw3", MipsInterruptAttr::hw3)
4475 .Case("vector=hw4", MipsInterruptAttr::hw4)
4476 .Case("vector=hw5", MipsInterruptAttr::hw5)
4477 .Case("eic", MipsInterruptAttr::eic)
4478 .Case("", MipsInterruptAttr::eic)
4479 .Default(Optional<InterruptType>());
4480 if (R) {
4481 Out = *R;
4482 return true;
4483 }
4484 return false;
4485 }
4486
4487 static const char *ConvertInterruptTypeToStr(InterruptType Val) {
4488 switch(Val) {
4489 case MipsInterruptAttr::sw0: return "vector=sw0";
4490 case MipsInterruptAttr::sw1: return "vector=sw1";
4491 case MipsInterruptAttr::hw0: return "vector=hw0";
4492 case MipsInterruptAttr::hw1: return "vector=hw1";
4493 case MipsInterruptAttr::hw2: return "vector=hw2";
4494 case MipsInterruptAttr::hw3: return "vector=hw3";
4495 case MipsInterruptAttr::hw4: return "vector=hw4";
4496 case MipsInterruptAttr::hw5: return "vector=hw5";
4497 case MipsInterruptAttr::eic: return "eic";
4498 }
4499 llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 4499)
;
4500 }
4501
4502
4503 static bool classof(const Attr *A) { return A->getKind() == attr::MipsInterrupt; }
4504};
4505
4506class MipsLongCallAttr : public InheritableAttr {
4507public:
4508 enum Spelling {
4509 GNU_long_call = 0,
4510 CXX11_gnu_long_call = 1,
4511 GNU_far = 2,
4512 CXX11_gnu_far = 3
4513 };
4514
4515 static MipsLongCallAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) {
4516 auto *A = new (Ctx) MipsLongCallAttr(Loc, Ctx, S);
4517 A->setImplicit(true);
4518 return A;
4519 }
4520
4521 MipsLongCallAttr(SourceRange R, ASTContext &Ctx
4522 , unsigned SI
4523 )
4524 : InheritableAttr(attr::MipsLongCall, R, SI, false, false)
4525 {
4526 }
4527
4528 MipsLongCallAttr *clone(ASTContext &C) const;
4529 void printPretty(raw_ostream &OS,
4530 const PrintingPolicy &Policy) const;
4531 const char *getSpelling() const;
4532 Spelling getSemanticSpelling() const {
4533 switch (SpellingListIndex) {
4534 default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 4534)
;
4535 case 0: return GNU_long_call;
4536 case 1: return CXX11_gnu_long_call;
4537 case 2: return GNU_far;
4538 case 3: return CXX11_gnu_far;
4539 }
4540 }
4541
4542
4543 static bool classof(const Attr *A) { return A->getKind() == attr::MipsLongCall; }
4544};
4545
4546class MipsShortCallAttr : public InheritableAttr {
4547public:
4548 enum Spelling {
4549 GNU_short_call = 0,
4550 CXX11_gnu_short_call = 1,
4551 GNU_near = 2,
4552 CXX11_gnu_near = 3
4553 };
4554
4555 static MipsShortCallAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) {
4556 auto *A = new (Ctx) MipsShortCallAttr(Loc, Ctx, S);
4557 A->setImplicit(true);
4558 return A;
4559 }
4560
4561 MipsShortCallAttr(SourceRange R, ASTContext &Ctx
4562 , unsigned SI
4563 )
4564 : InheritableAttr(attr::MipsShortCall, R, SI, false, false)
4565 {
4566 }
4567
4568 MipsShortCallAttr *clone(ASTContext &C) const;
4569 void printPretty(raw_ostream &OS,
4570 const PrintingPolicy &Policy) const;
4571 const char *getSpelling() const;
4572 Spelling getSemanticSpelling() const {
4573 switch (SpellingListIndex) {
4574 default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 4574)
;
4575 case 0: return GNU_short_call;
4576 case 1: return CXX11_gnu_short_call;
4577 case 2: return GNU_near;
4578 case 3: return CXX11_gnu_near;
4579 }
4580 }
4581
4582
4583 static bool classof(const Attr *A) { return A->getKind() == attr::MipsShortCall; }
4584};
4585
4586class ModeAttr : public Attr {
4587IdentifierInfo * mode;
4588
4589public:
4590 static ModeAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * Mode, SourceRange Loc = SourceRange()) {
4591 auto *A = new (Ctx) ModeAttr(Loc, Ctx, Mode, 0);
4592 A->setImplicit(true);
4593 return A;
4594 }
4595
4596 ModeAttr(SourceRange R, ASTContext &Ctx
4597 , IdentifierInfo * Mode
4598 , unsigned SI
4599 )
4600 : Attr(attr::Mode, R, SI, false)
4601 , mode(Mode)
4602 {
4603 }
4604
4605 ModeAttr *clone(ASTContext &C) const;
4606 void printPretty(raw_ostream &OS,
4607 const PrintingPolicy &Policy) const;
4608 const char *getSpelling() const;
4609 IdentifierInfo * getMode() const {
4610 return mode;
4611 }
4612
4613
4614
4615 static bool classof(const Attr *A) { return A->getKind() == attr::Mode; }
4616};
4617
4618class NSConsumedAttr : public InheritableParamAttr {
4619public:
4620 static NSConsumedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4621 auto *A = new (Ctx) NSConsumedAttr(Loc, Ctx, 0);
4622 A->setImplicit(true);
4623 return A;
4624 }
4625
4626 NSConsumedAttr(SourceRange R, ASTContext &Ctx
4627 , unsigned SI
4628 )
4629 : InheritableParamAttr(attr::NSConsumed, R, SI, false, false)
4630 {
4631 }
4632
4633 NSConsumedAttr *clone(ASTContext &C) const;
4634 void printPretty(raw_ostream &OS,
4635 const PrintingPolicy &Policy) const;
4636 const char *getSpelling() const;
4637
4638
4639 static bool classof(const Attr *A) { return A->getKind() == attr::NSConsumed; }
4640};
4641
4642class NSConsumesSelfAttr : public InheritableAttr {
4643public:
4644 static NSConsumesSelfAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4645 auto *A = new (Ctx) NSConsumesSelfAttr(Loc, Ctx, 0);
4646 A->setImplicit(true);
4647 return A;
4648 }
4649
4650 NSConsumesSelfAttr(SourceRange R, ASTContext &Ctx
4651 , unsigned SI
4652 )
4653 : InheritableAttr(attr::NSConsumesSelf, R, SI, false, false)
4654 {
4655 }
4656
4657 NSConsumesSelfAttr *clone(ASTContext &C) const;
4658 void printPretty(raw_ostream &OS,
4659 const PrintingPolicy &Policy) const;
4660 const char *getSpelling() const;
4661
4662
4663 static bool classof(const Attr *A) { return A->getKind() == attr::NSConsumesSelf; }
4664};
4665
4666class NSReturnsAutoreleasedAttr : public InheritableAttr {
4667public:
4668 static NSReturnsAutoreleasedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4669 auto *A = new (Ctx) NSReturnsAutoreleasedAttr(Loc, Ctx, 0);
4670 A->setImplicit(true);
4671 return A;
4672 }
4673
4674 NSReturnsAutoreleasedAttr(SourceRange R, ASTContext &Ctx
4675 , unsigned SI
4676 )
4677 : InheritableAttr(attr::NSReturnsAutoreleased, R, SI, false, false)
4678 {
4679 }
4680
4681 NSReturnsAutoreleasedAttr *clone(ASTContext &C) const;
4682 void printPretty(raw_ostream &OS,
4683 const PrintingPolicy &Policy) const;
4684 const char *getSpelling() const;
4685
4686
4687 static bool classof(const Attr *A) { return A->getKind() == attr::NSReturnsAutoreleased; }
4688};
4689
4690class NSReturnsNotRetainedAttr : public InheritableAttr {
4691public:
4692 static NSReturnsNotRetainedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4693 auto *A = new (Ctx) NSReturnsNotRetainedAttr(Loc, Ctx, 0);
4694 A->setImplicit(true);
4695 return A;
4696 }
4697
4698 NSReturnsNotRetainedAttr(SourceRange R, ASTContext &Ctx
4699 , unsigned SI
4700 )
4701 : InheritableAttr(attr::NSReturnsNotRetained, R, SI, false, false)
4702 {
4703 }
4704
4705 NSReturnsNotRetainedAttr *clone(ASTContext &C) const;
4706 void printPretty(raw_ostream &OS,
4707 const PrintingPolicy &Policy) const;
4708 const char *getSpelling() const;
4709
4710
4711 static bool classof(const Attr *A) { return A->getKind() == attr::NSReturnsNotRetained; }
4712};
4713
4714class NSReturnsRetainedAttr : public InheritableAttr {
4715public:
4716 static NSReturnsRetainedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4717 auto *A = new (Ctx) NSReturnsRetainedAttr(Loc, Ctx, 0);
4718 A->setImplicit(true);
4719 return A;
4720 }
4721
4722 NSReturnsRetainedAttr(SourceRange R, ASTContext &Ctx
4723 , unsigned SI
4724 )
4725 : InheritableAttr(attr::NSReturnsRetained, R, SI, false, false)
4726 {
4727 }
4728
4729 NSReturnsRetainedAttr *clone(ASTContext &C) const;
4730 void printPretty(raw_ostream &OS,
4731 const PrintingPolicy &Policy) const;
4732 const char *getSpelling() const;
4733
4734
4735 static bool classof(const Attr *A) { return A->getKind() == attr::NSReturnsRetained; }
4736};
4737
4738class NakedAttr : public InheritableAttr {
4739public:
4740 static NakedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4741 auto *A = new (Ctx) NakedAttr(Loc, Ctx, 0);
4742 A->setImplicit(true);
4743 return A;
4744 }
4745
4746 NakedAttr(SourceRange R, ASTContext &Ctx
4747 , unsigned SI
4748 )
4749 : InheritableAttr(attr::Naked, R, SI, false, false)
4750 {
4751 }
4752
4753 NakedAttr *clone(ASTContext &C) const;
4754 void printPretty(raw_ostream &OS,
4755 const PrintingPolicy &Policy) const;
4756 const char *getSpelling() const;
4757
4758
4759 static bool classof(const Attr *A) { return A->getKind() == attr::Naked; }
4760};
4761
4762class NoAliasAttr : public InheritableAttr {
4763public:
4764 static NoAliasAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4765 auto *A = new (Ctx) NoAliasAttr(Loc, Ctx, 0);
4766 A->setImplicit(true);
4767 return A;
4768 }
4769
4770 NoAliasAttr(SourceRange R, ASTContext &Ctx
4771 , unsigned SI
4772 )
4773 : InheritableAttr(attr::NoAlias, R, SI, false, false)
4774 {
4775 }
4776
4777 NoAliasAttr *clone(ASTContext &C) const;
4778 void printPretty(raw_ostream &OS,
4779 const PrintingPolicy &Policy) const;
4780 const char *getSpelling() const;
4781
4782
4783 static bool classof(const Attr *A) { return A->getKind() == attr::NoAlias; }
4784};
4785
4786class NoCommonAttr : public InheritableAttr {
4787public:
4788 static NoCommonAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4789 auto *A = new (Ctx) NoCommonAttr(Loc, Ctx, 0);
4790 A->setImplicit(true);
4791 return A;
4792 }
4793
4794 NoCommonAttr(SourceRange R, ASTContext &Ctx
4795 , unsigned SI
4796 )
4797 : InheritableAttr(attr::NoCommon, R, SI, false, false)
4798 {
4799 }
4800
4801 NoCommonAttr *clone(ASTContext &C) const;
4802 void printPretty(raw_ostream &OS,
4803 const PrintingPolicy &Policy) const;
4804 const char *getSpelling() const;
4805
4806
4807 static bool classof(const Attr *A) { return A->getKind() == attr::NoCommon; }
4808};
4809
4810class NoDebugAttr : public InheritableAttr {
4811public:
4812 static NoDebugAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4813 auto *A = new (Ctx) NoDebugAttr(Loc, Ctx, 0);
4814 A->setImplicit(true);
4815 return A;
4816 }
4817
4818 NoDebugAttr(SourceRange R, ASTContext &Ctx
4819 , unsigned SI
4820 )
4821 : InheritableAttr(attr::NoDebug, R, SI, false, false)
4822 {
4823 }
4824
4825 NoDebugAttr *clone(ASTContext &C) const;
4826 void printPretty(raw_ostream &OS,
4827 const PrintingPolicy &Policy) const;
4828 const char *getSpelling() const;
4829
4830
4831 static bool classof(const Attr *A) { return A->getKind() == attr::NoDebug; }
4832};
4833
4834class NoDuplicateAttr : public InheritableAttr {
4835public:
4836 static NoDuplicateAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4837 auto *A = new (Ctx) NoDuplicateAttr(Loc, Ctx, 0);
4838 A->setImplicit(true);
4839 return A;
4840 }
4841
4842 NoDuplicateAttr(SourceRange R, ASTContext &Ctx
4843 , unsigned SI
4844 )
4845 : InheritableAttr(attr::NoDuplicate, R, SI, false, false)
4846 {
4847 }
4848
4849 NoDuplicateAttr *clone(ASTContext &C) const;
4850 void printPretty(raw_ostream &OS,
4851 const PrintingPolicy &Policy) const;
4852 const char *getSpelling() const;
4853
4854
4855 static bool classof(const Attr *A) { return A->getKind() == attr::NoDuplicate; }
4856};
4857
4858class NoEscapeAttr : public Attr {
4859public:
4860 static NoEscapeAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4861 auto *A = new (Ctx) NoEscapeAttr(Loc, Ctx, 0);
4862 A->setImplicit(true);
4863 return A;
4864 }
4865
4866 NoEscapeAttr(SourceRange R, ASTContext &Ctx
4867 , unsigned SI
4868 )
4869 : Attr(attr::NoEscape, R, SI, false)
4870 {
4871 }
4872
4873 NoEscapeAttr *clone(ASTContext &C) const;
4874 void printPretty(raw_ostream &OS,
4875 const PrintingPolicy &Policy) const;
4876 const char *getSpelling() const;
4877
4878
4879 static bool classof(const Attr *A) { return A->getKind() == attr::NoEscape; }
4880};
4881
4882class NoInlineAttr : public InheritableAttr {
4883public:
4884 static NoInlineAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4885 auto *A = new (Ctx) NoInlineAttr(Loc, Ctx, 0);
4886 A->setImplicit(true);
4887 return A;
4888 }
4889
4890 NoInlineAttr(SourceRange R, ASTContext &Ctx
4891 , unsigned SI
4892 )
4893 : InheritableAttr(attr::NoInline, R, SI, false, false)
4894 {
4895 }
4896
4897 NoInlineAttr *clone(ASTContext &C) const;
4898 void printPretty(raw_ostream &OS,
4899 const PrintingPolicy &Policy) const;
4900 const char *getSpelling() const;
4901
4902
4903 static bool classof(const Attr *A) { return A->getKind() == attr::NoInline; }
4904};
4905
4906class NoInstrumentFunctionAttr : public InheritableAttr {
4907public:
4908 static NoInstrumentFunctionAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4909 auto *A = new (Ctx) NoInstrumentFunctionAttr(Loc, Ctx, 0);
4910 A->setImplicit(true);
4911 return A;
4912 }
4913
4914 NoInstrumentFunctionAttr(SourceRange R, ASTContext &Ctx
4915 , unsigned SI
4916 )
4917 : InheritableAttr(attr::NoInstrumentFunction, R, SI, false, false)
4918 {
4919 }
4920
4921 NoInstrumentFunctionAttr *clone(ASTContext &C) const;
4922 void printPretty(raw_ostream &OS,
4923 const PrintingPolicy &Policy) const;
4924 const char *getSpelling() const;
4925
4926
4927 static bool classof(const Attr *A) { return A->getKind() == attr::NoInstrumentFunction; }
4928};
4929
4930class NoMicroMipsAttr : public InheritableAttr {
4931public:
4932 static NoMicroMipsAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4933 auto *A = new (Ctx) NoMicroMipsAttr(Loc, Ctx, 0);
4934 A->setImplicit(true);
4935 return A;
4936 }
4937
4938 NoMicroMipsAttr(SourceRange R, ASTContext &Ctx
4939 , unsigned SI
4940 )
4941 : InheritableAttr(attr::NoMicroMips, R, SI, false, false)
4942 {
4943 }
4944
4945 NoMicroMipsAttr *clone(ASTContext &C) const;
4946 void printPretty(raw_ostream &OS,
4947 const PrintingPolicy &Policy) const;
4948 const char *getSpelling() const;
4949
4950
4951 static bool classof(const Attr *A) { return A->getKind() == attr::NoMicroMips; }
4952};
4953
4954class NoMips16Attr : public InheritableAttr {
4955public:
4956 static NoMips16Attr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4957 auto *A = new (Ctx) NoMips16Attr(Loc, Ctx, 0);
4958 A->setImplicit(true);
4959 return A;
4960 }
4961
4962 NoMips16Attr(SourceRange R, ASTContext &Ctx
4963 , unsigned SI
4964 )
4965 : InheritableAttr(attr::NoMips16, R, SI, false, false)
4966 {
4967 }
4968
4969 NoMips16Attr *clone(ASTContext &C) const;
4970 void printPretty(raw_ostream &OS,
4971 const PrintingPolicy &Policy) const;
4972 const char *getSpelling() const;
4973
4974
4975 static bool classof(const Attr *A) { return A->getKind() == attr::NoMips16; }
4976};
4977
4978class NoReturnAttr : public InheritableAttr {
4979public:
4980 static NoReturnAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
4981 auto *A = new (Ctx) NoReturnAttr(Loc, Ctx, 0);
4982 A->setImplicit(true);
4983 return A;
4984 }
4985
4986 NoReturnAttr(SourceRange R, ASTContext &Ctx
4987 , unsigned SI
4988 )
4989 : InheritableAttr(attr::NoReturn, R, SI, false, false)
4990 {
4991 }
4992
4993 NoReturnAttr *clone(ASTContext &C) const;
4994 void printPretty(raw_ostream &OS,
4995 const PrintingPolicy &Policy) const;
4996 const char *getSpelling() const;
4997
4998
4999 static bool classof(const Attr *A) { return A->getKind() == attr::NoReturn; }
5000};
5001
5002class NoSanitizeAttr : public InheritableAttr {
5003 unsigned sanitizers_Size;
5004 StringRef *sanitizers_;
5005
5006public:
5007 static NoSanitizeAttr *CreateImplicit(ASTContext &Ctx, StringRef *Sanitizers, unsigned SanitizersSize, SourceRange Loc = SourceRange()) {
5008 auto *A = new (Ctx) NoSanitizeAttr(Loc, Ctx, Sanitizers, SanitizersSize, 0);
5009 A->setImplicit(true);
5010 return A;
5011 }
5012
5013 NoSanitizeAttr(SourceRange R, ASTContext &Ctx
5014 , StringRef *Sanitizers, unsigned SanitizersSize
5015 , unsigned SI
5016 )
5017 : InheritableAttr(attr::NoSanitize, R, SI, false, false)
5018 , sanitizers_Size(SanitizersSize), sanitizers_(new (Ctx, 16) StringRef[sanitizers_Size])
5019 {
5020 for (size_t I = 0, E = sanitizers_Size; I != E;
5021 ++I) {
5022 StringRef Ref = Sanitizers[I];
5023 if (!Ref.empty()) {
5024 char *Mem = new (Ctx, 1) char[Ref.size()];
5025 std::memcpy(Mem, Ref.data(), Ref.size());
5026 sanitizers_[I] = StringRef(Mem, Ref.size());
5027 }
5028 }
5029 }
5030
5031 NoSanitizeAttr(SourceRange R, ASTContext &Ctx
5032 , unsigned SI
5033 )
5034 : InheritableAttr(attr::NoSanitize, R, SI, false, false)
5035 , sanitizers_Size(0), sanitizers_(nullptr)
5036 {
5037 }
5038
5039 NoSanitizeAttr *clone(ASTContext &C) const;
5040 void printPretty(raw_ostream &OS,
5041 const PrintingPolicy &Policy) const;
5042 const char *getSpelling() const;
5043 typedef StringRef* sanitizers_iterator;
5044 sanitizers_iterator sanitizers_begin() const { return sanitizers_; }
5045 sanitizers_iterator sanitizers_end() const { return sanitizers_ + sanitizers_Size; }
5046 unsigned sanitizers_size() const { return sanitizers_Size; }
5047 llvm::iterator_range<sanitizers_iterator> sanitizers() const { return llvm::make_range(sanitizers_begin(), sanitizers_end()); }
5048
5049
5050
5051 SanitizerMask getMask() const {
5052 SanitizerMask Mask = 0;
5053 for (auto SanitizerName : sanitizers()) {
5054 SanitizerMask ParsedMask =
5055 parseSanitizerValue(SanitizerName, /*AllowGroups=*/true);
5056 Mask |= expandSanitizerGroups(ParsedMask);
5057 }
5058 return Mask;
5059 }
5060
5061
5062 static bool classof(const Attr *A) { return A->getKind() == attr::NoSanitize; }
5063};
5064
5065class NoSplitStackAttr : public InheritableAttr {
5066public:
5067 static NoSplitStackAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
5068 auto *A = new (Ctx) NoSplitStackAttr(Loc, Ctx, 0);
5069 A->setImplicit(true);
5070 return A;
5071 }
5072
5073 NoSplitStackAttr(SourceRange R, ASTContext &Ctx
5074 , unsigned SI
5075 )
5076 : InheritableAttr(attr::NoSplitStack, R, SI, false, false)
5077 {
5078 }
5079
5080 NoSplitStackAttr *clone(ASTContext &C) const;
5081 void printPretty(raw_ostream &OS,
5082 const PrintingPolicy &Policy) const;
5083 const char *getSpelling() const;
5084
5085
5086 static bool classof(const Attr *A) { return A->getKind() == attr::NoSplitStack; }
5087};
5088
5089class NoStackProtectorAttr : public InheritableAttr {
5090public:
5091 static NoStackProtectorAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
5092 auto *A = new (Ctx) NoStackProtectorAttr(Loc, Ctx, 0);
5093 A->setImplicit(true);
5094 return A;
5095 }
5096
5097 NoStackProtectorAttr(SourceRange R, ASTContext &Ctx
5098 , unsigned SI
5099 )
5100 : InheritableAttr(attr::NoStackProtector, R, SI, false, false)
5101 {
5102 }
5103
5104 NoStackProtectorAttr *clone(ASTContext &C) const;
5105 void printPretty(raw_ostream &OS,
5106 const PrintingPolicy &Policy) const;
5107 const char *getSpelling() const;
5108
5109
5110 static bool classof(const Attr *A) { return A->getKind() == attr::NoStackProtector; }
5111};
5112
5113class NoThreadSafetyAnalysisAttr : public InheritableAttr {
5114public:
5115 static NoThreadSafetyAnalysisAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
5116 auto *A = new (Ctx) NoThreadSafetyAnalysisAttr(Loc, Ctx, 0);
5117 A->setImplicit(true);
5118 return A;
5119 }
5120
5121 NoThreadSafetyAnalysisAttr(SourceRange R, ASTContext &Ctx
5122 , unsigned SI
5123 )
5124 : InheritableAttr(attr::NoThreadSafetyAnalysis, R, SI, false, false)
5125 {
5126 }
5127
5128 NoThreadSafetyAnalysisAttr *clone(ASTContext &C) const;
5129 void printPretty(raw_ostream &OS,
5130 const PrintingPolicy &Policy) const;
5131 const char *getSpelling() const;
5132
5133
5134 static bool classof(const Attr *A) { return A->getKind() == attr::NoThreadSafetyAnalysis; }
5135};
5136
5137class NoThrowAttr : public InheritableAttr {
5138public:
5139 static NoThrowAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
5140 auto *A = new (Ctx) NoThrowAttr(Loc, Ctx, 0);
5141 A->setImplicit(true);
5142 return A;
5143 }
5144
5145 NoThrowAttr(SourceRange R, ASTContext &Ctx
5146 , unsigned SI
5147 )
5148 : InheritableAttr(attr::NoThrow, R, SI, false, false)
5149 {
5150 }
5151
5152 NoThrowAttr *clone(ASTContext &C) const;
5153 void printPretty(raw_ostream &OS,
5154 const PrintingPolicy &Policy) const;
5155 const char *getSpelling() const;
5156
5157
5158 static bool classof(const Attr *A) { return A->getKind() == attr::NoThrow; }
5159};
5160
5161class NonNullAttr : public InheritableParamAttr {
5162 unsigned args_Size;
5163 ParamIdx *args_;
5164
5165public:
5166 static NonNullAttr *CreateImplicit(ASTContext &Ctx, ParamIdx *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
5167 auto *A = new (Ctx) NonNullAttr(Loc, Ctx, Args, ArgsSize, 0);
5168 A->setImplicit(true);
5169 return A;
5170 }
5171
5172 NonNullAttr(SourceRange R, ASTContext &Ctx
5173 , ParamIdx *Args, unsigned ArgsSize
5174 , unsigned SI
5175 )
5176 : InheritableParamAttr(attr::NonNull, R, SI, false, true)
5177 , args_Size(ArgsSize), args_(new (Ctx, 16) ParamIdx[args_Size])
5178 {
5179 std::copy(Args, Args + args_Size, args_);
5180 }
5181
5182 NonNullAttr(SourceRange R, ASTContext &Ctx
5183 , unsigned SI
5184 )
5185 : InheritableParamAttr(attr::NonNull, R, SI, false, true)
5186 , args_Size(0), args_(nullptr)
5187 {
5188 }
5189
5190 NonNullAttr *clone(ASTContext &C) const;
5191 void printPretty(raw_ostream &OS,
5192 const PrintingPolicy &Policy) const;
5193 const char *getSpelling() const;
5194 typedef ParamIdx* args_iterator;
5195 args_iterator args_begin() const { return args_; }
5196 args_iterator args_end() const { return args_ + args_Size; }
5197 unsigned args_size() const { return args_Size; }
5198 llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
5199
5200
5201
5202 bool isNonNull(unsigned IdxAST) const {
5203 if (!args_size())
5204 return true;
5205 return args_end() != std::find_if(
5206 args_begin(), args_end(),
5207 [=](const ParamIdx &Idx) { return Idx.getASTIndex() == IdxAST; });
5208 }
5209
5210
5211 static bool classof(const Attr *A) { return A->getKind() == attr::NonNull; }
5212};
5213
5214class NotTailCalledAttr : public InheritableAttr {
5215public:
5216 static NotTailCalledAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
5217 auto *A = new (Ctx) NotTailCalledAttr(Loc, Ctx, 0);
5218 A->setImplicit(true);
5219 return A;
5220 }
5221
5222 NotTailCalledAttr(SourceRange R, ASTContext &Ctx
5223 , unsigned SI
5224 )
5225 : InheritableAttr(attr::NotTailCalled, R, SI, false, false)
5226 {
5227 }
5228
5229 NotTailCalledAttr *clone(ASTContext &C) const;
5230 void printPretty(raw_ostream &OS,
5231 const PrintingPolicy &Policy) const;
5232 const char *getSpelling() const;
5233
5234
5235 static bool classof(const Attr *A) { return A->getKind() == attr::NotTailCalled; }
5236};
5237
5238class OMPCaptureKindAttr : public Attr {
5239unsigned captureKind;
5240
5241public:
5242 static OMPCaptureKindAttr *CreateImplicit(ASTContext &Ctx, unsigned CaptureKind, SourceRange Loc = SourceRange()) {
5243 auto *A = new (Ctx) OMPCaptureKindAttr(Loc, Ctx, CaptureKind, 0);
5244 A->setImplicit(true);
5245 return A;
5246 }
5247
5248 OMPCaptureKindAttr(SourceRange R, ASTContext &Ctx
5249 , unsigned CaptureKind
5250 , unsigned SI
5251 )
5252 : Attr(attr::OMPCaptureKind, R, SI, false)
5253 , captureKind(CaptureKind)
5254 {
5255 }
5256
5257 OMPCaptureKindAttr *clone(ASTContext &C) const;
5258 void printPretty(raw_ostream &OS,
5259 const PrintingPolicy &Policy) const;
5260 const char *getSpelling() const;
5261 unsigned getCaptureKind() const {
5262 return captureKind;
5263 }
5264
5265
5266
5267 static bool classof(const Attr *A) { return A->getKind() == attr::OMPCaptureKind; }
5268};
5269
5270class OMPCaptureNoInitAttr : public InheritableAttr {
5271public:
5272 static OMPCaptureNoInitAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
5273 auto *A = new (Ctx) OMPCaptureNoInitAttr(Loc, Ctx, 0);
5274 A->setImplicit(true);
5275 return A;
5276 }
5277
5278 OMPCaptureNoInitAttr(SourceRange R, ASTContext &Ctx
5279 , unsigned SI
5280 )
5281 : InheritableAttr(attr::OMPCaptureNoInit, R, SI, false, false)