Bug Summary

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

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

1//===--- SemaAttr.cpp - Semantic Analysis for Attributes ------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements semantic analysis for non-trivial attributes and
10// pragmas.
11//
12//===----------------------------------------------------------------------===//
13
14#include "clang/AST/ASTConsumer.h"
15#include "clang/AST/Attr.h"
16#include "clang/AST/Expr.h"
17#include "clang/Basic/TargetInfo.h"
18#include "clang/Lex/Preprocessor.h"
19#include "clang/Sema/Lookup.h"
20#include "clang/Sema/SemaInternal.h"
21using namespace clang;
22
23//===----------------------------------------------------------------------===//
24// Pragma 'pack' and 'options align'
25//===----------------------------------------------------------------------===//
26
27Sema::PragmaStackSentinelRAII::PragmaStackSentinelRAII(Sema &S,
28 StringRef SlotLabel,
29 bool ShouldAct)
30 : S(S), SlotLabel(SlotLabel), ShouldAct(ShouldAct) {
31 if (ShouldAct) {
32 S.VtorDispStack.SentinelAction(PSK_Push, SlotLabel);
33 S.DataSegStack.SentinelAction(PSK_Push, SlotLabel);
34 S.BSSSegStack.SentinelAction(PSK_Push, SlotLabel);
35 S.ConstSegStack.SentinelAction(PSK_Push, SlotLabel);
36 S.CodeSegStack.SentinelAction(PSK_Push, SlotLabel);
37 }
38}
39
40Sema::PragmaStackSentinelRAII::~PragmaStackSentinelRAII() {
41 if (ShouldAct) {
42 S.VtorDispStack.SentinelAction(PSK_Pop, SlotLabel);
43 S.DataSegStack.SentinelAction(PSK_Pop, SlotLabel);
44 S.BSSSegStack.SentinelAction(PSK_Pop, SlotLabel);
45 S.ConstSegStack.SentinelAction(PSK_Pop, SlotLabel);
46 S.CodeSegStack.SentinelAction(PSK_Pop, SlotLabel);
47 }
48}
49
50void Sema::AddAlignmentAttributesForRecord(RecordDecl *RD) {
51 // If there is no pack value, we don't need any attributes.
52 if (!PackStack.CurrentValue)
53 return;
54
55 // Otherwise, check to see if we need a max field alignment attribute.
56 if (unsigned Alignment = PackStack.CurrentValue) {
57 if (Alignment == Sema::kMac68kAlignmentSentinel)
58 RD->addAttr(AlignMac68kAttr::CreateImplicit(Context));
59 else
60 RD->addAttr(MaxFieldAlignmentAttr::CreateImplicit(Context,
61 Alignment * 8));
62 }
63 if (PackIncludeStack.empty())
64 return;
65 // The #pragma pack affected a record in an included file, so Clang should
66 // warn when that pragma was written in a file that included the included
67 // file.
68 for (auto &PackedInclude : llvm::reverse(PackIncludeStack)) {
69 if (PackedInclude.CurrentPragmaLocation != PackStack.CurrentPragmaLocation)
70 break;
71 if (PackedInclude.HasNonDefaultValue)
72 PackedInclude.ShouldWarnOnInclude = true;
73 }
74}
75
76void Sema::AddMsStructLayoutForRecord(RecordDecl *RD) {
77 if (MSStructPragmaOn)
78 RD->addAttr(MSStructAttr::CreateImplicit(Context));
79
80 // FIXME: We should merge AddAlignmentAttributesForRecord with
81 // AddMsStructLayoutForRecord into AddPragmaAttributesForRecord, which takes
82 // all active pragmas and applies them as attributes to class definitions.
83 if (VtorDispStack.CurrentValue != getLangOpts().VtorDispMode)
84 RD->addAttr(
85 MSVtorDispAttr::CreateImplicit(Context, VtorDispStack.CurrentValue));
86}
87
88void Sema::ActOnPragmaOptionsAlign(PragmaOptionsAlignKind Kind,
89 SourceLocation PragmaLoc) {
90 PragmaMsStackAction Action = Sema::PSK_Reset;
91 unsigned Alignment = 0;
92 switch (Kind) {
93 // For all targets we support native and natural are the same.
94 //
95 // FIXME: This is not true on Darwin/PPC.
96 case POAK_Native:
97 case POAK_Power:
98 case POAK_Natural:
99 Action = Sema::PSK_Push_Set;
100 Alignment = 0;
101 break;
102
103 // Note that '#pragma options align=packed' is not equivalent to attribute
104 // packed, it has a different precedence relative to attribute aligned.
105 case POAK_Packed:
106 Action = Sema::PSK_Push_Set;
107 Alignment = 1;
108 break;
109
110 case POAK_Mac68k:
111 // Check if the target supports this.
112 if (!this->Context.getTargetInfo().hasAlignMac68kSupport()) {
113 Diag(PragmaLoc, diag::err_pragma_options_align_mac68k_target_unsupported);
114 return;
115 }
116 Action = Sema::PSK_Push_Set;
117 Alignment = Sema::kMac68kAlignmentSentinel;
118 break;
119
120 case POAK_Reset:
121 // Reset just pops the top of the stack, or resets the current alignment to
122 // default.
123 Action = Sema::PSK_Pop;
124 if (PackStack.Stack.empty()) {
125 if (PackStack.CurrentValue) {
126 Action = Sema::PSK_Reset;
127 } else {
128 Diag(PragmaLoc, diag::warn_pragma_options_align_reset_failed)
129 << "stack empty";
130 return;
131 }
132 }
133 break;
134 }
135
136 PackStack.Act(PragmaLoc, Action, StringRef(), Alignment);
137}
138
139void Sema::ActOnPragmaClangSection(SourceLocation PragmaLoc, PragmaClangSectionAction Action,
140 PragmaClangSectionKind SecKind, StringRef SecName) {
141 PragmaClangSection *CSec;
142 switch (SecKind) {
143 case PragmaClangSectionKind::PCSK_BSS:
144 CSec = &PragmaClangBSSSection;
145 break;
146 case PragmaClangSectionKind::PCSK_Data:
147 CSec = &PragmaClangDataSection;
148 break;
149 case PragmaClangSectionKind::PCSK_Rodata:
150 CSec = &PragmaClangRodataSection;
151 break;
152 case PragmaClangSectionKind::PCSK_Text:
153 CSec = &PragmaClangTextSection;
154 break;
155 default:
156 llvm_unreachable("invalid clang section kind")::llvm::llvm_unreachable_internal("invalid clang section kind"
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaAttr.cpp"
, 156)
;
157 }
158
159 if (Action == PragmaClangSectionAction::PCSA_Clear) {
160 CSec->Valid = false;
161 return;
162 }
163
164 CSec->Valid = true;
165 CSec->SectionName = SecName;
166 CSec->PragmaLocation = PragmaLoc;
167}
168
169void Sema::ActOnPragmaPack(SourceLocation PragmaLoc, PragmaMsStackAction Action,
170 StringRef SlotLabel, Expr *alignment) {
171 Expr *Alignment = static_cast<Expr *>(alignment);
172
173 // If specified then alignment must be a "small" power of two.
174 unsigned AlignmentVal = 0;
175 if (Alignment) {
176 llvm::APSInt Val;
177
178 // pack(0) is like pack(), which just works out since that is what
179 // we use 0 for in PackAttr.
180 if (Alignment->isTypeDependent() ||
181 Alignment->isValueDependent() ||
182 !Alignment->isIntegerConstantExpr(Val, Context) ||
183 !(Val == 0 || Val.isPowerOf2()) ||
184 Val.getZExtValue() > 16) {
185 Diag(PragmaLoc, diag::warn_pragma_pack_invalid_alignment);
186 return; // Ignore
187 }
188
189 AlignmentVal = (unsigned) Val.getZExtValue();
190 }
191 if (Action == Sema::PSK_Show) {
192 // Show the current alignment, making sure to show the right value
193 // for the default.
194 // FIXME: This should come from the target.
195 AlignmentVal = PackStack.CurrentValue;
196 if (AlignmentVal == 0)
197 AlignmentVal = 8;
198 if (AlignmentVal == Sema::kMac68kAlignmentSentinel)
199 Diag(PragmaLoc, diag::warn_pragma_pack_show) << "mac68k";
200 else
201 Diag(PragmaLoc, diag::warn_pragma_pack_show) << AlignmentVal;
202 }
203 // MSDN, C/C++ Preprocessor Reference > Pragma Directives > pack:
204 // "#pragma pack(pop, identifier, n) is undefined"
205 if (Action & Sema::PSK_Pop) {
206 if (Alignment && !SlotLabel.empty())
207 Diag(PragmaLoc, diag::warn_pragma_pack_pop_identifier_and_alignment);
208 if (PackStack.Stack.empty())
209 Diag(PragmaLoc, diag::warn_pragma_pop_failed) << "pack" << "stack empty";
210 }
211
212 PackStack.Act(PragmaLoc, Action, SlotLabel, AlignmentVal);
213}
214
215void Sema::DiagnoseNonDefaultPragmaPack(PragmaPackDiagnoseKind Kind,
216 SourceLocation IncludeLoc) {
217 if (Kind == PragmaPackDiagnoseKind::NonDefaultStateAtInclude) {
218 SourceLocation PrevLocation = PackStack.CurrentPragmaLocation;
219 // Warn about non-default alignment at #includes (without redundant
220 // warnings for the same directive in nested includes).
221 // The warning is delayed until the end of the file to avoid warnings
222 // for files that don't have any records that are affected by the modified
223 // alignment.
224 bool HasNonDefaultValue =
225 PackStack.hasValue() &&
226 (PackIncludeStack.empty() ||
227 PackIncludeStack.back().CurrentPragmaLocation != PrevLocation);
228 PackIncludeStack.push_back(
229 {PackStack.CurrentValue,
230 PackStack.hasValue() ? PrevLocation : SourceLocation(),
231 HasNonDefaultValue, /*ShouldWarnOnInclude*/ false});
232 return;
233 }
234
235 assert(Kind == PragmaPackDiagnoseKind::ChangedStateAtExit && "invalid kind")((Kind == PragmaPackDiagnoseKind::ChangedStateAtExit &&
"invalid kind") ? static_cast<void> (0) : __assert_fail
("Kind == PragmaPackDiagnoseKind::ChangedStateAtExit && \"invalid kind\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaAttr.cpp"
, 235, __PRETTY_FUNCTION__))
;
236 PackIncludeState PrevPackState = PackIncludeStack.pop_back_val();
237 if (PrevPackState.ShouldWarnOnInclude) {
238 // Emit the delayed non-default alignment at #include warning.
239 Diag(IncludeLoc, diag::warn_pragma_pack_non_default_at_include);
240 Diag(PrevPackState.CurrentPragmaLocation, diag::note_pragma_pack_here);
241 }
242 // Warn about modified alignment after #includes.
243 if (PrevPackState.CurrentValue != PackStack.CurrentValue) {
244 Diag(IncludeLoc, diag::warn_pragma_pack_modified_after_include);
245 Diag(PackStack.CurrentPragmaLocation, diag::note_pragma_pack_here);
246 }
247}
248
249void Sema::DiagnoseUnterminatedPragmaPack() {
250 if (PackStack.Stack.empty())
251 return;
252 bool IsInnermost = true;
253 for (const auto &StackSlot : llvm::reverse(PackStack.Stack)) {
254 Diag(StackSlot.PragmaPushLocation, diag::warn_pragma_pack_no_pop_eof);
255 // The user might have already reset the alignment, so suggest replacing
256 // the reset with a pop.
257 if (IsInnermost && PackStack.CurrentValue == PackStack.DefaultValue) {
258 DiagnosticBuilder DB = Diag(PackStack.CurrentPragmaLocation,
259 diag::note_pragma_pack_pop_instead_reset);
260 SourceLocation FixItLoc = Lexer::findLocationAfterToken(
261 PackStack.CurrentPragmaLocation, tok::l_paren, SourceMgr, LangOpts,
262 /*SkipTrailing=*/false);
263 if (FixItLoc.isValid())
264 DB << FixItHint::CreateInsertion(FixItLoc, "pop");
265 }
266 IsInnermost = false;
267 }
268}
269
270void Sema::ActOnPragmaMSStruct(PragmaMSStructKind Kind) {
271 MSStructPragmaOn = (Kind == PMSST_ON);
272}
273
274void Sema::ActOnPragmaMSComment(SourceLocation CommentLoc,
275 PragmaMSCommentKind Kind, StringRef Arg) {
276 auto *PCD = PragmaCommentDecl::Create(
277 Context, Context.getTranslationUnitDecl(), CommentLoc, Kind, Arg);
278 Context.getTranslationUnitDecl()->addDecl(PCD);
279 Consumer.HandleTopLevelDecl(DeclGroupRef(PCD));
280}
281
282void Sema::ActOnPragmaDetectMismatch(SourceLocation Loc, StringRef Name,
283 StringRef Value) {
284 auto *PDMD = PragmaDetectMismatchDecl::Create(
285 Context, Context.getTranslationUnitDecl(), Loc, Name, Value);
286 Context.getTranslationUnitDecl()->addDecl(PDMD);
287 Consumer.HandleTopLevelDecl(DeclGroupRef(PDMD));
288}
289
290void Sema::ActOnPragmaMSPointersToMembers(
291 LangOptions::PragmaMSPointersToMembersKind RepresentationMethod,
292 SourceLocation PragmaLoc) {
293 MSPointerToMemberRepresentationMethod = RepresentationMethod;
294 ImplicitMSInheritanceAttrLoc = PragmaLoc;
295}
296
297void Sema::ActOnPragmaMSVtorDisp(PragmaMsStackAction Action,
298 SourceLocation PragmaLoc,
299 MSVtorDispAttr::Mode Mode) {
300 if (Action & PSK_Pop && VtorDispStack.Stack.empty())
301 Diag(PragmaLoc, diag::warn_pragma_pop_failed) << "vtordisp"
302 << "stack empty";
303 VtorDispStack.Act(PragmaLoc, Action, StringRef(), Mode);
304}
305
306template<typename ValueType>
307void Sema::PragmaStack<ValueType>::Act(SourceLocation PragmaLocation,
308 PragmaMsStackAction Action,
309 llvm::StringRef StackSlotLabel,
310 ValueType Value) {
311 if (Action == PSK_Reset) {
312 CurrentValue = DefaultValue;
313 CurrentPragmaLocation = PragmaLocation;
314 return;
315 }
316 if (Action & PSK_Push)
317 Stack.emplace_back(StackSlotLabel, CurrentValue, CurrentPragmaLocation,
318 PragmaLocation);
319 else if (Action & PSK_Pop) {
320 if (!StackSlotLabel.empty()) {
321 // If we've got a label, try to find it and jump there.
322 auto I = llvm::find_if(llvm::reverse(Stack), [&](const Slot &x) {
323 return x.StackSlotLabel == StackSlotLabel;
324 });
325 // If we found the label so pop from there.
326 if (I != Stack.rend()) {
327 CurrentValue = I->Value;
328 CurrentPragmaLocation = I->PragmaLocation;
329 Stack.erase(std::prev(I.base()), Stack.end());
330 }
331 } else if (!Stack.empty()) {
332 // We do not have a label, just pop the last entry.
333 CurrentValue = Stack.back().Value;
334 CurrentPragmaLocation = Stack.back().PragmaLocation;
335 Stack.pop_back();
336 }
337 }
338 if (Action & PSK_Set) {
339 CurrentValue = Value;
340 CurrentPragmaLocation = PragmaLocation;
341 }
342}
343
344bool Sema::UnifySection(StringRef SectionName,
345 int SectionFlags,
346 DeclaratorDecl *Decl) {
347 auto Section = Context.SectionInfos.find(SectionName);
348 if (Section == Context.SectionInfos.end()) {
349 Context.SectionInfos[SectionName] =
350 ASTContext::SectionInfo(Decl, SourceLocation(), SectionFlags);
351 return false;
352 }
353 // A pre-declared section takes precedence w/o diagnostic.
354 if (Section->second.SectionFlags == SectionFlags ||
355 !(Section->second.SectionFlags & ASTContext::PSF_Implicit))
356 return false;
357 auto OtherDecl = Section->second.Decl;
358 Diag(Decl->getLocation(), diag::err_section_conflict)
359 << Decl << OtherDecl;
360 Diag(OtherDecl->getLocation(), diag::note_declared_at)
361 << OtherDecl->getName();
362 if (auto A = Decl->getAttr<SectionAttr>())
363 if (A->isImplicit())
364 Diag(A->getLocation(), diag::note_pragma_entered_here);
365 if (auto A = OtherDecl->getAttr<SectionAttr>())
366 if (A->isImplicit())
367 Diag(A->getLocation(), diag::note_pragma_entered_here);
368 return true;
369}
370
371bool Sema::UnifySection(StringRef SectionName,
372 int SectionFlags,
373 SourceLocation PragmaSectionLocation) {
374 auto Section = Context.SectionInfos.find(SectionName);
375 if (Section != Context.SectionInfos.end()) {
376 if (Section->second.SectionFlags == SectionFlags)
377 return false;
378 if (!(Section->second.SectionFlags & ASTContext::PSF_Implicit)) {
379 Diag(PragmaSectionLocation, diag::err_section_conflict)
380 << "this" << "a prior #pragma section";
381 Diag(Section->second.PragmaSectionLocation,
382 diag::note_pragma_entered_here);
383 return true;
384 }
385 }
386 Context.SectionInfos[SectionName] =
387 ASTContext::SectionInfo(nullptr, PragmaSectionLocation, SectionFlags);
388 return false;
389}
390
391/// Called on well formed \#pragma bss_seg().
392void Sema::ActOnPragmaMSSeg(SourceLocation PragmaLocation,
393 PragmaMsStackAction Action,
394 llvm::StringRef StackSlotLabel,
395 StringLiteral *SegmentName,
396 llvm::StringRef PragmaName) {
397 PragmaStack<StringLiteral *> *Stack =
398 llvm::StringSwitch<PragmaStack<StringLiteral *> *>(PragmaName)
399 .Case("data_seg", &DataSegStack)
400 .Case("bss_seg", &BSSSegStack)
401 .Case("const_seg", &ConstSegStack)
402 .Case("code_seg", &CodeSegStack);
403 if (Action & PSK_Pop && Stack->Stack.empty())
404 Diag(PragmaLocation, diag::warn_pragma_pop_failed) << PragmaName
405 << "stack empty";
406 if (SegmentName &&
407 !checkSectionName(SegmentName->getBeginLoc(), SegmentName->getString()))
408 return;
409 Stack->Act(PragmaLocation, Action, StackSlotLabel, SegmentName);
410}
411
412/// Called on well formed \#pragma bss_seg().
413void Sema::ActOnPragmaMSSection(SourceLocation PragmaLocation,
414 int SectionFlags, StringLiteral *SegmentName) {
415 UnifySection(SegmentName->getString(), SectionFlags, PragmaLocation);
416}
417
418void Sema::ActOnPragmaMSInitSeg(SourceLocation PragmaLocation,
419 StringLiteral *SegmentName) {
420 // There's no stack to maintain, so we just have a current section. When we
421 // see the default section, reset our current section back to null so we stop
422 // tacking on unnecessary attributes.
423 CurInitSeg = SegmentName->getString() == ".CRT$XCU" ? nullptr : SegmentName;
424 CurInitSegLoc = PragmaLocation;
425}
426
427void Sema::ActOnPragmaUnused(const Token &IdTok, Scope *curScope,
428 SourceLocation PragmaLoc) {
429
430 IdentifierInfo *Name = IdTok.getIdentifierInfo();
431 LookupResult Lookup(*this, Name, IdTok.getLocation(), LookupOrdinaryName);
432 LookupParsedName(Lookup, curScope, nullptr, true);
433
434 if (Lookup.empty()) {
435 Diag(PragmaLoc, diag::warn_pragma_unused_undeclared_var)
436 << Name << SourceRange(IdTok.getLocation());
437 return;
438 }
439
440 VarDecl *VD = Lookup.getAsSingle<VarDecl>();
441 if (!VD) {
442 Diag(PragmaLoc, diag::warn_pragma_unused_expected_var_arg)
443 << Name << SourceRange(IdTok.getLocation());
444 return;
445 }
446
447 // Warn if this was used before being marked unused.
448 if (VD->isUsed())
449 Diag(PragmaLoc, diag::warn_used_but_marked_unused) << Name;
450
451 VD->addAttr(UnusedAttr::CreateImplicit(Context, UnusedAttr::GNU_unused,
452 IdTok.getLocation()));
453}
454
455void Sema::AddCFAuditedAttribute(Decl *D) {
456 SourceLocation Loc = PP.getPragmaARCCFCodeAuditedLoc();
457 if (!Loc.isValid()) return;
458
459 // Don't add a redundant or conflicting attribute.
460 if (D->hasAttr<CFAuditedTransferAttr>() ||
461 D->hasAttr<CFUnknownTransferAttr>())
462 return;
463
464 D->addAttr(CFAuditedTransferAttr::CreateImplicit(Context, Loc));
465}
466
467namespace {
468
469Optional<attr::SubjectMatchRule>
470getParentAttrMatcherRule(attr::SubjectMatchRule Rule) {
471 using namespace attr;
472 switch (Rule) {
473 default:
474 return None;
475#define ATTR_MATCH_RULE(Value, Spelling, IsAbstract)
476#define ATTR_MATCH_SUB_RULE(Value, Spelling, IsAbstract, Parent, IsNegated) \
477 case Value: \
478 return Parent;
479#include "clang/Basic/AttrSubMatchRulesList.inc"
480 }
481}
482
483bool isNegatedAttrMatcherSubRule(attr::SubjectMatchRule Rule) {
484 using namespace attr;
485 switch (Rule) {
486 default:
487 return false;
488#define ATTR_MATCH_RULE(Value, Spelling, IsAbstract)
489#define ATTR_MATCH_SUB_RULE(Value, Spelling, IsAbstract, Parent, IsNegated) \
490 case Value: \
491 return IsNegated;
492#include "clang/Basic/AttrSubMatchRulesList.inc"
493 }
494}
495
496CharSourceRange replacementRangeForListElement(const Sema &S,
497 SourceRange Range) {
498 // Make sure that the ',' is removed as well.
499 SourceLocation AfterCommaLoc = Lexer::findLocationAfterToken(
500 Range.getEnd(), tok::comma, S.getSourceManager(), S.getLangOpts(),
501 /*SkipTrailingWhitespaceAndNewLine=*/false);
502 if (AfterCommaLoc.isValid())
503 return CharSourceRange::getCharRange(Range.getBegin(), AfterCommaLoc);
504 else
505 return CharSourceRange::getTokenRange(Range);
506}
507
508std::string
509attrMatcherRuleListToString(ArrayRef<attr::SubjectMatchRule> Rules) {
510 std::string Result;
511 llvm::raw_string_ostream OS(Result);
512 for (const auto &I : llvm::enumerate(Rules)) {
513 if (I.index())
514 OS << (I.index() == Rules.size() - 1 ? ", and " : ", ");
515 OS << "'" << attr::getSubjectMatchRuleSpelling(I.value()) << "'";
516 }
517 return OS.str();
518}
519
520} // end anonymous namespace
521
522void Sema::ActOnPragmaAttributeAttribute(
523 ParsedAttr &Attribute, SourceLocation PragmaLoc,
524 attr::ParsedSubjectMatchRuleSet Rules) {
525 Attribute.setIsPragmaClangAttribute();
526 SmallVector<attr::SubjectMatchRule, 4> SubjectMatchRules;
527 // Gather the subject match rules that are supported by the attribute.
528 SmallVector<std::pair<attr::SubjectMatchRule, bool>, 4>
529 StrictSubjectMatchRuleSet;
530 Attribute.getMatchRules(LangOpts, StrictSubjectMatchRuleSet);
531
532 // Figure out which subject matching rules are valid.
533 if (StrictSubjectMatchRuleSet.empty()) {
534 // Check for contradicting match rules. Contradicting match rules are
535 // either:
536 // - a top-level rule and one of its sub-rules. E.g. variable and
537 // variable(is_parameter).
538 // - a sub-rule and a sibling that's negated. E.g.
539 // variable(is_thread_local) and variable(unless(is_parameter))
540 llvm::SmallDenseMap<int, std::pair<int, SourceRange>, 2>
541 RulesToFirstSpecifiedNegatedSubRule;
542 for (const auto &Rule : Rules) {
543 attr::SubjectMatchRule MatchRule = attr::SubjectMatchRule(Rule.first);
544 Optional<attr::SubjectMatchRule> ParentRule =
545 getParentAttrMatcherRule(MatchRule);
546 if (!ParentRule)
547 continue;
548 auto It = Rules.find(*ParentRule);
549 if (It != Rules.end()) {
550 // A sub-rule contradicts a parent rule.
551 Diag(Rule.second.getBegin(),
552 diag::err_pragma_attribute_matcher_subrule_contradicts_rule)
553 << attr::getSubjectMatchRuleSpelling(MatchRule)
554 << attr::getSubjectMatchRuleSpelling(*ParentRule) << It->second
555 << FixItHint::CreateRemoval(
556 replacementRangeForListElement(*this, Rule.second));
557 // Keep going without removing this rule as it won't change the set of
558 // declarations that receive the attribute.
559 continue;
560 }
561 if (isNegatedAttrMatcherSubRule(MatchRule))
562 RulesToFirstSpecifiedNegatedSubRule.insert(
563 std::make_pair(*ParentRule, Rule));
564 }
565 bool IgnoreNegatedSubRules = false;
566 for (const auto &Rule : Rules) {
567 attr::SubjectMatchRule MatchRule = attr::SubjectMatchRule(Rule.first);
568 Optional<attr::SubjectMatchRule> ParentRule =
569 getParentAttrMatcherRule(MatchRule);
570 if (!ParentRule)
571 continue;
572 auto It = RulesToFirstSpecifiedNegatedSubRule.find(*ParentRule);
573 if (It != RulesToFirstSpecifiedNegatedSubRule.end() &&
574 It->second != Rule) {
575 // Negated sub-rule contradicts another sub-rule.
576 Diag(
577 It->second.second.getBegin(),
578 diag::
579 err_pragma_attribute_matcher_negated_subrule_contradicts_subrule)
580 << attr::getSubjectMatchRuleSpelling(
581 attr::SubjectMatchRule(It->second.first))
582 << attr::getSubjectMatchRuleSpelling(MatchRule) << Rule.second
583 << FixItHint::CreateRemoval(
584 replacementRangeForListElement(*this, It->second.second));
585 // Keep going but ignore all of the negated sub-rules.
586 IgnoreNegatedSubRules = true;
587 RulesToFirstSpecifiedNegatedSubRule.erase(It);
588 }
589 }
590
591 if (!IgnoreNegatedSubRules) {
592 for (const auto &Rule : Rules)
593 SubjectMatchRules.push_back(attr::SubjectMatchRule(Rule.first));
594 } else {
595 for (const auto &Rule : Rules) {
596 if (!isNegatedAttrMatcherSubRule(attr::SubjectMatchRule(Rule.first)))
597 SubjectMatchRules.push_back(attr::SubjectMatchRule(Rule.first));
598 }
599 }
600 Rules.clear();
601 } else {
602 for (const auto &Rule : StrictSubjectMatchRuleSet) {
603 if (Rules.erase(Rule.first)) {
604 // Add the rule to the set of attribute receivers only if it's supported
605 // in the current language mode.
606 if (Rule.second)
607 SubjectMatchRules.push_back(Rule.first);
608 }
609 }
610 }
611
612 if (!Rules.empty()) {
613 auto Diagnostic =
614 Diag(PragmaLoc, diag::err_pragma_attribute_invalid_matchers)
615 << Attribute.getName();
616 SmallVector<attr::SubjectMatchRule, 2> ExtraRules;
617 for (const auto &Rule : Rules) {
618 ExtraRules.push_back(attr::SubjectMatchRule(Rule.first));
619 Diagnostic << FixItHint::CreateRemoval(
620 replacementRangeForListElement(*this, Rule.second));
621 }
622 Diagnostic << attrMatcherRuleListToString(ExtraRules);
623 }
624
625 if (PragmaAttributeStack.empty()) {
626 Diag(PragmaLoc, diag::err_pragma_attr_attr_no_push);
627 return;
628 }
629
630 PragmaAttributeStack.back().Entries.push_back(
631 {PragmaLoc, &Attribute, std::move(SubjectMatchRules), /*IsUsed=*/false});
632}
633
634void Sema::ActOnPragmaAttributeEmptyPush(SourceLocation PragmaLoc,
635 const IdentifierInfo *Namespace) {
636 PragmaAttributeStack.emplace_back();
637 PragmaAttributeStack.back().Loc = PragmaLoc;
638 PragmaAttributeStack.back().Namespace = Namespace;
639}
640
641void Sema::ActOnPragmaAttributePop(SourceLocation PragmaLoc,
642 const IdentifierInfo *Namespace) {
643 if (PragmaAttributeStack.empty()) {
644 Diag(PragmaLoc, diag::err_pragma_attribute_stack_mismatch) << 1;
645 return;
646 }
647
648 // Dig back through the stack trying to find the most recently pushed group
649 // that in Namespace. Note that this works fine if no namespace is present,
650 // think of push/pops without namespaces as having an implicit "nullptr"
651 // namespace.
652 for (size_t Index = PragmaAttributeStack.size(); Index;) {
653 --Index;
654 if (PragmaAttributeStack[Index].Namespace == Namespace) {
655 for (const PragmaAttributeEntry &Entry :
656 PragmaAttributeStack[Index].Entries) {
657 if (!Entry.IsUsed) {
658 assert(Entry.Attribute && "Expected an attribute")((Entry.Attribute && "Expected an attribute") ? static_cast
<void> (0) : __assert_fail ("Entry.Attribute && \"Expected an attribute\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaAttr.cpp"
, 658, __PRETTY_FUNCTION__))
;
659 Diag(Entry.Attribute->getLoc(), diag::warn_pragma_attribute_unused)
660 << *Entry.Attribute;
661 Diag(PragmaLoc, diag::note_pragma_attribute_region_ends_here);
662 }
663 }
664 PragmaAttributeStack.erase(PragmaAttributeStack.begin() + Index);
665 return;
666 }
667 }
668
669 if (Namespace)
670 Diag(PragmaLoc, diag::err_pragma_attribute_stack_mismatch)
671 << 0 << Namespace->getName();
672 else
673 Diag(PragmaLoc, diag::err_pragma_attribute_stack_mismatch) << 1;
674}
675
676void Sema::AddPragmaAttributes(Scope *S, Decl *D) {
677 if (PragmaAttributeStack.empty())
678 return;
679 for (auto &Group : PragmaAttributeStack) {
680 for (auto &Entry : Group.Entries) {
681 ParsedAttr *Attribute = Entry.Attribute;
682 assert(Attribute && "Expected an attribute")((Attribute && "Expected an attribute") ? static_cast
<void> (0) : __assert_fail ("Attribute && \"Expected an attribute\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaAttr.cpp"
, 682, __PRETTY_FUNCTION__))
;
683 assert(Attribute->isPragmaClangAttribute() &&((Attribute->isPragmaClangAttribute() && "expected #pragma clang attribute"
) ? static_cast<void> (0) : __assert_fail ("Attribute->isPragmaClangAttribute() && \"expected #pragma clang attribute\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaAttr.cpp"
, 684, __PRETTY_FUNCTION__))
684 "expected #pragma clang attribute")((Attribute->isPragmaClangAttribute() && "expected #pragma clang attribute"
) ? static_cast<void> (0) : __assert_fail ("Attribute->isPragmaClangAttribute() && \"expected #pragma clang attribute\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaAttr.cpp"
, 684, __PRETTY_FUNCTION__))
;
685
686 // Ensure that the attribute can be applied to the given declaration.
687 bool Applies = false;
688 for (const auto &Rule : Entry.MatchRules) {
689 if (Attribute->appliesToDecl(D, Rule)) {
690 Applies = true;
691 break;
692 }
693 }
694 if (!Applies)
695 continue;
696 Entry.IsUsed = true;
697 PragmaAttributeCurrentTargetDecl = D;
698 ParsedAttributesView Attrs;
699 Attrs.addAtEnd(Attribute);
700 ProcessDeclAttributeList(S, D, Attrs);
701 PragmaAttributeCurrentTargetDecl = nullptr;
702 }
703 }
704}
705
706void Sema::PrintPragmaAttributeInstantiationPoint() {
707 assert(PragmaAttributeCurrentTargetDecl && "Expected an active declaration")((PragmaAttributeCurrentTargetDecl && "Expected an active declaration"
) ? static_cast<void> (0) : __assert_fail ("PragmaAttributeCurrentTargetDecl && \"Expected an active declaration\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaAttr.cpp"
, 707, __PRETTY_FUNCTION__))
;
708 Diags.Report(PragmaAttributeCurrentTargetDecl->getBeginLoc(),
709 diag::note_pragma_attribute_applied_decl_here);
710}
711
712void Sema::DiagnoseUnterminatedPragmaAttribute() {
713 if (PragmaAttributeStack.empty())
714 return;
715 Diag(PragmaAttributeStack.back().Loc, diag::err_pragma_attribute_no_pop_eof);
716}
717
718void Sema::ActOnPragmaOptimize(bool On, SourceLocation PragmaLoc) {
719 if(On)
720 OptimizeOffPragmaLocation = SourceLocation();
721 else
722 OptimizeOffPragmaLocation = PragmaLoc;
723}
724
725void Sema::AddRangeBasedOptnone(FunctionDecl *FD) {
726 // In the future, check other pragmas if they're implemented (e.g. pragma
727 // optimize 0 will probably map to this functionality too).
728 if(OptimizeOffPragmaLocation.isValid())
1
Taking true branch
729 AddOptnoneAttributeIfNoConflicts(FD, OptimizeOffPragmaLocation);
2
Calling 'Sema::AddOptnoneAttributeIfNoConflicts'
730}
731
732void Sema::AddOptnoneAttributeIfNoConflicts(FunctionDecl *FD,
733 SourceLocation Loc) {
734 // Don't add a conflicting attribute. No diagnostic is needed.
735 if (FD->hasAttr<MinSizeAttr>() || FD->hasAttr<AlwaysInlineAttr>())
3
Taking false branch
736 return;
737
738 // Add attributes only if required. Optnone requires noinline as well, but if
739 // either is already present then don't bother adding them.
740 if (!FD->hasAttr<OptimizeNoneAttr>())
4
Taking true branch
741 FD->addAttr(OptimizeNoneAttr::CreateImplicit(Context, Loc));
5
Calling 'OptimizeNoneAttr::CreateImplicit'
742 if (!FD->hasAttr<NoInlineAttr>())
743 FD->addAttr(NoInlineAttr::CreateImplicit(Context, Loc));
744}
745
746typedef std::vector<std::pair<unsigned, SourceLocation> > VisStack;
747enum : unsigned { NoVisibility = ~0U };
748
749void Sema::AddPushedVisibilityAttribute(Decl *D) {
750 if (!VisContext)
751 return;
752
753 NamedDecl *ND = dyn_cast<NamedDecl>(D);
754 if (ND && ND->getExplicitVisibility(NamedDecl::VisibilityForValue))
755 return;
756
757 VisStack *Stack = static_cast<VisStack*>(VisContext);
758 unsigned rawType = Stack->back().first;
759 if (rawType == NoVisibility) return;
760
761 VisibilityAttr::VisibilityType type
762 = (VisibilityAttr::VisibilityType) rawType;
763 SourceLocation loc = Stack->back().second;
764
765 D->addAttr(VisibilityAttr::CreateImplicit(Context, type, loc));
766}
767
768/// FreeVisContext - Deallocate and null out VisContext.
769void Sema::FreeVisContext() {
770 delete static_cast<VisStack*>(VisContext);
771 VisContext = nullptr;
772}
773
774static void PushPragmaVisibility(Sema &S, unsigned type, SourceLocation loc) {
775 // Put visibility on stack.
776 if (!S.VisContext)
777 S.VisContext = new VisStack;
778
779 VisStack *Stack = static_cast<VisStack*>(S.VisContext);
780 Stack->push_back(std::make_pair(type, loc));
781}
782
783void Sema::ActOnPragmaVisibility(const IdentifierInfo* VisType,
784 SourceLocation PragmaLoc) {
785 if (VisType) {
786 // Compute visibility to use.
787 VisibilityAttr::VisibilityType T;
788 if (!VisibilityAttr::ConvertStrToVisibilityType(VisType->getName(), T)) {
789 Diag(PragmaLoc, diag::warn_attribute_unknown_visibility) << VisType;
790 return;
791 }
792 PushPragmaVisibility(*this, T, PragmaLoc);
793 } else {
794 PopPragmaVisibility(false, PragmaLoc);
795 }
796}
797
798void Sema::ActOnPragmaFPContract(LangOptions::FPContractModeKind FPC) {
799 switch (FPC) {
800 case LangOptions::FPC_On:
801 FPFeatures.setAllowFPContractWithinStatement();
802 break;
803 case LangOptions::FPC_Fast:
804 FPFeatures.setAllowFPContractAcrossStatement();
805 break;
806 case LangOptions::FPC_Off:
807 FPFeatures.setDisallowFPContract();
808 break;
809 }
810}
811
812void Sema::ActOnPragmaFEnvAccess(LangOptions::FEnvAccessModeKind FPC) {
813 switch (FPC) {
814 case LangOptions::FEA_On:
815 FPFeatures.setAllowFEnvAccess();
816 break;
817 case LangOptions::FEA_Off:
818 FPFeatures.setDisallowFEnvAccess();
819 break;
820 }
821}
822
823
824void Sema::PushNamespaceVisibilityAttr(const VisibilityAttr *Attr,
825 SourceLocation Loc) {
826 // Visibility calculations will consider the namespace's visibility.
827 // Here we just want to note that we're in a visibility context
828 // which overrides any enclosing #pragma context, but doesn't itself
829 // contribute visibility.
830 PushPragmaVisibility(*this, NoVisibility, Loc);
831}
832
833void Sema::PopPragmaVisibility(bool IsNamespaceEnd, SourceLocation EndLoc) {
834 if (!VisContext) {
835 Diag(EndLoc, diag::err_pragma_pop_visibility_mismatch);
836 return;
837 }
838
839 // Pop visibility from stack
840 VisStack *Stack = static_cast<VisStack*>(VisContext);
841
842 const std::pair<unsigned, SourceLocation> *Back = &Stack->back();
843 bool StartsWithPragma = Back->first != NoVisibility;
844 if (StartsWithPragma && IsNamespaceEnd) {
845 Diag(Back->second, diag::err_pragma_push_visibility_mismatch);
846 Diag(EndLoc, diag::note_surrounding_namespace_ends_here);
847
848 // For better error recovery, eat all pushes inside the namespace.
849 do {
850 Stack->pop_back();
851 Back = &Stack->back();
852 StartsWithPragma = Back->first != NoVisibility;
853 } while (StartsWithPragma);
854 } else if (!StartsWithPragma && !IsNamespaceEnd) {
855 Diag(EndLoc, diag::err_pragma_pop_visibility_mismatch);
856 Diag(Back->second, diag::note_surrounding_namespace_starts_here);
857 return;
858 }
859
860 Stack->pop_back();
861 // To simplify the implementation, never keep around an empty stack.
862 if (Stack->empty())
863 FreeVisContext();
864}

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