Bug Summary

File:build-llvm/tools/clang/include/clang/AST/Attrs.inc
Warning:line 9312, 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 -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-8/lib/clang/8.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-8~svn345461/tools/clang/include -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/include -I /build/llvm-toolchain-snapshot-8~svn345461/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/8.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-8/lib/clang/8.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-8~svn345461/build-llvm/tools/clang/lib/Sema -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-10-27-211344-32123-1 -x c++ /build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaAttr.cpp -faddrsig

/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/Sema/SemaAttr.cpp

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

/build/llvm-toolchain-snapshot-8~svn345461/build-llvm/tools/clang/include/clang/AST/Attrs.inc

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